1 /* 2 * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. 3 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) 4 * Copyright (C) 2009 Igalia S.L. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY 16 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR 19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 23 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "config.h" 29 30 #include "AtomicString.h" 31 #include "CSSComputedStyleDeclaration.h" 32 #include "CSSMutableStyleDeclaration.h" 33 #include "CSSPropertyNames.h" 34 #include "CSSValueKeywords.h" 35 #include "Chrome.h" 36 #include "CreateLinkCommand.h" 37 #include "DocumentFragment.h" 38 #include "Editor.h" 39 #include "EditorClient.h" 40 #include "Event.h" 41 #include "EventHandler.h" 42 #include "FormatBlockCommand.h" 43 #include "Frame.h" 44 #include "HTMLFontElement.h" 45 #include "HTMLHRElement.h" 46 #include "HTMLImageElement.h" 47 #include "IndentOutdentCommand.h" 48 #include "InsertListCommand.h" 49 #include "Page.h" 50 #include "RenderBox.h" 51 #include "ReplaceSelectionCommand.h" 52 #include "Scrollbar.h" 53 #include "Settings.h" 54 #include "Sound.h" 55 #include "TypingCommand.h" 56 #include "UnlinkCommand.h" 57 #include "htmlediting.h" 58 #include "markup.h" 59 60 namespace WebCore { 61 62 using namespace HTMLNames; 63 64 class EditorInternalCommand { 65 public: 66 bool (*execute)(Frame*, Event*, EditorCommandSource, const String&); 67 bool (*isSupported)(Frame*, EditorCommandSource); 68 bool (*isEnabled)(Frame*, Event*, EditorCommandSource); 69 TriState (*state)(Frame*, Event*); 70 String (*value)(Frame*, Event*); 71 bool isTextInsertion; 72 bool allowExecutionWhenDisabled; 73 }; 74 75 typedef HashMap<String, const EditorInternalCommand*, CaseFoldingHash> CommandMap; 76 77 static const bool notTextInsertion = false; 78 static const bool isTextInsertion = true; 79 80 static const bool allowExecutionWhenDisabled = true; 81 static const bool doNotAllowExecutionWhenDisabled = false; 82 83 // Related to Editor::selectionForCommand. 84 // Certain operations continue to use the target control's selection even if the event handler 85 // already moved the selection outside of the text control. 86 static Frame* targetFrame(Frame* frame, Event* event) 87 { 88 if (!event) 89 return frame; 90 Node* node = event->target()->toNode(); 91 if (!node) 92 return frame; 93 return node->document()->frame(); 94 } 95 96 static bool applyCommandToFrame(Frame* frame, EditorCommandSource source, EditAction action, CSSMutableStyleDeclaration* style) 97 { 98 // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that? 99 switch (source) { 100 case CommandFromMenuOrKeyBinding: 101 frame->editor()->applyStyleToSelection(style, action); 102 return true; 103 case CommandFromDOM: 104 case CommandFromDOMWithUserInterface: 105 frame->editor()->applyStyle(style); 106 return true; 107 } 108 ASSERT_NOT_REACHED(); 109 return false; 110 } 111 112 static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue) 113 { 114 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 115 style->setProperty(propertyID, propertyValue); 116 return applyCommandToFrame(frame, source, action, style.get()); 117 } 118 119 static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, int propertyValue) 120 { 121 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 122 style->setProperty(propertyID, propertyValue); 123 return applyCommandToFrame(frame, source, action, style.get()); 124 } 125 126 // FIXME: executeToggleStyleInList does not handle complicated cases such as <b><u>hello</u>world</b> properly. 127 // This function must use Editor::selectionHasStyle to determine the current style but we cannot fix this 128 // until https://bugs.webkit.org/show_bug.cgi?id=27818 is resolved. 129 static bool executeToggleStyleInList(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, CSSValue* value) 130 { 131 ExceptionCode ec = 0; 132 Node* nodeToRemove = 0; 133 RefPtr<CSSComputedStyleDeclaration> selectionStyle = frame->selectionComputedStyle(nodeToRemove); 134 RefPtr<CSSValue> selectedCSSValue = selectionStyle->getPropertyCSSValue(propertyID); 135 String newStyle = "none"; 136 if (selectedCSSValue->isValueList()) { 137 RefPtr<CSSValueList> selectedCSSValueList = static_cast<CSSValueList*>(selectedCSSValue.get()); 138 if (!selectedCSSValueList->removeAll(value)) 139 selectedCSSValueList->append(value); 140 if (selectedCSSValueList->length()) 141 newStyle = selectedCSSValueList->cssText(); 142 143 } else if (selectedCSSValue->cssText() == "none") 144 newStyle = value->cssText(); 145 146 ASSERT(ec == 0); 147 if (nodeToRemove) { 148 nodeToRemove->remove(ec); 149 ASSERT(ec == 0); 150 } 151 152 // FIXME: We shouldn't be having to convert new style into text. We should have setPropertyCSSValue. 153 RefPtr<CSSMutableStyleDeclaration> newMutableStyle = CSSMutableStyleDeclaration::create(); 154 newMutableStyle->setProperty(propertyID, newStyle,ec); 155 return applyCommandToFrame(frame, source, action, newMutableStyle.get()); 156 } 157 158 static bool executeToggleStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const char* offValue, const char* onValue) 159 { 160 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 161 style->setProperty(propertyID, onValue); // We need to add this style to pass it to selectionStartHasStyle / selectionHasStyle 162 163 // Style is considered present when 164 // mac: present at the beginning of selection 165 // other: present throughout the selection 166 Settings* settings = frame->document()->settings(); 167 bool styleIsPresent; 168 if (settings && settings->editingBehavior() == EditingMacBehavior) 169 styleIsPresent = frame->editor()->selectionStartHasStyle(style.get()); 170 else 171 styleIsPresent = frame->editor()->selectionHasStyle(style.get()) == TrueTriState; 172 173 style->setProperty(propertyID, styleIsPresent ? offValue : onValue); 174 return applyCommandToFrame(frame, source, action, style.get()); 175 } 176 177 static bool executeApplyParagraphStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue) 178 { 179 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 180 style->setProperty(propertyID, propertyValue); 181 // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that? 182 switch (source) { 183 case CommandFromMenuOrKeyBinding: 184 frame->editor()->applyParagraphStyleToSelection(style.get(), action); 185 return true; 186 case CommandFromDOM: 187 case CommandFromDOMWithUserInterface: 188 frame->editor()->applyParagraphStyle(style.get()); 189 return true; 190 } 191 ASSERT_NOT_REACHED(); 192 return false; 193 } 194 195 static bool executeInsertFragment(Frame* frame, PassRefPtr<DocumentFragment> fragment) 196 { 197 applyCommand(ReplaceSelectionCommand::create(frame->document(), fragment, 198 false, false, false, true, false, EditActionUnspecified)); 199 return true; 200 } 201 202 static bool executeInsertNode(Frame* frame, PassRefPtr<Node> content) 203 { 204 RefPtr<DocumentFragment> fragment = DocumentFragment::create(frame->document()); 205 ExceptionCode ec = 0; 206 fragment->appendChild(content, ec); 207 if (ec) 208 return false; 209 return executeInsertFragment(frame, fragment.release()); 210 } 211 212 static bool expandSelectionToGranularity(Frame* frame, TextGranularity granularity) 213 { 214 VisibleSelection selection = frame->selection()->selection(); 215 selection.expandUsingGranularity(granularity); 216 RefPtr<Range> newRange = selection.toNormalizedRange(); 217 if (!newRange) 218 return false; 219 ExceptionCode ec = 0; 220 if (newRange->collapsed(ec)) 221 return false; 222 RefPtr<Range> oldRange = frame->selection()->selection().toNormalizedRange(); 223 EAffinity affinity = frame->selection()->affinity(); 224 if (!frame->editor()->client()->shouldChangeSelectedRange(oldRange.get(), newRange.get(), affinity, false)) 225 return false; 226 frame->selection()->setSelectedRange(newRange.get(), affinity, true); 227 return true; 228 } 229 230 static TriState stateStyle(Frame* frame, int propertyID, const char* desiredValue) 231 { 232 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 233 style->setProperty(propertyID, desiredValue); 234 return frame->editor()->selectionHasStyle(style.get()); 235 } 236 237 static String valueStyle(Frame* frame, int propertyID) 238 { 239 return frame->selectionStartStylePropertyValue(propertyID); 240 } 241 242 static TriState stateTextWritingDirection(Frame* frame, WritingDirection direction) 243 { 244 bool hasNestedOrMultipleEmbeddings; 245 WritingDirection selectionDirection = frame->editor()->textDirectionForSelection(hasNestedOrMultipleEmbeddings); 246 return (selectionDirection == direction && !hasNestedOrMultipleEmbeddings) ? TrueTriState : FalseTriState; 247 } 248 249 static int verticalScrollDistance(Frame* frame) 250 { 251 Node* focusedNode = frame->document()->focusedNode(); 252 if (!focusedNode) 253 return 0; 254 RenderObject* renderer = focusedNode->renderer(); 255 if (!renderer || !renderer->isBox()) 256 return 0; 257 RenderStyle* style = renderer->style(); 258 if (!style) 259 return 0; 260 if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || renderer->isTextArea())) 261 return 0; 262 int height = toRenderBox(renderer)->clientHeight(); 263 return max(max<int>(height * Scrollbar::minFractionToStepWhenPaging(), height - Scrollbar::maxOverlapBetweenPages()), 1); 264 } 265 266 static RefPtr<Range> unionDOMRanges(Range* a, Range* b) 267 { 268 ExceptionCode ec = 0; 269 Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ec) <= 0 ? a : b; 270 ASSERT(!ec); 271 Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ec) <= 0 ? b : a; 272 ASSERT(!ec); 273 274 return Range::create(a->startContainer(ec)->ownerDocument(), start->startContainer(ec), start->startOffset(ec), end->endContainer(ec), end->endOffset(ec)); 275 } 276 277 // Execute command functions 278 279 static bool executeBackColor(Frame* frame, Event*, EditorCommandSource source, const String& value) 280 { 281 return executeApplyStyle(frame, source, EditActionSetBackgroundColor, CSSPropertyBackgroundColor, value); 282 } 283 284 static bool executeCopy(Frame* frame, Event*, EditorCommandSource, const String&) 285 { 286 frame->editor()->copy(); 287 return true; 288 } 289 290 static bool executeCreateLink(Frame* frame, Event*, EditorCommandSource, const String& value) 291 { 292 // FIXME: If userInterface is true, we should display a dialog box to let the user enter a URL. 293 if (value.isEmpty()) 294 return false; 295 applyCommand(CreateLinkCommand::create(frame->document(), value)); 296 return true; 297 } 298 299 static bool executeCut(Frame* frame, Event*, EditorCommandSource, const String&) 300 { 301 frame->editor()->cut(); 302 return true; 303 } 304 305 static bool executeDelete(Frame* frame, Event*, EditorCommandSource source, const String&) 306 { 307 switch (source) { 308 case CommandFromMenuOrKeyBinding: 309 // Doesn't modify the text if the current selection isn't a range. 310 frame->editor()->performDelete(); 311 return true; 312 case CommandFromDOM: 313 case CommandFromDOMWithUserInterface: 314 // If the current selection is a caret, delete the preceding character. IE performs forwardDelete, but we currently side with Firefox. 315 // Doesn't scroll to make the selection visible, or modify the kill ring (this time, siding with IE, not Firefox). 316 TypingCommand::deleteKeyPressed(frame->document(), frame->selectionGranularity() == WordGranularity); 317 return true; 318 } 319 ASSERT_NOT_REACHED(); 320 return false; 321 } 322 323 static bool executeDeleteBackward(Frame* frame, Event*, EditorCommandSource, const String&) 324 { 325 frame->editor()->deleteWithDirection(SelectionController::BACKWARD, CharacterGranularity, false, true); 326 return true; 327 } 328 329 static bool executeDeleteBackwardByDecomposingPreviousCharacter(Frame* frame, Event*, EditorCommandSource, const String&) 330 { 331 LOG_ERROR("DeleteBackwardByDecomposingPreviousCharacter is not implemented, doing DeleteBackward instead"); 332 frame->editor()->deleteWithDirection(SelectionController::BACKWARD, CharacterGranularity, false, true); 333 return true; 334 } 335 336 static bool executeDeleteForward(Frame* frame, Event*, EditorCommandSource, const String&) 337 { 338 frame->editor()->deleteWithDirection(SelectionController::FORWARD, CharacterGranularity, false, true); 339 return true; 340 } 341 342 static bool executeDeleteToBeginningOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 343 { 344 frame->editor()->deleteWithDirection(SelectionController::BACKWARD, LineBoundary, true, false); 345 return true; 346 } 347 348 static bool executeDeleteToBeginningOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 349 { 350 frame->editor()->deleteWithDirection(SelectionController::BACKWARD, ParagraphBoundary, true, false); 351 return true; 352 } 353 354 static bool executeDeleteToEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 355 { 356 // Despite its name, this command should delete the newline at the end of 357 // a paragraph if you are at the end of a paragraph (like DeleteToEndOfParagraph). 358 frame->editor()->deleteWithDirection(SelectionController::FORWARD, LineBoundary, true, false); 359 return true; 360 } 361 362 static bool executeDeleteToEndOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 363 { 364 // Despite its name, this command should delete the newline at the end of 365 // a paragraph if you are at the end of a paragraph. 366 frame->editor()->deleteWithDirection(SelectionController::FORWARD, ParagraphBoundary, true, false); 367 return true; 368 } 369 370 static bool executeDeleteToMark(Frame* frame, Event*, EditorCommandSource, const String&) 371 { 372 RefPtr<Range> mark = frame->mark().toNormalizedRange(); 373 if (mark) { 374 SelectionController* selection = frame->selection(); 375 bool selected = selection->setSelectedRange(unionDOMRanges(mark.get(), frame->editor()->selectedRange().get()).get(), DOWNSTREAM, true); 376 ASSERT(selected); 377 if (!selected) 378 return false; 379 } 380 frame->editor()->performDelete(); 381 frame->setMark(frame->selection()->selection()); 382 return true; 383 } 384 385 static bool executeDeleteWordBackward(Frame* frame, Event*, EditorCommandSource, const String&) 386 { 387 frame->editor()->deleteWithDirection(SelectionController::BACKWARD, WordGranularity, true, false); 388 return true; 389 } 390 391 static bool executeDeleteWordForward(Frame* frame, Event*, EditorCommandSource, const String&) 392 { 393 frame->editor()->deleteWithDirection(SelectionController::FORWARD, WordGranularity, true, false); 394 return true; 395 } 396 397 static bool executeFindString(Frame* frame, Event*, EditorCommandSource, const String& value) 398 { 399 return frame->findString(value, true, false, true, false); 400 } 401 402 static bool executeFontName(Frame* frame, Event*, EditorCommandSource source, const String& value) 403 { 404 return executeApplyStyle(frame, source, EditActionSetFont, CSSPropertyFontFamily, value); 405 } 406 407 static bool executeFontSize(Frame* frame, Event*, EditorCommandSource source, const String& value) 408 { 409 int size; 410 if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size)) 411 return false; 412 return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontSize, size); 413 } 414 415 static bool executeFontSizeDelta(Frame* frame, Event*, EditorCommandSource source, const String& value) 416 { 417 return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyWebkitFontSizeDelta, value); 418 } 419 420 static bool executeForeColor(Frame* frame, Event*, EditorCommandSource source, const String& value) 421 { 422 return executeApplyStyle(frame, source, EditActionSetColor, CSSPropertyColor, value); 423 } 424 425 static bool executeFormatBlock(Frame* frame, Event*, EditorCommandSource, const String& value) 426 { 427 String tagName = value.lower(); 428 if (tagName[0] == '<' && tagName[tagName.length() - 1] == '>') 429 tagName = tagName.substring(1, tagName.length() - 2); 430 if (!validBlockTag(tagName)) 431 return false; 432 applyCommand(FormatBlockCommand::create(frame->document(), tagName)); 433 return true; 434 } 435 436 static bool executeForwardDelete(Frame* frame, Event*, EditorCommandSource source, const String&) 437 { 438 switch (source) { 439 case CommandFromMenuOrKeyBinding: 440 frame->editor()->deleteWithDirection(SelectionController::FORWARD, CharacterGranularity, false, true); 441 return true; 442 case CommandFromDOM: 443 case CommandFromDOMWithUserInterface: 444 // Doesn't scroll to make the selection visible, or modify the kill ring. 445 // ForwardDelete is not implemented in IE or Firefox, so this behavior is only needed for 446 // backward compatibility with ourselves, and for consistency with Delete. 447 TypingCommand::forwardDeleteKeyPressed(frame->document()); 448 return true; 449 } 450 ASSERT_NOT_REACHED(); 451 return false; 452 } 453 454 static bool executeIgnoreSpelling(Frame* frame, Event*, EditorCommandSource, const String&) 455 { 456 frame->editor()->ignoreSpelling(); 457 return true; 458 } 459 460 static bool executeIndent(Frame* frame, Event*, EditorCommandSource, const String&) 461 { 462 applyCommand(IndentOutdentCommand::create(frame->document(), IndentOutdentCommand::Indent)); 463 return true; 464 } 465 466 static bool executeInsertBacktab(Frame* frame, Event* event, EditorCommandSource, const String&) 467 { 468 return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\t", event, false, true); 469 } 470 471 static bool executeInsertHorizontalRule(Frame* frame, Event*, EditorCommandSource, const String& value) 472 { 473 RefPtr<HTMLHRElement> hr = new HTMLHRElement(hrTag, frame->document()); 474 if (!value.isEmpty()) 475 hr->setAttribute(hr->idAttributeName(), value); 476 return executeInsertNode(frame, hr.release()); 477 } 478 479 static bool executeInsertHTML(Frame* frame, Event*, EditorCommandSource, const String& value) 480 { 481 return executeInsertFragment(frame, createFragmentFromMarkup(frame->document(), value, "")); 482 } 483 484 static bool executeInsertImage(Frame* frame, Event*, EditorCommandSource, const String& value) 485 { 486 // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image. 487 RefPtr<HTMLImageElement> image = new HTMLImageElement(imgTag, frame->document()); 488 image->setSrc(value); 489 return executeInsertNode(frame, image.release()); 490 } 491 492 static bool executeInsertLineBreak(Frame* frame, Event* event, EditorCommandSource source, const String&) 493 { 494 switch (source) { 495 case CommandFromMenuOrKeyBinding: 496 return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\n", event, true); 497 case CommandFromDOM: 498 case CommandFromDOMWithUserInterface: 499 // Doesn't scroll to make the selection visible, or modify the kill ring. 500 // InsertLineBreak is not implemented in IE or Firefox, so this behavior is only needed for 501 // backward compatibility with ourselves, and for consistency with other commands. 502 TypingCommand::insertLineBreak(frame->document()); 503 return true; 504 } 505 ASSERT_NOT_REACHED(); 506 return false; 507 } 508 509 static bool executeInsertNewline(Frame* frame, Event* event, EditorCommandSource, const String&) 510 { 511 Frame* targetFrame = WebCore::targetFrame(frame, event); 512 return targetFrame->eventHandler()->handleTextInputEvent("\n", event, !targetFrame->editor()->canEditRichly()); 513 } 514 515 static bool executeInsertNewlineInQuotedContent(Frame* frame, Event*, EditorCommandSource, const String&) 516 { 517 TypingCommand::insertParagraphSeparatorInQuotedContent(frame->document()); 518 return true; 519 } 520 521 static bool executeInsertOrderedList(Frame* frame, Event*, EditorCommandSource, const String&) 522 { 523 applyCommand(InsertListCommand::create(frame->document(), InsertListCommand::OrderedList)); 524 return true; 525 } 526 527 static bool executeInsertParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 528 { 529 TypingCommand::insertParagraphSeparator(frame->document()); 530 return true; 531 } 532 533 static bool executeInsertTab(Frame* frame, Event* event, EditorCommandSource, const String&) 534 { 535 return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\t", event, false, false); 536 } 537 538 static bool executeInsertText(Frame* frame, Event*, EditorCommandSource, const String& value) 539 { 540 TypingCommand::insertText(frame->document(), value); 541 return true; 542 } 543 544 static bool executeInsertUnorderedList(Frame* frame, Event*, EditorCommandSource, const String&) 545 { 546 applyCommand(InsertListCommand::create(frame->document(), InsertListCommand::UnorderedList)); 547 return true; 548 } 549 550 static bool executeJustifyCenter(Frame* frame, Event*, EditorCommandSource source, const String&) 551 { 552 return executeApplyParagraphStyle(frame, source, EditActionCenter, CSSPropertyTextAlign, "center"); 553 } 554 555 static bool executeJustifyFull(Frame* frame, Event*, EditorCommandSource source, const String&) 556 { 557 return executeApplyParagraphStyle(frame, source, EditActionJustify, CSSPropertyTextAlign, "justify"); 558 } 559 560 static bool executeJustifyLeft(Frame* frame, Event*, EditorCommandSource source, const String&) 561 { 562 return executeApplyParagraphStyle(frame, source, EditActionAlignLeft, CSSPropertyTextAlign, "left"); 563 } 564 565 static bool executeJustifyRight(Frame* frame, Event*, EditorCommandSource source, const String&) 566 { 567 return executeApplyParagraphStyle(frame, source, EditActionAlignRight, CSSPropertyTextAlign, "right"); 568 } 569 570 static bool executeMakeTextWritingDirectionLeftToRight(Frame* frame, Event*, EditorCommandSource, const String&) 571 { 572 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 573 style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed); 574 style->setProperty(CSSPropertyDirection, CSSValueLtr); 575 frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); 576 return true; 577 } 578 579 static bool executeMakeTextWritingDirectionNatural(Frame* frame, Event*, EditorCommandSource, const String&) 580 { 581 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 582 style->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal); 583 frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); 584 return true; 585 } 586 587 static bool executeMakeTextWritingDirectionRightToLeft(Frame* frame, Event*, EditorCommandSource, const String&) 588 { 589 RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); 590 style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed); 591 style->setProperty(CSSPropertyDirection, CSSValueRtl); 592 frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); 593 return true; 594 } 595 596 static bool executeMoveBackward(Frame* frame, Event*, EditorCommandSource, const String&) 597 { 598 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, CharacterGranularity, true); 599 return true; 600 } 601 602 static bool executeMoveBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 603 { 604 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, CharacterGranularity, true); 605 return true; 606 } 607 608 static bool executeMoveDown(Frame* frame, Event*, EditorCommandSource, const String&) 609 { 610 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, LineGranularity, true); 611 return true; 612 } 613 614 static bool executeMoveDownAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 615 { 616 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, LineGranularity, true); 617 return true; 618 } 619 620 static bool executeMoveForward(Frame* frame, Event*, EditorCommandSource, const String&) 621 { 622 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, CharacterGranularity, true); 623 return true; 624 } 625 626 static bool executeMoveForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 627 { 628 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, CharacterGranularity, true); 629 return true; 630 } 631 632 static bool executeMoveLeft(Frame* frame, Event*, EditorCommandSource, const String&) 633 { 634 frame->selection()->modify(SelectionController::MOVE, SelectionController::LEFT, CharacterGranularity, true); 635 return true; 636 } 637 638 static bool executeMoveLeftAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 639 { 640 frame->selection()->modify(SelectionController::EXTEND, SelectionController::LEFT, CharacterGranularity, true); 641 return true; 642 } 643 644 static bool executeMovePageDown(Frame* frame, Event*, EditorCommandSource, const String&) 645 { 646 int distance = verticalScrollDistance(frame); 647 if (!distance) 648 return false; 649 return frame->selection()->modify(SelectionController::MOVE, distance, true); 650 } 651 652 static bool executeMovePageDownAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 653 { 654 int distance = verticalScrollDistance(frame); 655 if (!distance) 656 return false; 657 return frame->selection()->modify(SelectionController::EXTEND, distance, true); 658 } 659 660 static bool executeMovePageUp(Frame* frame, Event*, EditorCommandSource, const String&) 661 { 662 int distance = verticalScrollDistance(frame); 663 if (!distance) 664 return false; 665 return frame->selection()->modify(SelectionController::MOVE, -distance, true); 666 } 667 668 static bool executeMovePageUpAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 669 { 670 int distance = verticalScrollDistance(frame); 671 if (!distance) 672 return false; 673 return frame->selection()->modify(SelectionController::EXTEND, -distance, true); 674 } 675 676 static bool executeMoveRight(Frame* frame, Event*, EditorCommandSource, const String&) 677 { 678 frame->selection()->modify(SelectionController::MOVE, SelectionController::RIGHT, CharacterGranularity, true); 679 return true; 680 } 681 682 static bool executeMoveRightAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 683 { 684 frame->selection()->modify(SelectionController::EXTEND, SelectionController::RIGHT, CharacterGranularity, true); 685 return true; 686 } 687 688 static bool executeMoveToBeginningOfDocument(Frame* frame, Event*, EditorCommandSource, const String&) 689 { 690 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, DocumentBoundary, true); 691 return true; 692 } 693 694 static bool executeMoveToBeginningOfDocumentAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 695 { 696 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, DocumentBoundary, true); 697 return true; 698 } 699 700 static bool executeMoveToBeginningOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 701 { 702 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, LineBoundary, true); 703 return true; 704 } 705 706 static bool executeMoveToBeginningOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 707 { 708 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, LineBoundary, true); 709 return true; 710 } 711 712 static bool executeMoveToBeginningOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 713 { 714 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, ParagraphBoundary, true); 715 return true; 716 } 717 718 static bool executeMoveToBeginningOfParagraphAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 719 { 720 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, ParagraphBoundary, true); 721 return true; 722 } 723 724 static bool executeMoveToBeginningOfSentence(Frame* frame, Event*, EditorCommandSource, const String&) 725 { 726 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, SentenceBoundary, true); 727 return true; 728 } 729 730 static bool executeMoveToBeginningOfSentenceAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 731 { 732 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, SentenceBoundary, true); 733 return true; 734 } 735 736 static bool executeMoveToEndOfDocument(Frame* frame, Event*, EditorCommandSource, const String&) 737 { 738 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, DocumentBoundary, true); 739 return true; 740 } 741 742 static bool executeMoveToEndOfDocumentAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 743 { 744 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, DocumentBoundary, true); 745 return true; 746 } 747 748 static bool executeMoveToEndOfSentence(Frame* frame, Event*, EditorCommandSource, const String&) 749 { 750 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, SentenceBoundary, true); 751 return true; 752 } 753 754 static bool executeMoveToEndOfSentenceAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 755 { 756 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, SentenceBoundary, true); 757 return true; 758 } 759 760 static bool executeMoveToEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 761 { 762 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, LineBoundary, true); 763 return true; 764 } 765 766 static bool executeMoveToEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 767 { 768 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, LineBoundary, true); 769 return true; 770 } 771 772 static bool executeMoveToEndOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 773 { 774 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, ParagraphBoundary, true); 775 return true; 776 } 777 778 static bool executeMoveToEndOfParagraphAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 779 { 780 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, ParagraphBoundary, true); 781 return true; 782 } 783 784 static bool executeMoveParagraphBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 785 { 786 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, ParagraphGranularity, true); 787 return true; 788 } 789 790 static bool executeMoveParagraphForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 791 { 792 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, ParagraphGranularity, true); 793 return true; 794 } 795 796 static bool executeMoveUp(Frame* frame, Event*, EditorCommandSource, const String&) 797 { 798 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, LineGranularity, true); 799 return true; 800 } 801 802 static bool executeMoveUpAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 803 { 804 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, LineGranularity, true); 805 return true; 806 } 807 808 static bool executeMoveWordBackward(Frame* frame, Event*, EditorCommandSource, const String&) 809 { 810 frame->selection()->modify(SelectionController::MOVE, SelectionController::BACKWARD, WordGranularity, true); 811 return true; 812 } 813 814 static bool executeMoveWordBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 815 { 816 frame->selection()->modify(SelectionController::EXTEND, SelectionController::BACKWARD, WordGranularity, true); 817 return true; 818 } 819 820 static bool executeMoveWordForward(Frame* frame, Event*, EditorCommandSource, const String&) 821 { 822 frame->selection()->modify(SelectionController::MOVE, SelectionController::FORWARD, WordGranularity, true); 823 return true; 824 } 825 826 static bool executeMoveWordForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 827 { 828 frame->selection()->modify(SelectionController::EXTEND, SelectionController::FORWARD, WordGranularity, true); 829 return true; 830 } 831 832 static bool executeMoveWordLeft(Frame* frame, Event*, EditorCommandSource, const String&) 833 { 834 frame->selection()->modify(SelectionController::MOVE, SelectionController::LEFT, WordGranularity, true); 835 return true; 836 } 837 838 static bool executeMoveWordLeftAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 839 { 840 frame->selection()->modify(SelectionController::EXTEND, SelectionController::LEFT, WordGranularity, true); 841 return true; 842 } 843 844 static bool executeMoveWordRight(Frame* frame, Event*, EditorCommandSource, const String&) 845 { 846 frame->selection()->modify(SelectionController::MOVE, SelectionController::RIGHT, WordGranularity, true); 847 return true; 848 } 849 850 static bool executeMoveWordRightAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 851 { 852 frame->selection()->modify(SelectionController::EXTEND, SelectionController::RIGHT, WordGranularity, true); 853 return true; 854 } 855 856 static bool executeMoveToLeftEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 857 { 858 frame->selection()->modify(SelectionController::MOVE, SelectionController::LEFT, LineBoundary, true); 859 return true; 860 } 861 862 static bool executeMoveToLeftEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 863 { 864 frame->selection()->modify(SelectionController::EXTEND, SelectionController::LEFT, LineBoundary, true); 865 return true; 866 } 867 868 static bool executeMoveToRightEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) 869 { 870 frame->selection()->modify(SelectionController::MOVE, SelectionController::RIGHT, LineBoundary, true); 871 return true; 872 } 873 874 static bool executeMoveToRightEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) 875 { 876 frame->selection()->modify(SelectionController::EXTEND, SelectionController::RIGHT, LineBoundary, true); 877 return true; 878 } 879 880 static bool executeOutdent(Frame* frame, Event*, EditorCommandSource, const String&) 881 { 882 applyCommand(IndentOutdentCommand::create(frame->document(), IndentOutdentCommand::Outdent)); 883 return true; 884 } 885 886 static bool executePaste(Frame* frame, Event*, EditorCommandSource, const String&) 887 { 888 frame->editor()->paste(); 889 return true; 890 } 891 892 static bool executePasteAndMatchStyle(Frame* frame, Event*, EditorCommandSource, const String&) 893 { 894 frame->editor()->pasteAsPlainText(); 895 return true; 896 } 897 898 static bool executePrint(Frame* frame, Event*, EditorCommandSource, const String&) 899 { 900 Page* page = frame->page(); 901 if (!page) 902 return false; 903 page->chrome()->print(frame); 904 return true; 905 } 906 907 static bool executeRedo(Frame* frame, Event*, EditorCommandSource, const String&) 908 { 909 frame->editor()->redo(); 910 return true; 911 } 912 913 static bool executeRemoveFormat(Frame* frame, Event*, EditorCommandSource, const String&) 914 { 915 frame->editor()->removeFormattingAndStyle(); 916 return true; 917 } 918 919 static bool executeSelectAll(Frame* frame, Event*, EditorCommandSource, const String&) 920 { 921 frame->selection()->selectAll(); 922 return true; 923 } 924 925 static bool executeSelectLine(Frame* frame, Event*, EditorCommandSource, const String&) 926 { 927 return expandSelectionToGranularity(frame, LineGranularity); 928 } 929 930 static bool executeSelectParagraph(Frame* frame, Event*, EditorCommandSource, const String&) 931 { 932 return expandSelectionToGranularity(frame, ParagraphGranularity); 933 } 934 935 static bool executeSelectSentence(Frame* frame, Event*, EditorCommandSource, const String&) 936 { 937 return expandSelectionToGranularity(frame, SentenceGranularity); 938 } 939 940 static bool executeSelectToMark(Frame* frame, Event*, EditorCommandSource, const String&) 941 { 942 RefPtr<Range> mark = frame->mark().toNormalizedRange(); 943 RefPtr<Range> selection = frame->editor()->selectedRange(); 944 if (!mark || !selection) { 945 systemBeep(); 946 return false; 947 } 948 frame->selection()->setSelectedRange(unionDOMRanges(mark.get(), selection.get()).get(), DOWNSTREAM, true); 949 return true; 950 } 951 952 static bool executeSelectWord(Frame* frame, Event*, EditorCommandSource, const String&) 953 { 954 return expandSelectionToGranularity(frame, WordGranularity); 955 } 956 957 static bool executeSetMark(Frame* frame, Event*, EditorCommandSource, const String&) 958 { 959 frame->setMark(frame->selection()->selection()); 960 return true; 961 } 962 963 static bool executeStrikethrough(Frame* frame, Event*, EditorCommandSource source, const String&) 964 { 965 RefPtr<CSSPrimitiveValue> lineThrough = CSSPrimitiveValue::createIdentifier(CSSValueLineThrough); 966 return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, lineThrough.get()); 967 } 968 969 static bool executeStyleWithCSS(Frame* frame, Event*, EditorCommandSource, const String& value) 970 { 971 if (value != "false" && value != "true") 972 return false; 973 974 frame->editor()->setShouldStyleWithCSS(value == "true" ? true : false); 975 return true; 976 } 977 978 static bool executeSubscript(Frame* frame, Event*, EditorCommandSource source, const String&) 979 { 980 return executeToggleStyle(frame, source, EditActionSubscript, CSSPropertyVerticalAlign, "baseline", "sub"); 981 } 982 983 static bool executeSuperscript(Frame* frame, Event*, EditorCommandSource source, const String&) 984 { 985 return executeToggleStyle(frame, source, EditActionSuperscript, CSSPropertyVerticalAlign, "baseline", "super"); 986 } 987 988 static bool executeSwapWithMark(Frame* frame, Event*, EditorCommandSource, const String&) 989 { 990 const VisibleSelection& mark = frame->mark(); 991 const VisibleSelection& selection = frame->selection()->selection(); 992 if (mark.isNone() || selection.isNone()) { 993 systemBeep(); 994 return false; 995 } 996 frame->selection()->setSelection(mark); 997 frame->setMark(selection); 998 return true; 999 } 1000 1001 static bool executeToggleBold(Frame* frame, Event*, EditorCommandSource source, const String&) 1002 { 1003 return executeToggleStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontWeight, "normal", "bold"); 1004 } 1005 1006 static bool executeToggleItalic(Frame* frame, Event*, EditorCommandSource source, const String&) 1007 { 1008 return executeToggleStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontStyle, "normal", "italic"); 1009 } 1010 1011 static bool executeTranspose(Frame* frame, Event*, EditorCommandSource, const String&) 1012 { 1013 frame->editor()->transpose(); 1014 return true; 1015 } 1016 1017 static bool executeUnderline(Frame* frame, Event*, EditorCommandSource source, const String&) 1018 { 1019 RefPtr<CSSPrimitiveValue> underline = CSSPrimitiveValue::createIdentifier(CSSValueUnderline); 1020 return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, underline.get()); 1021 } 1022 1023 static bool executeUndo(Frame* frame, Event*, EditorCommandSource, const String&) 1024 { 1025 frame->editor()->undo(); 1026 return true; 1027 } 1028 1029 static bool executeUnlink(Frame* frame, Event*, EditorCommandSource, const String&) 1030 { 1031 applyCommand(UnlinkCommand::create(frame->document())); 1032 return true; 1033 } 1034 1035 static bool executeUnscript(Frame* frame, Event*, EditorCommandSource source, const String&) 1036 { 1037 return executeApplyStyle(frame, source, EditActionUnscript, CSSPropertyVerticalAlign, "baseline"); 1038 } 1039 1040 static bool executeUnselect(Frame* frame, Event*, EditorCommandSource, const String&) 1041 { 1042 frame->selection()->clear(); 1043 return true; 1044 } 1045 1046 static bool executeYank(Frame* frame, Event*, EditorCommandSource, const String&) 1047 { 1048 frame->editor()->insertTextWithoutSendingTextEvent(frame->editor()->yankFromKillRing(), false, 0); 1049 frame->editor()->setKillRingToYankedState(); 1050 return true; 1051 } 1052 1053 static bool executeYankAndSelect(Frame* frame, Event*, EditorCommandSource, const String&) 1054 { 1055 frame->editor()->insertTextWithoutSendingTextEvent(frame->editor()->yankFromKillRing(), true, 0); 1056 frame->editor()->setKillRingToYankedState(); 1057 return true; 1058 } 1059 1060 // Supported functions 1061 1062 static bool supported(Frame*, EditorCommandSource) 1063 { 1064 return true; 1065 } 1066 1067 static bool supportedFromMenuOrKeyBinding(Frame*, EditorCommandSource source) 1068 { 1069 return source == CommandFromMenuOrKeyBinding; 1070 } 1071 1072 static bool supportedPaste(Frame* frame, EditorCommandSource source) 1073 { 1074 switch (source) { 1075 case CommandFromMenuOrKeyBinding: 1076 return true; 1077 case CommandFromDOM: 1078 case CommandFromDOMWithUserInterface: { 1079 Settings* settings = frame ? frame->settings() : 0; 1080 return settings && settings->isDOMPasteAllowed(); 1081 } 1082 } 1083 ASSERT_NOT_REACHED(); 1084 return false; 1085 } 1086 1087 // Enabled functions 1088 1089 static bool enabled(Frame*, Event*, EditorCommandSource) 1090 { 1091 return true; 1092 } 1093 1094 static bool enabledVisibleSelection(Frame* frame, Event* event, EditorCommandSource) 1095 { 1096 // The term "visible" here includes a caret in editable text or a range in any text. 1097 const VisibleSelection& selection = frame->editor()->selectionForCommand(event); 1098 return (selection.isCaret() && selection.isContentEditable()) || selection.isRange(); 1099 } 1100 1101 static bool caretBrowsingEnabled(Frame* frame) 1102 { 1103 return frame->settings() && frame->settings()->caretBrowsingEnabled(); 1104 } 1105 1106 static EditorCommandSource dummyEditorCommandSource = static_cast<EditorCommandSource>(0); 1107 1108 static bool enabledVisibleSelectionOrCaretBrowsing(Frame* frame, Event* event, EditorCommandSource) 1109 { 1110 // The EditorCommandSource parameter is unused in enabledVisibleSelection, so just pass a dummy variable 1111 return caretBrowsingEnabled(frame) || enabledVisibleSelection(frame, event, dummyEditorCommandSource); 1112 } 1113 1114 static bool enabledVisibleSelectionAndMark(Frame* frame, Event* event, EditorCommandSource) 1115 { 1116 const VisibleSelection& selection = frame->editor()->selectionForCommand(event); 1117 return ((selection.isCaret() && selection.isContentEditable()) || selection.isRange()) 1118 && frame->mark().isCaretOrRange(); 1119 } 1120 1121 static bool enableCaretInEditableText(Frame* frame, Event* event, EditorCommandSource) 1122 { 1123 const VisibleSelection& selection = frame->editor()->selectionForCommand(event); 1124 return selection.isCaret() && selection.isContentEditable(); 1125 } 1126 1127 static bool enabledCopy(Frame* frame, Event*, EditorCommandSource) 1128 { 1129 return frame->editor()->canDHTMLCopy() || frame->editor()->canCopy(); 1130 } 1131 1132 static bool enabledCut(Frame* frame, Event*, EditorCommandSource) 1133 { 1134 return frame->editor()->canDHTMLCut() || frame->editor()->canCut(); 1135 } 1136 1137 static bool enabledDelete(Frame* frame, Event* event, EditorCommandSource source) 1138 { 1139 switch (source) { 1140 case CommandFromMenuOrKeyBinding: 1141 // "Delete" from menu only affects selected range, just like Cut but without affecting pasteboard 1142 return frame->editor()->canDHTMLCut() || frame->editor()->canCut(); 1143 case CommandFromDOM: 1144 case CommandFromDOMWithUserInterface: 1145 // "Delete" from DOM is like delete/backspace keypress, affects selected range if non-empty, 1146 // otherwise removes a character 1147 return frame->editor()->selectionForCommand(event).isContentEditable(); 1148 } 1149 ASSERT_NOT_REACHED(); 1150 return false; 1151 } 1152 1153 static bool enabledInEditableText(Frame* frame, Event* event, EditorCommandSource) 1154 { 1155 return frame->editor()->selectionForCommand(event).isContentEditable(); 1156 } 1157 1158 static bool enabledInEditableTextOrCaretBrowsing(Frame* frame, Event* event, EditorCommandSource) 1159 { 1160 // The EditorCommandSource parameter is unused in enabledInEditableText, so just pass a dummy variable 1161 return caretBrowsingEnabled(frame) || enabledInEditableText(frame, event, dummyEditorCommandSource); 1162 } 1163 1164 static bool enabledInRichlyEditableText(Frame* frame, Event*, EditorCommandSource) 1165 { 1166 return frame->selection()->isCaretOrRange() && frame->selection()->isContentRichlyEditable(); 1167 } 1168 1169 static bool enabledPaste(Frame* frame, Event*, EditorCommandSource) 1170 { 1171 return frame->editor()->canPaste(); 1172 } 1173 1174 static bool enabledRangeInEditableText(Frame* frame, Event*, EditorCommandSource) 1175 { 1176 return frame->selection()->isRange() && frame->selection()->isContentEditable(); 1177 } 1178 1179 static bool enabledRangeInRichlyEditableText(Frame* frame, Event*, EditorCommandSource) 1180 { 1181 return frame->selection()->isRange() && frame->selection()->isContentRichlyEditable(); 1182 } 1183 1184 static bool enabledRedo(Frame* frame, Event*, EditorCommandSource) 1185 { 1186 return frame->editor()->canRedo(); 1187 } 1188 1189 static bool enabledUndo(Frame* frame, Event*, EditorCommandSource) 1190 { 1191 return frame->editor()->canUndo(); 1192 } 1193 1194 // State functions 1195 1196 static TriState stateNone(Frame*, Event*) 1197 { 1198 return FalseTriState; 1199 } 1200 1201 static TriState stateBold(Frame* frame, Event*) 1202 { 1203 return stateStyle(frame, CSSPropertyFontWeight, "bold"); 1204 } 1205 1206 static TriState stateItalic(Frame* frame, Event*) 1207 { 1208 return stateStyle(frame, CSSPropertyFontStyle, "italic"); 1209 } 1210 1211 static TriState stateOrderedList(Frame* frame, Event*) 1212 { 1213 return frame->editor()->selectionOrderedListState(); 1214 } 1215 1216 static TriState stateStrikethrough(Frame* frame, Event*) 1217 { 1218 return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "line-through"); 1219 } 1220 1221 static TriState stateStyleWithCSS(Frame* frame, Event*) 1222 { 1223 return frame->editor()->shouldStyleWithCSS() ? TrueTriState : FalseTriState; 1224 } 1225 1226 static TriState stateSubscript(Frame* frame, Event*) 1227 { 1228 return stateStyle(frame, CSSPropertyVerticalAlign, "sub"); 1229 } 1230 1231 static TriState stateSuperscript(Frame* frame, Event*) 1232 { 1233 return stateStyle(frame, CSSPropertyVerticalAlign, "super"); 1234 } 1235 1236 static TriState stateTextWritingDirectionLeftToRight(Frame* frame, Event*) 1237 { 1238 return stateTextWritingDirection(frame, LeftToRightWritingDirection); 1239 } 1240 1241 static TriState stateTextWritingDirectionNatural(Frame* frame, Event*) 1242 { 1243 return stateTextWritingDirection(frame, NaturalWritingDirection); 1244 } 1245 1246 static TriState stateTextWritingDirectionRightToLeft(Frame* frame, Event*) 1247 { 1248 return stateTextWritingDirection(frame, RightToLeftWritingDirection); 1249 } 1250 1251 static TriState stateUnderline(Frame* frame, Event*) 1252 { 1253 return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "underline"); 1254 } 1255 1256 static TriState stateUnorderedList(Frame* frame, Event*) 1257 { 1258 return frame->editor()->selectionUnorderedListState(); 1259 } 1260 1261 // Value functions 1262 1263 static String valueNull(Frame*, Event*) 1264 { 1265 return String(); 1266 } 1267 1268 static String valueBackColor(Frame* frame, Event*) 1269 { 1270 return valueStyle(frame, CSSPropertyBackgroundColor); 1271 } 1272 1273 static String valueFontName(Frame* frame, Event*) 1274 { 1275 return valueStyle(frame, CSSPropertyFontFamily); 1276 } 1277 1278 static String valueFontSize(Frame* frame, Event*) 1279 { 1280 return valueStyle(frame, CSSPropertyFontSize); 1281 } 1282 1283 static String valueFontSizeDelta(Frame* frame, Event*) 1284 { 1285 return valueStyle(frame, CSSPropertyWebkitFontSizeDelta); 1286 } 1287 1288 static String valueForeColor(Frame* frame, Event*) 1289 { 1290 return valueStyle(frame, CSSPropertyColor); 1291 } 1292 1293 // Map of functions 1294 1295 struct CommandEntry { const char* name; EditorInternalCommand command; }; 1296 1297 static const CommandMap& createCommandMap() 1298 { 1299 static const CommandEntry commands[] = { 1300 { "AlignCenter", { executeJustifyCenter, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1301 { "AlignJustified", { executeJustifyFull, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1302 { "AlignLeft", { executeJustifyLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1303 { "AlignRight", { executeJustifyRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1304 { "BackColor", { executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueBackColor, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1305 { "BackwardDelete", { executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, // FIXME: remove BackwardDelete when Safari for Windows stops using it. 1306 { "Bold", { executeToggleBold, supported, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1307 { "Copy", { executeCopy, supported, enabledCopy, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, 1308 { "CreateLink", { executeCreateLink, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1309 { "Cut", { executeCut, supported, enabledCut, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, 1310 { "Delete", { executeDelete, supported, enabledDelete, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1311 { "DeleteBackward", { executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1312 { "DeleteBackwardByDecomposingPreviousCharacter", { executeDeleteBackwardByDecomposingPreviousCharacter, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1313 { "DeleteForward", { executeDeleteForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1314 { "DeleteToBeginningOfLine", { executeDeleteToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1315 { "DeleteToBeginningOfParagraph", { executeDeleteToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1316 { "DeleteToEndOfLine", { executeDeleteToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1317 { "DeleteToEndOfParagraph", { executeDeleteToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1318 { "DeleteToMark", { executeDeleteToMark, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1319 { "DeleteWordBackward", { executeDeleteWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1320 { "DeleteWordForward", { executeDeleteWordForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1321 { "FindString", { executeFindString, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1322 { "FontName", { executeFontName, supported, enabledInEditableText, stateNone, valueFontName, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1323 { "FontSize", { executeFontSize, supported, enabledInEditableText, stateNone, valueFontSize, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1324 { "FontSizeDelta", { executeFontSizeDelta, supported, enabledInEditableText, stateNone, valueFontSizeDelta, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1325 { "ForeColor", { executeForeColor, supported, enabledInRichlyEditableText, stateNone, valueForeColor, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1326 { "FormatBlock", { executeFormatBlock, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1327 { "ForwardDelete", { executeForwardDelete, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1328 { "HiliteColor", { executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1329 { "IgnoreSpelling", { executeIgnoreSpelling, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1330 { "Indent", { executeIndent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1331 { "InsertBacktab", { executeInsertBacktab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, 1332 { "InsertHTML", { executeInsertHTML, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1333 { "InsertHorizontalRule", { executeInsertHorizontalRule, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1334 { "InsertImage", { executeInsertImage, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1335 { "InsertLineBreak", { executeInsertLineBreak, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, 1336 { "InsertNewline", { executeInsertNewline, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, 1337 { "InsertNewlineInQuotedContent", { executeInsertNewlineInQuotedContent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1338 { "InsertOrderedList", { executeInsertOrderedList, supported, enabledInRichlyEditableText, stateOrderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1339 { "InsertParagraph", { executeInsertParagraph, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1340 { "InsertTab", { executeInsertTab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, 1341 { "InsertText", { executeInsertText, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, 1342 { "InsertUnorderedList", { executeInsertUnorderedList, supported, enabledInRichlyEditableText, stateUnorderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1343 { "Italic", { executeToggleItalic, supported, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1344 { "JustifyCenter", { executeJustifyCenter, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1345 { "JustifyFull", { executeJustifyFull, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1346 { "JustifyLeft", { executeJustifyLeft, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1347 { "JustifyNone", { executeJustifyLeft, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1348 { "JustifyRight", { executeJustifyRight, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1349 { "MakeTextWritingDirectionLeftToRight", { executeMakeTextWritingDirectionLeftToRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionLeftToRight, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1350 { "MakeTextWritingDirectionNatural", { executeMakeTextWritingDirectionNatural, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionNatural, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1351 { "MakeTextWritingDirectionRightToLeft", { executeMakeTextWritingDirectionRightToLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionRightToLeft, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1352 { "MoveBackward", { executeMoveBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1353 { "MoveBackwardAndModifySelection", { executeMoveBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1354 { "MoveDown", { executeMoveDown, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1355 { "MoveDownAndModifySelection", { executeMoveDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1356 { "MoveForward", { executeMoveForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1357 { "MoveForwardAndModifySelection", { executeMoveForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1358 { "MoveLeft", { executeMoveLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1359 { "MoveLeftAndModifySelection", { executeMoveLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1360 { "MovePageDown", { executeMovePageDown, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1361 { "MovePageDownAndModifySelection", { executeMovePageDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1362 { "MovePageUp", { executeMovePageUp, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1363 { "MovePageUpAndModifySelection", { executeMovePageUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1364 { "MoveParagraphBackwardAndModifySelection", { executeMoveParagraphBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1365 { "MoveParagraphForwardAndModifySelection", { executeMoveParagraphForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1366 { "MoveRight", { executeMoveRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1367 { "MoveRightAndModifySelection", { executeMoveRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1368 { "MoveToBeginningOfDocument", { executeMoveToBeginningOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1369 { "MoveToBeginningOfDocumentAndModifySelection", { executeMoveToBeginningOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1370 { "MoveToBeginningOfLine", { executeMoveToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1371 { "MoveToBeginningOfLineAndModifySelection", { executeMoveToBeginningOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1372 { "MoveToBeginningOfParagraph", { executeMoveToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1373 { "MoveToBeginningOfParagraphAndModifySelection", { executeMoveToBeginningOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1374 { "MoveToBeginningOfSentence", { executeMoveToBeginningOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1375 { "MoveToBeginningOfSentenceAndModifySelection", { executeMoveToBeginningOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1376 { "MoveToEndOfDocument", { executeMoveToEndOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1377 { "MoveToEndOfDocumentAndModifySelection", { executeMoveToEndOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1378 { "MoveToEndOfLine", { executeMoveToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1379 { "MoveToEndOfLineAndModifySelection", { executeMoveToEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1380 { "MoveToEndOfParagraph", { executeMoveToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1381 { "MoveToEndOfParagraphAndModifySelection", { executeMoveToEndOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1382 { "MoveToEndOfSentence", { executeMoveToEndOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1383 { "MoveToEndOfSentenceAndModifySelection", { executeMoveToEndOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1384 { "MoveToLeftEndOfLine", { executeMoveToLeftEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1385 { "MoveToLeftEndOfLineAndModifySelection", { executeMoveToLeftEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1386 { "MoveToRightEndOfLine", { executeMoveToRightEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1387 { "MoveToRightEndOfLineAndModifySelection", { executeMoveToRightEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1388 { "MoveUp", { executeMoveUp, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1389 { "MoveUpAndModifySelection", { executeMoveUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1390 { "MoveWordBackward", { executeMoveWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1391 { "MoveWordBackwardAndModifySelection", { executeMoveWordBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1392 { "MoveWordForward", { executeMoveWordForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1393 { "MoveWordForwardAndModifySelection", { executeMoveWordForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1394 { "MoveWordLeft", { executeMoveWordLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1395 { "MoveWordLeftAndModifySelection", { executeMoveWordLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1396 { "MoveWordRight", { executeMoveWordRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1397 { "MoveWordRightAndModifySelection", { executeMoveWordRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1398 { "Outdent", { executeOutdent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1399 { "Paste", { executePaste, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, 1400 { "PasteAndMatchStyle", { executePasteAndMatchStyle, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, 1401 { "Print", { executePrint, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1402 { "Redo", { executeRedo, supported, enabledRedo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1403 { "RemoveFormat", { executeRemoveFormat, supported, enabledRangeInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1404 { "SelectAll", { executeSelectAll, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1405 { "SelectLine", { executeSelectLine, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1406 { "SelectParagraph", { executeSelectParagraph, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1407 { "SelectSentence", { executeSelectSentence, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1408 { "SelectToMark", { executeSelectToMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1409 { "SelectWord", { executeSelectWord, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1410 { "SetMark", { executeSetMark, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1411 { "Strikethrough", { executeStrikethrough, supported, enabledInRichlyEditableText, stateStrikethrough, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1412 { "StyleWithCSS", { executeStyleWithCSS, supported, enabledInRichlyEditableText, stateStyleWithCSS, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1413 { "Subscript", { executeSubscript, supported, enabledInRichlyEditableText, stateSubscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1414 { "Superscript", { executeSuperscript, supported, enabledInRichlyEditableText, stateSuperscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1415 { "SwapWithMark", { executeSwapWithMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1416 { "ToggleBold", { executeToggleBold, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1417 { "ToggleItalic", { executeToggleItalic, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1418 { "ToggleUnderline", { executeUnderline, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1419 { "Transpose", { executeTranspose, supported, enableCaretInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1420 { "Underline", { executeUnderline, supported, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1421 { "Undo", { executeUndo, supported, enabledUndo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1422 { "Unlink", { executeUnlink, supported, enabledRangeInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1423 { "Unscript", { executeUnscript, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1424 { "Unselect", { executeUnselect, supported, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1425 { "Yank", { executeYank, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1426 { "YankAndSelect", { executeYankAndSelect, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, 1427 }; 1428 1429 // These unsupported commands are listed here since they appear in the Microsoft 1430 // documentation used as the starting point for our DOM executeCommand support. 1431 // 1432 // 2D-Position (not supported) 1433 // AbsolutePosition (not supported) 1434 // BlockDirLTR (not supported) 1435 // BlockDirRTL (not supported) 1436 // BrowseMode (not supported) 1437 // ClearAuthenticationCache (not supported) 1438 // CreateBookmark (not supported) 1439 // DirLTR (not supported) 1440 // DirRTL (not supported) 1441 // EditMode (not supported) 1442 // InlineDirLTR (not supported) 1443 // InlineDirRTL (not supported) 1444 // InsertButton (not supported) 1445 // InsertFieldSet (not supported) 1446 // InsertIFrame (not supported) 1447 // InsertInputButton (not supported) 1448 // InsertInputCheckbox (not supported) 1449 // InsertInputFileUpload (not supported) 1450 // InsertInputHidden (not supported) 1451 // InsertInputImage (not supported) 1452 // InsertInputPassword (not supported) 1453 // InsertInputRadio (not supported) 1454 // InsertInputReset (not supported) 1455 // InsertInputSubmit (not supported) 1456 // InsertInputText (not supported) 1457 // InsertMarquee (not supported) 1458 // InsertSelectDropDown (not supported) 1459 // InsertSelectListBox (not supported) 1460 // InsertTextArea (not supported) 1461 // LiveResize (not supported) 1462 // MultipleSelection (not supported) 1463 // Open (not supported) 1464 // Overwrite (not supported) 1465 // PlayImage (not supported) 1466 // Refresh (not supported) 1467 // RemoveParaFormat (not supported) 1468 // SaveAs (not supported) 1469 // SizeToControl (not supported) 1470 // SizeToControlHeight (not supported) 1471 // SizeToControlWidth (not supported) 1472 // Stop (not supported) 1473 // StopImage (not supported) 1474 // Unbookmark (not supported) 1475 1476 CommandMap& commandMap = *new CommandMap; 1477 1478 const unsigned numCommands = sizeof(commands) / sizeof(commands[0]); 1479 for (unsigned i = 0; i < numCommands; i++) { 1480 ASSERT(!commandMap.get(commands[i].name)); 1481 commandMap.set(commands[i].name, &commands[i].command); 1482 } 1483 1484 return commandMap; 1485 } 1486 1487 Editor::Command Editor::command(const String& commandName) 1488 { 1489 return command(commandName, CommandFromMenuOrKeyBinding); 1490 } 1491 1492 Editor::Command Editor::command(const String& commandName, EditorCommandSource source) 1493 { 1494 if (commandName.isEmpty()) 1495 return Command(); 1496 1497 static const CommandMap& commandMap = createCommandMap(); 1498 const EditorInternalCommand* internalCommand = commandMap.get(commandName); 1499 return internalCommand ? Command(m_frame, internalCommand, source) : Command(); 1500 } 1501 1502 Editor::Command::Command() 1503 : m_command(0) 1504 , m_source() 1505 { 1506 } 1507 1508 Editor::Command::Command(PassRefPtr<Frame> frame, const EditorInternalCommand* command, EditorCommandSource source) 1509 : m_frame(frame) 1510 , m_command(command) 1511 , m_source(source) 1512 { 1513 ASSERT(m_frame); 1514 ASSERT(m_command); 1515 } 1516 1517 bool Editor::Command::execute(const String& parameter, Event* triggeringEvent) const 1518 { 1519 if (!isEnabled(triggeringEvent)) { 1520 // Let certain commands be executed when performed explicitly even if they are disabled. 1521 if (!isSupported() || !m_frame || !m_command->allowExecutionWhenDisabled) 1522 return false; 1523 } 1524 m_frame->document()->updateLayoutIgnorePendingStylesheets(); 1525 return m_command->execute(m_frame.get(), triggeringEvent, m_source, parameter); 1526 } 1527 1528 bool Editor::Command::execute(Event* triggeringEvent) const 1529 { 1530 return execute(String(), triggeringEvent); 1531 } 1532 1533 bool Editor::Command::isSupported() const 1534 { 1535 return m_command && m_command->isSupported(m_frame.get(), m_source); 1536 } 1537 1538 bool Editor::Command::isEnabled(Event* triggeringEvent) const 1539 { 1540 if (!isSupported() || !m_frame) 1541 return false; 1542 return m_command->isEnabled(m_frame.get(), triggeringEvent, m_source); 1543 } 1544 1545 TriState Editor::Command::state(Event* triggeringEvent) const 1546 { 1547 if (!isSupported() || !m_frame) 1548 return FalseTriState; 1549 return m_command->state(m_frame.get(), triggeringEvent); 1550 } 1551 1552 String Editor::Command::value(Event* triggeringEvent) const 1553 { 1554 if (!isSupported() || !m_frame) 1555 return String(); 1556 return m_command->value(m_frame.get(), triggeringEvent); 1557 } 1558 1559 bool Editor::Command::isTextInsertion() const 1560 { 1561 return m_command && m_command->isTextInsertion; 1562 } 1563 1564 } // namespace WebCore 1565