Home | History | Annotate | Download | only in editing 
      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 #include "core/editing/Editor.h"
     30 
     31 #include "bindings/core/v8/ExceptionState.h"
     32 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
     33 #include "core/CSSPropertyNames.h"
     34 #include "core/CSSValueKeywords.h"
     35 #include "core/HTMLNames.h"
     36 #include "core/clipboard/Pasteboard.h"
     37 #include "core/css/CSSValueList.h"
     38 #include "core/css/StylePropertySet.h"
     39 #include "core/dom/DocumentFragment.h"
     40 #include "core/editing/CreateLinkCommand.h"
     41 #include "core/editing/FormatBlockCommand.h"
     42 #include "core/editing/FrameSelection.h"
     43 #include "core/editing/IndentOutdentCommand.h"
     44 #include "core/editing/InsertListCommand.h"
     45 #include "core/editing/ReplaceSelectionCommand.h"
     46 #include "core/editing/SpellChecker.h"
     47 #include "core/editing/TypingCommand.h"
     48 #include "core/editing/UnlinkCommand.h"
     49 #include "core/editing/htmlediting.h"
     50 #include "core/editing/markup.h"
     51 #include "core/events/Event.h"
     52 #include "core/frame/FrameHost.h"
     53 #include "core/frame/FrameView.h"
     54 #include "core/frame/LocalFrame.h"
     55 #include "core/frame/Settings.h"
     56 #include "core/html/HTMLFontElement.h"
     57 #include "core/html/HTMLHRElement.h"
     58 #include "core/html/HTMLImageElement.h"
     59 #include "core/page/Chrome.h"
     60 #include "core/page/EditorClient.h"
     61 #include "core/page/EventHandler.h"
     62 #include "core/rendering/RenderBox.h"
     63 #include "platform/KillRing.h"
     64 #include "platform/scroll/Scrollbar.h"
     65 #include "public/platform/Platform.h"
     66 #include "wtf/text/AtomicString.h"
     67 
     68 namespace blink {
     69 
     70 using namespace HTMLNames;
     71 
     72 class EditorInternalCommand {
     73 public:
     74     int idForUserMetrics;
     75     bool (*execute)(LocalFrame&, Event*, EditorCommandSource, const String&);
     76     bool (*isSupportedFromDOM)(LocalFrame*);
     77     bool (*isEnabled)(LocalFrame&, Event*, EditorCommandSource);
     78     TriState (*state)(LocalFrame&, Event*);
     79     String (*value)(LocalFrame&, Event*);
     80     bool isTextInsertion;
     81     bool allowExecutionWhenDisabled;
     82 };
     83 
     84 typedef HashMap<String, const EditorInternalCommand*, CaseFoldingHash> CommandMap;
     85 
     86 static const bool notTextInsertion = false;
     87 static const bool isTextInsertion = true;
     88 
     89 static const bool allowExecutionWhenDisabled = true;
     90 static const bool doNotAllowExecutionWhenDisabled = false;
     91 
     92 // Related to Editor::selectionForCommand.
     93 // Certain operations continue to use the target control's selection even if the event handler
     94 // already moved the selection outside of the text control.
     95 static LocalFrame* targetFrame(LocalFrame& frame, Event* event)
     96 {
     97     if (!event)
     98         return &frame;
     99     Node* node = event->target()->toNode();
    100     if (!node)
    101         return &frame;
    102     return node->document().frame();
    103 }
    104 
    105 static bool applyCommandToFrame(LocalFrame& frame, EditorCommandSource source, EditAction action, StylePropertySet* style)
    106 {
    107     // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that?
    108     switch (source) {
    109     case CommandFromMenuOrKeyBinding:
    110         frame.editor().applyStyleToSelection(style, action);
    111         return true;
    112     case CommandFromDOM:
    113     case CommandFromDOMWithUserInterface:
    114         frame.editor().applyStyle(style);
    115         return true;
    116     }
    117     ASSERT_NOT_REACHED();
    118     return false;
    119 }
    120 
    121 static bool executeApplyStyle(LocalFrame& frame, EditorCommandSource source, EditAction action, CSSPropertyID propertyID, const String& propertyValue)
    122 {
    123     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    124     style->setProperty(propertyID, propertyValue);
    125     return applyCommandToFrame(frame, source, action, style.get());
    126 }
    127 
    128 static bool executeApplyStyle(LocalFrame& frame, EditorCommandSource source, EditAction action, CSSPropertyID propertyID, CSSValueID propertyValue)
    129 {
    130     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    131     style->setProperty(propertyID, propertyValue);
    132     return applyCommandToFrame(frame, source, action, style.get());
    133 }
    134 
    135 // FIXME: executeToggleStyleInList does not handle complicated cases such as <b><u>hello</u>world</b> properly.
    136 //        This function must use Editor::selectionHasStyle to determine the current style but we cannot fix this
    137 //        until https://bugs.webkit.org/show_bug.cgi?id=27818 is resolved.
    138 static bool executeToggleStyleInList(LocalFrame& frame, EditorCommandSource source, EditAction action, CSSPropertyID propertyID, CSSValue* value)
    139 {
    140     RefPtrWillBeRawPtr<EditingStyle> selectionStyle = EditingStyle::styleAtSelectionStart(frame.selection().selection());
    141     if (!selectionStyle || !selectionStyle->style())
    142         return false;
    143 
    144     RefPtrWillBeRawPtr<CSSValue> selectedCSSValue = selectionStyle->style()->getPropertyCSSValue(propertyID);
    145     String newStyle("none");
    146     if (selectedCSSValue->isValueList()) {
    147         RefPtrWillBeRawPtr<CSSValueList> selectedCSSValueList = toCSSValueList(selectedCSSValue.get());
    148         if (!selectedCSSValueList->removeAll(value))
    149             selectedCSSValueList->append(value);
    150         if (selectedCSSValueList->length())
    151             newStyle = selectedCSSValueList->cssText();
    152 
    153     } else if (selectedCSSValue->cssText() == "none")
    154         newStyle = value->cssText();
    155 
    156     // FIXME: We shouldn't be having to convert new style into text.  We should have setPropertyCSSValue.
    157     RefPtrWillBeRawPtr<MutableStylePropertySet> newMutableStyle = MutableStylePropertySet::create();
    158     newMutableStyle->setProperty(propertyID, newStyle);
    159     return applyCommandToFrame(frame, source, action, newMutableStyle.get());
    160 }
    161 
    162 static bool executeToggleStyle(LocalFrame& frame, EditorCommandSource source, EditAction action, CSSPropertyID propertyID, const char* offValue, const char* onValue)
    163 {
    164     // Style is considered present when
    165     // Mac: present at the beginning of selection
    166     // other: present throughout the selection
    167 
    168     bool styleIsPresent;
    169     if (frame.editor().behavior().shouldToggleStyleBasedOnStartOfSelection())
    170         styleIsPresent = frame.editor().selectionStartHasStyle(propertyID, onValue);
    171     else
    172         styleIsPresent = frame.editor().selectionHasStyle(propertyID, onValue) == TrueTriState;
    173 
    174     RefPtrWillBeRawPtr<EditingStyle> style = EditingStyle::create(propertyID, styleIsPresent ? offValue : onValue);
    175     return applyCommandToFrame(frame, source, action, style->style());
    176 }
    177 
    178 static bool executeApplyParagraphStyle(LocalFrame& frame, EditorCommandSource source, EditAction action, CSSPropertyID propertyID, const String& propertyValue)
    179 {
    180     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    181     style->setProperty(propertyID, propertyValue);
    182     // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that?
    183     switch (source) {
    184     case CommandFromMenuOrKeyBinding:
    185         frame.editor().applyParagraphStyleToSelection(style.get(), action);
    186         return true;
    187     case CommandFromDOM:
    188     case CommandFromDOMWithUserInterface:
    189         frame.editor().applyParagraphStyle(style.get());
    190         return true;
    191     }
    192     ASSERT_NOT_REACHED();
    193     return false;
    194 }
    195 
    196 static bool executeInsertFragment(LocalFrame& frame, PassRefPtrWillBeRawPtr<DocumentFragment> fragment)
    197 {
    198     ASSERT(frame.document());
    199     ReplaceSelectionCommand::create(*frame.document(), fragment, ReplaceSelectionCommand::PreventNesting, EditActionUnspecified)->apply();
    200     return true;
    201 }
    202 
    203 static bool executeInsertElement(LocalFrame& frame, PassRefPtrWillBeRawPtr<HTMLElement> content)
    204 {
    205     ASSERT(frame.document());
    206     RefPtrWillBeRawPtr<DocumentFragment> fragment = DocumentFragment::create(*frame.document());
    207     TrackExceptionState exceptionState;
    208     fragment->appendChild(content, exceptionState);
    209     if (exceptionState.hadException())
    210         return false;
    211     return executeInsertFragment(frame, fragment.release());
    212 }
    213 
    214 static bool expandSelectionToGranularity(LocalFrame& frame, TextGranularity granularity)
    215 {
    216     VisibleSelection selection = frame.selection().selection();
    217     selection.expandUsingGranularity(granularity);
    218     RefPtrWillBeRawPtr<Range> newRange = selection.toNormalizedRange();
    219     if (!newRange)
    220         return false;
    221     if (newRange->collapsed())
    222         return false;
    223     EAffinity affinity = frame.selection().affinity();
    224     frame.selection().setSelectedRange(newRange.get(), affinity, FrameSelection::NonDirectional, FrameSelection::CloseTyping);
    225     return true;
    226 }
    227 
    228 static TriState selectionListState(const FrameSelection& selection, const QualifiedName& tagName)
    229 {
    230     if (selection.isCaret()) {
    231         if (enclosingElementWithTag(selection.selection().start(), tagName))
    232             return TrueTriState;
    233     } else if (selection.isRange()) {
    234         Element* startElement = enclosingElementWithTag(selection.selection().start(), tagName);
    235         Element* endElement = enclosingElementWithTag(selection.selection().end(), tagName);
    236         if (startElement && endElement && startElement == endElement)
    237             return TrueTriState;
    238     }
    239 
    240     return FalseTriState;
    241 }
    242 
    243 static TriState stateStyle(LocalFrame& frame, CSSPropertyID propertyID, const char* desiredValue)
    244 {
    245     if (frame.editor().behavior().shouldToggleStyleBasedOnStartOfSelection())
    246         return frame.editor().selectionStartHasStyle(propertyID, desiredValue) ? TrueTriState : FalseTriState;
    247     return frame.editor().selectionHasStyle(propertyID, desiredValue);
    248 }
    249 
    250 static String valueStyle(LocalFrame& frame, CSSPropertyID propertyID)
    251 {
    252     // FIXME: Rather than retrieving the style at the start of the current selection,
    253     // we should retrieve the style present throughout the selection for non-Mac platforms.
    254     return frame.editor().selectionStartCSSPropertyValue(propertyID);
    255 }
    256 
    257 static TriState stateTextWritingDirection(LocalFrame& frame, WritingDirection direction)
    258 {
    259     bool hasNestedOrMultipleEmbeddings;
    260     WritingDirection selectionDirection = EditingStyle::textDirectionForSelection(frame.selection().selection(),
    261         frame.selection().typingStyle(), hasNestedOrMultipleEmbeddings);
    262     // FXIME: We should be returning MixedTriState when selectionDirection == direction && hasNestedOrMultipleEmbeddings
    263     return (selectionDirection == direction && !hasNestedOrMultipleEmbeddings) ? TrueTriState : FalseTriState;
    264 }
    265 
    266 static unsigned verticalScrollDistance(LocalFrame& frame)
    267 {
    268     Element* focusedElement = frame.document()->focusedElement();
    269     if (!focusedElement)
    270         return 0;
    271     RenderObject* renderer = focusedElement->renderer();
    272     if (!renderer || !renderer->isBox())
    273         return 0;
    274     RenderBox& renderBox = toRenderBox(*renderer);
    275     RenderStyle* style = renderBox.style();
    276     if (!style)
    277         return 0;
    278     if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedElement->hasEditableStyle()))
    279         return 0;
    280     int height = std::min<int>(renderBox.clientHeight(), frame.view()->visibleHeight());
    281     return static_cast<unsigned>(max(max<int>(height * ScrollableArea::minFractionToStepWhenPaging(), height - ScrollableArea::maxOverlapBetweenPages()), 1));
    282 }
    283 
    284 static PassRefPtrWillBeRawPtr<Range> unionDOMRanges(Range* a, Range* b)
    285 {
    286     Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ASSERT_NO_EXCEPTION) <= 0 ? a : b;
    287     Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ASSERT_NO_EXCEPTION) <= 0 ? b : a;
    288 
    289     return Range::create(a->ownerDocument(), start->startContainer(), start->startOffset(), end->endContainer(), end->endOffset());
    290 }
    291 
    292 // Execute command functions
    293 
    294 static bool executeBackColor(LocalFrame& frame, Event*, EditorCommandSource source, const String& value)
    295 {
    296     return executeApplyStyle(frame, source, EditActionSetBackgroundColor, CSSPropertyBackgroundColor, value);
    297 }
    298 
    299 static bool executeCopy(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    300 {
    301     frame.editor().copy();
    302     return true;
    303 }
    304 
    305 static bool executeCreateLink(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    306 {
    307     // FIXME: If userInterface is true, we should display a dialog box to let the user enter a URL.
    308     if (value.isEmpty())
    309         return false;
    310     ASSERT(frame.document());
    311     CreateLinkCommand::create(*frame.document(), value)->apply();
    312     return true;
    313 }
    314 
    315 static bool executeCut(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    316 {
    317     frame.editor().cut();
    318     return true;
    319 }
    320 
    321 static bool executeDefaultParagraphSeparator(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    322 {
    323     if (equalIgnoringCase(value, "div"))
    324         frame.editor().setDefaultParagraphSeparator(EditorParagraphSeparatorIsDiv);
    325     else if (equalIgnoringCase(value, "p"))
    326         frame.editor().setDefaultParagraphSeparator(EditorParagraphSeparatorIsP);
    327 
    328     return true;
    329 }
    330 
    331 static bool executeDelete(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    332 {
    333     switch (source) {
    334     case CommandFromMenuOrKeyBinding: {
    335         // Doesn't modify the text if the current selection isn't a range.
    336         frame.editor().performDelete();
    337         return true;
    338     }
    339     case CommandFromDOM:
    340     case CommandFromDOMWithUserInterface:
    341         // If the current selection is a caret, delete the preceding character. IE performs forwardDelete, but we currently side with Firefox.
    342         // Doesn't scroll to make the selection visible, or modify the kill ring (this time, siding with IE, not Firefox).
    343         ASSERT(frame.document());
    344         TypingCommand::deleteKeyPressed(*frame.document(), frame.selection().granularity() == WordGranularity ? TypingCommand::SmartDelete : 0);
    345         return true;
    346     }
    347     ASSERT_NOT_REACHED();
    348     return false;
    349 }
    350 
    351 static bool executeDeleteBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    352 {
    353     frame.editor().deleteWithDirection(DirectionBackward, CharacterGranularity, false, true);
    354     return true;
    355 }
    356 
    357 static bool executeDeleteBackwardByDecomposingPreviousCharacter(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    358 {
    359     WTF_LOG_ERROR("DeleteBackwardByDecomposingPreviousCharacter is not implemented, doing DeleteBackward instead");
    360     frame.editor().deleteWithDirection(DirectionBackward, CharacterGranularity, false, true);
    361     return true;
    362 }
    363 
    364 static bool executeDeleteForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    365 {
    366     frame.editor().deleteWithDirection(DirectionForward, CharacterGranularity, false, true);
    367     return true;
    368 }
    369 
    370 static bool executeDeleteToBeginningOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    371 {
    372     frame.editor().deleteWithDirection(DirectionBackward, LineBoundary, true, false);
    373     return true;
    374 }
    375 
    376 static bool executeDeleteToBeginningOfParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    377 {
    378     frame.editor().deleteWithDirection(DirectionBackward, ParagraphBoundary, true, false);
    379     return true;
    380 }
    381 
    382 static bool executeDeleteToEndOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    383 {
    384     // Despite its name, this command should delete the newline at the end of
    385     // a paragraph if you are at the end of a paragraph (like DeleteToEndOfParagraph).
    386     frame.editor().deleteWithDirection(DirectionForward, LineBoundary, true, false);
    387     return true;
    388 }
    389 
    390 static bool executeDeleteToEndOfParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    391 {
    392     // Despite its name, this command should delete the newline at the end of
    393     // a paragraph if you are at the end of a paragraph.
    394     frame.editor().deleteWithDirection(DirectionForward, ParagraphBoundary, true, false);
    395     return true;
    396 }
    397 
    398 static bool executeDeleteToMark(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    399 {
    400     RefPtrWillBeRawPtr<Range> mark = frame.editor().mark().toNormalizedRange();
    401     if (mark) {
    402         bool selected = frame.selection().setSelectedRange(unionDOMRanges(mark.get(), frame.editor().selectedRange().get()).get(), DOWNSTREAM, FrameSelection::NonDirectional, FrameSelection::CloseTyping);
    403         ASSERT(selected);
    404         if (!selected)
    405             return false;
    406     }
    407     frame.editor().performDelete();
    408     frame.editor().setMark(frame.selection().selection());
    409     return true;
    410 }
    411 
    412 static bool executeDeleteWordBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    413 {
    414     frame.editor().deleteWithDirection(DirectionBackward, WordGranularity, true, false);
    415     return true;
    416 }
    417 
    418 static bool executeDeleteWordForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    419 {
    420     frame.editor().deleteWithDirection(DirectionForward, WordGranularity, true, false);
    421     return true;
    422 }
    423 
    424 static bool executeFindString(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    425 {
    426     return frame.editor().findString(value, true, false, true, false);
    427 }
    428 
    429 static bool executeFontName(LocalFrame& frame, Event*, EditorCommandSource source, const String& value)
    430 {
    431     return executeApplyStyle(frame, source, EditActionSetFont, CSSPropertyFontFamily, value);
    432 }
    433 
    434 static bool executeFontSize(LocalFrame& frame, Event*, EditorCommandSource source, const String& value)
    435 {
    436     CSSValueID size;
    437     if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))
    438         return false;
    439     return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontSize, size);
    440 }
    441 
    442 static bool executeFontSizeDelta(LocalFrame& frame, Event*, EditorCommandSource source, const String& value)
    443 {
    444     return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyWebkitFontSizeDelta, value);
    445 }
    446 
    447 static bool executeForeColor(LocalFrame& frame, Event*, EditorCommandSource source, const String& value)
    448 {
    449     return executeApplyStyle(frame, source, EditActionSetColor, CSSPropertyColor, value);
    450 }
    451 
    452 static bool executeFormatBlock(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    453 {
    454     String tagName = value.lower();
    455     if (tagName[0] == '<' && tagName[tagName.length() - 1] == '>')
    456         tagName = tagName.substring(1, tagName.length() - 2);
    457 
    458     AtomicString localName, prefix;
    459     if (!Document::parseQualifiedName(AtomicString(tagName), prefix, localName, IGNORE_EXCEPTION))
    460         return false;
    461     QualifiedName qualifiedTagName(prefix, localName, xhtmlNamespaceURI);
    462 
    463     ASSERT(frame.document());
    464     RefPtrWillBeRawPtr<FormatBlockCommand> command = FormatBlockCommand::create(*frame.document(), qualifiedTagName);
    465     command->apply();
    466     return command->didApply();
    467 }
    468 
    469 static bool executeForwardDelete(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    470 {
    471     switch (source) {
    472     case CommandFromMenuOrKeyBinding:
    473         frame.editor().deleteWithDirection(DirectionForward, CharacterGranularity, false, true);
    474         return true;
    475     case CommandFromDOM:
    476     case CommandFromDOMWithUserInterface:
    477         // Doesn't scroll to make the selection visible, or modify the kill ring.
    478         // ForwardDelete is not implemented in IE or Firefox, so this behavior is only needed for
    479         // backward compatibility with ourselves, and for consistency with Delete.
    480         ASSERT(frame.document());
    481         TypingCommand::forwardDeleteKeyPressed(*frame.document());
    482         return true;
    483     }
    484     ASSERT_NOT_REACHED();
    485     return false;
    486 }
    487 
    488 static bool executeIgnoreSpelling(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    489 {
    490     frame.spellChecker().ignoreSpelling();
    491     return true;
    492 }
    493 
    494 static bool executeIndent(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    495 {
    496     ASSERT(frame.document());
    497     IndentOutdentCommand::create(*frame.document(), IndentOutdentCommand::Indent)->apply();
    498     return true;
    499 }
    500 
    501 static bool executeInsertBacktab(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
    502 {
    503     return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\t", event, TextEventInputBackTab);
    504 }
    505 
    506 static bool executeInsertHorizontalRule(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    507 {
    508     ASSERT(frame.document());
    509     RefPtrWillBeRawPtr<HTMLHRElement> rule = HTMLHRElement::create(*frame.document());
    510     if (!value.isEmpty())
    511         rule->setIdAttribute(AtomicString(value));
    512     return executeInsertElement(frame, rule.release());
    513 }
    514 
    515 static bool executeInsertHTML(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    516 {
    517     ASSERT(frame.document());
    518     return executeInsertFragment(frame, createFragmentFromMarkup(*frame.document(), value, ""));
    519 }
    520 
    521 static bool executeInsertImage(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    522 {
    523     // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image.
    524     ASSERT(frame.document());
    525     RefPtrWillBeRawPtr<HTMLImageElement> image = HTMLImageElement::create(*frame.document());
    526     image->setSrc(value);
    527     return executeInsertElement(frame, image.release());
    528 }
    529 
    530 static bool executeInsertLineBreak(LocalFrame& frame, Event* event, EditorCommandSource source, const String&)
    531 {
    532     switch (source) {
    533     case CommandFromMenuOrKeyBinding:
    534         return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\n", event, TextEventInputLineBreak);
    535     case CommandFromDOM:
    536     case CommandFromDOMWithUserInterface:
    537         // Doesn't scroll to make the selection visible, or modify the kill ring.
    538         // InsertLineBreak is not implemented in IE or Firefox, so this behavior is only needed for
    539         // backward compatibility with ourselves, and for consistency with other commands.
    540         ASSERT(frame.document());
    541         TypingCommand::insertLineBreak(*frame.document(), 0);
    542         return true;
    543     }
    544     ASSERT_NOT_REACHED();
    545     return false;
    546 }
    547 
    548 static bool executeInsertNewline(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
    549 {
    550     LocalFrame* targetFrame = blink::targetFrame(frame, event);
    551     return targetFrame->eventHandler().handleTextInputEvent("\n", event, targetFrame->editor().canEditRichly() ? TextEventInputKeyboard : TextEventInputLineBreak);
    552 }
    553 
    554 static bool executeInsertNewlineInQuotedContent(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    555 {
    556     ASSERT(frame.document());
    557     TypingCommand::insertParagraphSeparatorInQuotedContent(*frame.document());
    558     return true;
    559 }
    560 
    561 static bool executeInsertOrderedList(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    562 {
    563     ASSERT(frame.document());
    564     InsertListCommand::create(*frame.document(), InsertListCommand::OrderedList)->apply();
    565     return true;
    566 }
    567 
    568 static bool executeInsertParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    569 {
    570     ASSERT(frame.document());
    571     TypingCommand::insertParagraphSeparator(*frame.document(), 0);
    572     return true;
    573 }
    574 
    575 static bool executeInsertTab(LocalFrame& frame, Event* event, EditorCommandSource, const String&)
    576 {
    577     return targetFrame(frame, event)->eventHandler().handleTextInputEvent("\t", event);
    578 }
    579 
    580 static bool executeInsertText(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
    581 {
    582     ASSERT(frame.document());
    583     TypingCommand::insertText(*frame.document(), value, 0);
    584     return true;
    585 }
    586 
    587 static bool executeInsertUnorderedList(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    588 {
    589     ASSERT(frame.document());
    590     InsertListCommand::create(*frame.document(), InsertListCommand::UnorderedList)->apply();
    591     return true;
    592 }
    593 
    594 static bool executeJustifyCenter(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    595 {
    596     return executeApplyParagraphStyle(frame, source, EditActionCenter, CSSPropertyTextAlign, "center");
    597 }
    598 
    599 static bool executeJustifyFull(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    600 {
    601     return executeApplyParagraphStyle(frame, source, EditActionJustify, CSSPropertyTextAlign, "justify");
    602 }
    603 
    604 static bool executeJustifyLeft(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    605 {
    606     return executeApplyParagraphStyle(frame, source, EditActionAlignLeft, CSSPropertyTextAlign, "left");
    607 }
    608 
    609 static bool executeJustifyRight(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    610 {
    611     return executeApplyParagraphStyle(frame, source, EditActionAlignRight, CSSPropertyTextAlign, "right");
    612 }
    613 
    614 static bool executeMakeTextWritingDirectionLeftToRight(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    615 {
    616     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    617     style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);
    618     style->setProperty(CSSPropertyDirection, CSSValueLtr);
    619     frame.editor().applyStyle(style.get(), EditActionSetWritingDirection);
    620     return true;
    621 }
    622 
    623 static bool executeMakeTextWritingDirectionNatural(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    624 {
    625     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    626     style->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
    627     frame.editor().applyStyle(style.get(), EditActionSetWritingDirection);
    628     return true;
    629 }
    630 
    631 static bool executeMakeTextWritingDirectionRightToLeft(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    632 {
    633     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
    634     style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);
    635     style->setProperty(CSSPropertyDirection, CSSValueRtl);
    636     frame.editor().applyStyle(style.get(), EditActionSetWritingDirection);
    637     return true;
    638 }
    639 
    640 static bool executeMoveBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    641 {
    642     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, CharacterGranularity, UserTriggered);
    643     return true;
    644 }
    645 
    646 static bool executeMoveBackwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    647 {
    648     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, CharacterGranularity, UserTriggered);
    649     return true;
    650 }
    651 
    652 static bool executeMoveDown(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    653 {
    654     return frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, LineGranularity, UserTriggered);
    655 }
    656 
    657 static bool executeMoveDownAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    658 {
    659     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, LineGranularity, UserTriggered);
    660     return true;
    661 }
    662 
    663 static bool executeMoveForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    664 {
    665     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity, UserTriggered);
    666     return true;
    667 }
    668 
    669 static bool executeMoveForwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    670 {
    671     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, CharacterGranularity, UserTriggered);
    672     return true;
    673 }
    674 
    675 static bool executeMoveLeft(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    676 {
    677     return frame.selection().modify(FrameSelection::AlterationMove, DirectionLeft, CharacterGranularity, UserTriggered);
    678 }
    679 
    680 static bool executeMoveLeftAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    681 {
    682     frame.selection().modify(FrameSelection::AlterationExtend, DirectionLeft, CharacterGranularity, UserTriggered);
    683     return true;
    684 }
    685 
    686 static bool executeMovePageDown(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    687 {
    688     unsigned distance = verticalScrollDistance(frame);
    689     if (!distance)
    690         return false;
    691     return frame.selection().modify(FrameSelection::AlterationMove, distance, FrameSelection::DirectionDown,
    692         UserTriggered, FrameSelection::AlignCursorOnScrollAlways);
    693 }
    694 
    695 static bool executeMovePageDownAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    696 {
    697     unsigned distance = verticalScrollDistance(frame);
    698     if (!distance)
    699         return false;
    700     return frame.selection().modify(FrameSelection::AlterationExtend, distance, FrameSelection::DirectionDown,
    701         UserTriggered, FrameSelection::AlignCursorOnScrollAlways);
    702 }
    703 
    704 static bool executeMovePageUp(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    705 {
    706     unsigned distance = verticalScrollDistance(frame);
    707     if (!distance)
    708         return false;
    709     return frame.selection().modify(FrameSelection::AlterationMove, distance, FrameSelection::DirectionUp,
    710         UserTriggered, FrameSelection::AlignCursorOnScrollAlways);
    711 }
    712 
    713 static bool executeMovePageUpAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    714 {
    715     unsigned distance = verticalScrollDistance(frame);
    716     if (!distance)
    717         return false;
    718     return frame.selection().modify(FrameSelection::AlterationExtend, distance, FrameSelection::DirectionUp,
    719         UserTriggered, FrameSelection::AlignCursorOnScrollAlways);
    720 }
    721 
    722 static bool executeMoveRight(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    723 {
    724     return frame.selection().modify(FrameSelection::AlterationMove, DirectionRight, CharacterGranularity, UserTriggered);
    725 }
    726 
    727 static bool executeMoveRightAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    728 {
    729     frame.selection().modify(FrameSelection::AlterationExtend, DirectionRight, CharacterGranularity, UserTriggered);
    730     return true;
    731 }
    732 
    733 static bool executeMoveToBeginningOfDocument(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    734 {
    735     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, DocumentBoundary, UserTriggered);
    736     return true;
    737 }
    738 
    739 static bool executeMoveToBeginningOfDocumentAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    740 {
    741     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, DocumentBoundary, UserTriggered);
    742     return true;
    743 }
    744 
    745 static bool executeMoveToBeginningOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    746 {
    747     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, LineBoundary, UserTriggered);
    748     return true;
    749 }
    750 
    751 static bool executeMoveToBeginningOfLineAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    752 {
    753     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, LineBoundary, UserTriggered);
    754     return true;
    755 }
    756 
    757 static bool executeMoveToBeginningOfParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    758 {
    759     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, ParagraphBoundary, UserTriggered);
    760     return true;
    761 }
    762 
    763 static bool executeMoveToBeginningOfParagraphAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    764 {
    765     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, ParagraphBoundary, UserTriggered);
    766     return true;
    767 }
    768 
    769 static bool executeMoveToBeginningOfSentence(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    770 {
    771     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, SentenceBoundary, UserTriggered);
    772     return true;
    773 }
    774 
    775 static bool executeMoveToBeginningOfSentenceAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    776 {
    777     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, SentenceBoundary, UserTriggered);
    778     return true;
    779 }
    780 
    781 static bool executeMoveToEndOfDocument(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    782 {
    783     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, DocumentBoundary, UserTriggered);
    784     return true;
    785 }
    786 
    787 static bool executeMoveToEndOfDocumentAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    788 {
    789     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, DocumentBoundary, UserTriggered);
    790     return true;
    791 }
    792 
    793 static bool executeMoveToEndOfSentence(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    794 {
    795     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, SentenceBoundary, UserTriggered);
    796     return true;
    797 }
    798 
    799 static bool executeMoveToEndOfSentenceAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    800 {
    801     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, SentenceBoundary, UserTriggered);
    802     return true;
    803 }
    804 
    805 static bool executeMoveToEndOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    806 {
    807     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, LineBoundary, UserTriggered);
    808     return true;
    809 }
    810 
    811 static bool executeMoveToEndOfLineAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    812 {
    813     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, LineBoundary, UserTriggered);
    814     return true;
    815 }
    816 
    817 static bool executeMoveToEndOfParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    818 {
    819     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, ParagraphBoundary, UserTriggered);
    820     return true;
    821 }
    822 
    823 static bool executeMoveToEndOfParagraphAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    824 {
    825     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, ParagraphBoundary, UserTriggered);
    826     return true;
    827 }
    828 
    829 static bool executeMoveParagraphBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    830 {
    831     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, ParagraphGranularity, UserTriggered);
    832     return true;
    833 }
    834 
    835 static bool executeMoveParagraphBackwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    836 {
    837     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, ParagraphGranularity, UserTriggered);
    838     return true;
    839 }
    840 
    841 static bool executeMoveParagraphForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    842 {
    843     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, ParagraphGranularity, UserTriggered);
    844     return true;
    845 }
    846 
    847 static bool executeMoveParagraphForwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    848 {
    849     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, ParagraphGranularity, UserTriggered);
    850     return true;
    851 }
    852 
    853 static bool executeMoveUp(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    854 {
    855     return frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, LineGranularity, UserTriggered);
    856 }
    857 
    858 static bool executeMoveUpAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    859 {
    860     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, LineGranularity, UserTriggered);
    861     return true;
    862 }
    863 
    864 static bool executeMoveWordBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    865 {
    866     frame.selection().modify(FrameSelection::AlterationMove, DirectionBackward, WordGranularity, UserTriggered);
    867     return true;
    868 }
    869 
    870 static bool executeMoveWordBackwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    871 {
    872     frame.selection().modify(FrameSelection::AlterationExtend, DirectionBackward, WordGranularity, UserTriggered);
    873     return true;
    874 }
    875 
    876 static bool executeMoveWordForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    877 {
    878     frame.selection().modify(FrameSelection::AlterationMove, DirectionForward, WordGranularity, UserTriggered);
    879     return true;
    880 }
    881 
    882 static bool executeMoveWordForwardAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    883 {
    884     frame.selection().modify(FrameSelection::AlterationExtend, DirectionForward, WordGranularity, UserTriggered);
    885     return true;
    886 }
    887 
    888 static bool executeMoveWordLeft(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    889 {
    890     frame.selection().modify(FrameSelection::AlterationMove, DirectionLeft, WordGranularity, UserTriggered);
    891     return true;
    892 }
    893 
    894 static bool executeMoveWordLeftAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    895 {
    896     frame.selection().modify(FrameSelection::AlterationExtend, DirectionLeft, WordGranularity, UserTriggered);
    897     return true;
    898 }
    899 
    900 static bool executeMoveWordRight(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    901 {
    902     frame.selection().modify(FrameSelection::AlterationMove, DirectionRight, WordGranularity, UserTriggered);
    903     return true;
    904 }
    905 
    906 static bool executeMoveWordRightAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    907 {
    908     frame.selection().modify(FrameSelection::AlterationExtend, DirectionRight, WordGranularity, UserTriggered);
    909     return true;
    910 }
    911 
    912 static bool executeMoveToLeftEndOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    913 {
    914     frame.selection().modify(FrameSelection::AlterationMove, DirectionLeft, LineBoundary, UserTriggered);
    915     return true;
    916 }
    917 
    918 static bool executeMoveToLeftEndOfLineAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    919 {
    920     frame.selection().modify(FrameSelection::AlterationExtend, DirectionLeft, LineBoundary, UserTriggered);
    921     return true;
    922 }
    923 
    924 static bool executeMoveToRightEndOfLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    925 {
    926     frame.selection().modify(FrameSelection::AlterationMove, DirectionRight, LineBoundary, UserTriggered);
    927     return true;
    928 }
    929 
    930 static bool executeMoveToRightEndOfLineAndModifySelection(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    931 {
    932     frame.selection().modify(FrameSelection::AlterationExtend, DirectionRight, LineBoundary, UserTriggered);
    933     return true;
    934 }
    935 
    936 static bool executeOutdent(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    937 {
    938     ASSERT(frame.document());
    939     IndentOutdentCommand::create(*frame.document(), IndentOutdentCommand::Outdent)->apply();
    940     return true;
    941 }
    942 
    943 static bool executeToggleOverwrite(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    944 {
    945     frame.editor().toggleOverwriteModeEnabled();
    946     return true;
    947 }
    948 
    949 static bool executePaste(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    950 {
    951     frame.editor().paste();
    952     return true;
    953 }
    954 
    955 static bool executePasteGlobalSelection(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
    956 {
    957     if (!frame.editor().behavior().supportsGlobalSelection())
    958         return false;
    959     ASSERT_UNUSED(source, source == CommandFromMenuOrKeyBinding);
    960 
    961     bool oldSelectionMode = Pasteboard::generalPasteboard()->isSelectionMode();
    962     Pasteboard::generalPasteboard()->setSelectionMode(true);
    963     frame.editor().paste();
    964     Pasteboard::generalPasteboard()->setSelectionMode(oldSelectionMode);
    965     return true;
    966 }
    967 
    968 static bool executePasteAndMatchStyle(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    969 {
    970     frame.editor().pasteAsPlainText();
    971     return true;
    972 }
    973 
    974 static bool executePrint(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    975 {
    976     FrameHost* host = frame.host();
    977     if (!host)
    978         return false;
    979     host->chrome().print(&frame);
    980     return true;
    981 }
    982 
    983 static bool executeRedo(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    984 {
    985     frame.editor().redo();
    986     return true;
    987 }
    988 
    989 static bool executeRemoveFormat(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    990 {
    991     frame.editor().removeFormattingAndStyle();
    992     return true;
    993 }
    994 
    995 static bool executeScrollPageBackward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
    996 {
    997     return frame.eventHandler().bubblingScroll(ScrollBlockDirectionBackward, ScrollByPage);
    998 }
    999 
   1000 static bool executeScrollPageForward(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1001 {
   1002     return frame.eventHandler().bubblingScroll(ScrollBlockDirectionForward, ScrollByPage);
   1003 }
   1004 
   1005 static bool executeScrollLineUp(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1006 {
   1007     return frame.eventHandler().bubblingScroll(ScrollUp, ScrollByLine);
   1008 }
   1009 
   1010 static bool executeScrollLineDown(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1011 {
   1012     return frame.eventHandler().bubblingScroll(ScrollDown, ScrollByLine);
   1013 }
   1014 
   1015 static bool executeScrollToBeginningOfDocument(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1016 {
   1017     return frame.eventHandler().bubblingScroll(ScrollBlockDirectionBackward, ScrollByDocument);
   1018 }
   1019 
   1020 static bool executeScrollToEndOfDocument(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1021 {
   1022     return frame.eventHandler().bubblingScroll(ScrollBlockDirectionForward, ScrollByDocument);
   1023 }
   1024 
   1025 static bool executeSelectAll(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1026 {
   1027     frame.selection().selectAll();
   1028     return true;
   1029 }
   1030 
   1031 static bool executeSelectLine(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1032 {
   1033     return expandSelectionToGranularity(frame, LineGranularity);
   1034 }
   1035 
   1036 static bool executeSelectParagraph(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1037 {
   1038     return expandSelectionToGranularity(frame, ParagraphGranularity);
   1039 }
   1040 
   1041 static bool executeSelectSentence(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1042 {
   1043     return expandSelectionToGranularity(frame, SentenceGranularity);
   1044 }
   1045 
   1046 static bool executeSelectToMark(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1047 {
   1048     RefPtrWillBeRawPtr<Range> mark = frame.editor().mark().toNormalizedRange();
   1049     RefPtrWillBeRawPtr<Range> selection = frame.editor().selectedRange();
   1050     if (!mark || !selection)
   1051         return false;
   1052     frame.selection().setSelectedRange(unionDOMRanges(mark.get(), selection.get()).get(), DOWNSTREAM, FrameSelection::NonDirectional, FrameSelection::CloseTyping);
   1053     return true;
   1054 }
   1055 
   1056 static bool executeSelectWord(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1057 {
   1058     return expandSelectionToGranularity(frame, WordGranularity);
   1059 }
   1060 
   1061 static bool executeSetMark(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1062 {
   1063     frame.editor().setMark(frame.selection().selection());
   1064     return true;
   1065 }
   1066 
   1067 static bool executeStrikethrough(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1068 {
   1069     RefPtrWillBeRawPtr<CSSPrimitiveValue> lineThrough = CSSPrimitiveValue::createIdentifier(CSSValueLineThrough);
   1070     return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, lineThrough.get());
   1071 }
   1072 
   1073 static bool executeStyleWithCSS(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
   1074 {
   1075     frame.editor().setShouldStyleWithCSS(!equalIgnoringCase(value, "false"));
   1076     return true;
   1077 }
   1078 
   1079 static bool executeUseCSS(LocalFrame& frame, Event*, EditorCommandSource, const String& value)
   1080 {
   1081     frame.editor().setShouldStyleWithCSS(equalIgnoringCase(value, "false"));
   1082     return true;
   1083 }
   1084 
   1085 static bool executeSubscript(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1086 {
   1087     return executeToggleStyle(frame, source, EditActionSubscript, CSSPropertyVerticalAlign, "baseline", "sub");
   1088 }
   1089 
   1090 static bool executeSuperscript(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1091 {
   1092     return executeToggleStyle(frame, source, EditActionSuperscript, CSSPropertyVerticalAlign, "baseline", "super");
   1093 }
   1094 
   1095 static bool executeSwapWithMark(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1096 {
   1097     const VisibleSelection& mark = frame.editor().mark();
   1098     const VisibleSelection& selection = frame.selection().selection();
   1099     if (mark.isNone() || selection.isNone())
   1100         return false;
   1101     frame.selection().setSelection(mark);
   1102     frame.editor().setMark(selection);
   1103     return true;
   1104 }
   1105 
   1106 static bool executeToggleBold(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1107 {
   1108     return executeToggleStyle(frame, source, EditActionBold, CSSPropertyFontWeight, "normal", "bold");
   1109 }
   1110 
   1111 static bool executeToggleItalic(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1112 {
   1113     return executeToggleStyle(frame, source, EditActionItalics, CSSPropertyFontStyle, "normal", "italic");
   1114 }
   1115 
   1116 static bool executeTranspose(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1117 {
   1118     frame.editor().transpose();
   1119     return true;
   1120 }
   1121 
   1122 static bool executeUnderline(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1123 {
   1124     RefPtrWillBeRawPtr<CSSPrimitiveValue> underline = CSSPrimitiveValue::createIdentifier(CSSValueUnderline);
   1125     return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, underline.get());
   1126 }
   1127 
   1128 static bool executeUndo(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1129 {
   1130     frame.editor().undo();
   1131     return true;
   1132 }
   1133 
   1134 static bool executeUnlink(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1135 {
   1136     ASSERT(frame.document());
   1137     UnlinkCommand::create(*frame.document())->apply();
   1138     return true;
   1139 }
   1140 
   1141 static bool executeUnscript(LocalFrame& frame, Event*, EditorCommandSource source, const String&)
   1142 {
   1143     return executeApplyStyle(frame, source, EditActionUnscript, CSSPropertyVerticalAlign, "baseline");
   1144 }
   1145 
   1146 static bool executeUnselect(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1147 {
   1148     frame.selection().clear();
   1149     return true;
   1150 }
   1151 
   1152 static bool executeYank(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1153 {
   1154     frame.editor().insertTextWithoutSendingTextEvent(frame.editor().killRing().yank(), false, 0);
   1155     frame.editor().killRing().setToYankedState();
   1156     return true;
   1157 }
   1158 
   1159 static bool executeYankAndSelect(LocalFrame& frame, Event*, EditorCommandSource, const String&)
   1160 {
   1161     frame.editor().insertTextWithoutSendingTextEvent(frame.editor().killRing().yank(), true, 0);
   1162     frame.editor().killRing().setToYankedState();
   1163     return true;
   1164 }
   1165 
   1166 // Supported functions
   1167 
   1168 static bool supported(LocalFrame*)
   1169 {
   1170     return true;
   1171 }
   1172 
   1173 static bool supportedFromMenuOrKeyBinding(LocalFrame*)
   1174 {
   1175     return false;
   1176 }
   1177 
   1178 static bool supportedCopyCut(LocalFrame* frame)
   1179 {
   1180     if (!frame)
   1181         return false;
   1182 
   1183     Settings* settings = frame->settings();
   1184     bool defaultValue = settings && settings->javaScriptCanAccessClipboard();
   1185     return frame->editor().client().canCopyCut(frame, defaultValue);
   1186 }
   1187 
   1188 static bool supportedPaste(LocalFrame* frame)
   1189 {
   1190     if (!frame)
   1191         return false;
   1192 
   1193     Settings* settings = frame->settings();
   1194     bool defaultValue = settings && settings->javaScriptCanAccessClipboard() && settings->DOMPasteAllowed();
   1195     return frame->editor().client().canPaste(frame, defaultValue);
   1196 }
   1197 
   1198 // Enabled functions
   1199 
   1200 static bool enabled(LocalFrame&, Event*, EditorCommandSource)
   1201 {
   1202     return true;
   1203 }
   1204 
   1205 static bool enabledVisibleSelection(LocalFrame& frame, Event* event, EditorCommandSource)
   1206 {
   1207     // The term "visible" here includes a caret in editable text or a range in any text.
   1208     const VisibleSelection& selection = frame.editor().selectionForCommand(event);
   1209     return (selection.isCaret() && selection.isContentEditable()) || selection.isRange();
   1210 }
   1211 
   1212 static bool caretBrowsingEnabled(LocalFrame& frame)
   1213 {
   1214     return frame.settings() && frame.settings()->caretBrowsingEnabled();
   1215 }
   1216 
   1217 static EditorCommandSource dummyEditorCommandSource = static_cast<EditorCommandSource>(0);
   1218 
   1219 static bool enabledVisibleSelectionOrCaretBrowsing(LocalFrame& frame, Event* event, EditorCommandSource)
   1220 {
   1221     // The EditorCommandSource parameter is unused in enabledVisibleSelection, so just pass a dummy variable
   1222     return caretBrowsingEnabled(frame) || enabledVisibleSelection(frame, event, dummyEditorCommandSource);
   1223 }
   1224 
   1225 static bool enabledVisibleSelectionAndMark(LocalFrame& frame, Event* event, EditorCommandSource)
   1226 {
   1227     const VisibleSelection& selection = frame.editor().selectionForCommand(event);
   1228     return ((selection.isCaret() && selection.isContentEditable()) || selection.isRange())
   1229         && frame.editor().mark().isCaretOrRange();
   1230 }
   1231 
   1232 static bool enableCaretInEditableText(LocalFrame& frame, Event* event, EditorCommandSource)
   1233 {
   1234     const VisibleSelection& selection = frame.editor().selectionForCommand(event);
   1235     return selection.isCaret() && selection.isContentEditable();
   1236 }
   1237 
   1238 static bool enabledCopy(LocalFrame& frame, Event*, EditorCommandSource)
   1239 {
   1240     return frame.editor().canDHTMLCopy() || frame.editor().canCopy();
   1241 }
   1242 
   1243 static bool enabledCut(LocalFrame& frame, Event*, EditorCommandSource)
   1244 {
   1245     return frame.editor().canDHTMLCut() || frame.editor().canCut();
   1246 }
   1247 
   1248 static bool enabledInEditableText(LocalFrame& frame, Event* event, EditorCommandSource)
   1249 {
   1250     return frame.editor().selectionForCommand(event).rootEditableElement();
   1251 }
   1252 
   1253 static bool enabledDelete(LocalFrame& frame, Event* event, EditorCommandSource source)
   1254 {
   1255     switch (source) {
   1256     case CommandFromMenuOrKeyBinding:
   1257         return frame.editor().canDelete();
   1258     case CommandFromDOM:
   1259     case CommandFromDOMWithUserInterface:
   1260         // "Delete" from DOM is like delete/backspace keypress, affects selected range if non-empty,
   1261         // otherwise removes a character
   1262         return enabledInEditableText(frame, event, source);
   1263     }
   1264     ASSERT_NOT_REACHED();
   1265     return false;
   1266 }
   1267 
   1268 static bool enabledInEditableTextOrCaretBrowsing(LocalFrame& frame, Event* event, EditorCommandSource)
   1269 {
   1270     // The EditorCommandSource parameter is unused in enabledInEditableText, so just pass a dummy variable
   1271     return caretBrowsingEnabled(frame) || enabledInEditableText(frame, event, dummyEditorCommandSource);
   1272 }
   1273 
   1274 static bool enabledInRichlyEditableText(LocalFrame& frame, Event*, EditorCommandSource)
   1275 {
   1276     return frame.selection().isCaretOrRange() && frame.selection().isContentRichlyEditable() && frame.selection().rootEditableElement();
   1277 }
   1278 
   1279 static bool enabledPaste(LocalFrame& frame, Event*, EditorCommandSource)
   1280 {
   1281     return frame.editor().canPaste();
   1282 }
   1283 
   1284 static bool enabledRangeInEditableText(LocalFrame& frame, Event*, EditorCommandSource)
   1285 {
   1286     return frame.selection().isRange() && frame.selection().isContentEditable();
   1287 }
   1288 
   1289 static bool enabledRangeInRichlyEditableText(LocalFrame& frame, Event*, EditorCommandSource)
   1290 {
   1291     return frame.selection().isRange() && frame.selection().isContentRichlyEditable();
   1292 }
   1293 
   1294 static bool enabledRedo(LocalFrame& frame, Event*, EditorCommandSource)
   1295 {
   1296     return frame.editor().canRedo();
   1297 }
   1298 
   1299 static bool enabledUndo(LocalFrame& frame, Event*, EditorCommandSource)
   1300 {
   1301     return frame.editor().canUndo();
   1302 }
   1303 
   1304 // State functions
   1305 
   1306 static TriState stateNone(LocalFrame&, Event*)
   1307 {
   1308     return FalseTriState;
   1309 }
   1310 
   1311 static TriState stateBold(LocalFrame& frame, Event*)
   1312 {
   1313     return stateStyle(frame, CSSPropertyFontWeight, "bold");
   1314 }
   1315 
   1316 static TriState stateItalic(LocalFrame& frame, Event*)
   1317 {
   1318     return stateStyle(frame, CSSPropertyFontStyle, "italic");
   1319 }
   1320 
   1321 static TriState stateOrderedList(LocalFrame& frame, Event*)
   1322 {
   1323     return selectionListState(frame.selection(), olTag);
   1324 }
   1325 
   1326 static TriState stateStrikethrough(LocalFrame& frame, Event*)
   1327 {
   1328     return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "line-through");
   1329 }
   1330 
   1331 static TriState stateStyleWithCSS(LocalFrame& frame, Event*)
   1332 {
   1333     return frame.editor().shouldStyleWithCSS() ? TrueTriState : FalseTriState;
   1334 }
   1335 
   1336 static TriState stateSubscript(LocalFrame& frame, Event*)
   1337 {
   1338     return stateStyle(frame, CSSPropertyVerticalAlign, "sub");
   1339 }
   1340 
   1341 static TriState stateSuperscript(LocalFrame& frame, Event*)
   1342 {
   1343     return stateStyle(frame, CSSPropertyVerticalAlign, "super");
   1344 }
   1345 
   1346 static TriState stateTextWritingDirectionLeftToRight(LocalFrame& frame, Event*)
   1347 {
   1348     return stateTextWritingDirection(frame, LeftToRightWritingDirection);
   1349 }
   1350 
   1351 static TriState stateTextWritingDirectionNatural(LocalFrame& frame, Event*)
   1352 {
   1353     return stateTextWritingDirection(frame, NaturalWritingDirection);
   1354 }
   1355 
   1356 static TriState stateTextWritingDirectionRightToLeft(LocalFrame& frame, Event*)
   1357 {
   1358     return stateTextWritingDirection(frame, RightToLeftWritingDirection);
   1359 }
   1360 
   1361 static TriState stateUnderline(LocalFrame& frame, Event*)
   1362 {
   1363     return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "underline");
   1364 }
   1365 
   1366 static TriState stateUnorderedList(LocalFrame& frame, Event*)
   1367 {
   1368     return selectionListState(frame.selection(), ulTag);
   1369 }
   1370 
   1371 static TriState stateJustifyCenter(LocalFrame& frame, Event*)
   1372 {
   1373     return stateStyle(frame, CSSPropertyTextAlign, "center");
   1374 }
   1375 
   1376 static TriState stateJustifyFull(LocalFrame& frame, Event*)
   1377 {
   1378     return stateStyle(frame, CSSPropertyTextAlign, "justify");
   1379 }
   1380 
   1381 static TriState stateJustifyLeft(LocalFrame& frame, Event*)
   1382 {
   1383     return stateStyle(frame, CSSPropertyTextAlign, "left");
   1384 }
   1385 
   1386 static TriState stateJustifyRight(LocalFrame& frame, Event*)
   1387 {
   1388     return stateStyle(frame, CSSPropertyTextAlign, "right");
   1389 }
   1390 
   1391 // Value functions
   1392 
   1393 static String valueNull(LocalFrame&, Event*)
   1394 {
   1395     return String();
   1396 }
   1397 
   1398 static String valueBackColor(LocalFrame& frame, Event*)
   1399 {
   1400     return valueStyle(frame, CSSPropertyBackgroundColor);
   1401 }
   1402 
   1403 static String valueDefaultParagraphSeparator(LocalFrame& frame, Event*)
   1404 {
   1405     switch (frame.editor().defaultParagraphSeparator()) {
   1406     case EditorParagraphSeparatorIsDiv:
   1407         return divTag.localName();
   1408     case EditorParagraphSeparatorIsP:
   1409         return pTag.localName();
   1410     }
   1411 
   1412     ASSERT_NOT_REACHED();
   1413     return String();
   1414 }
   1415 
   1416 static String valueFontName(LocalFrame& frame, Event*)
   1417 {
   1418     return valueStyle(frame, CSSPropertyFontFamily);
   1419 }
   1420 
   1421 static String valueFontSize(LocalFrame& frame, Event*)
   1422 {
   1423     return valueStyle(frame, CSSPropertyFontSize);
   1424 }
   1425 
   1426 static String valueFontSizeDelta(LocalFrame& frame, Event*)
   1427 {
   1428     return valueStyle(frame, CSSPropertyWebkitFontSizeDelta);
   1429 }
   1430 
   1431 static String valueForeColor(LocalFrame& frame, Event*)
   1432 {
   1433     return valueStyle(frame, CSSPropertyColor);
   1434 }
   1435 
   1436 static String valueFormatBlock(LocalFrame& frame, Event*)
   1437 {
   1438     const VisibleSelection& selection = frame.selection().selection();
   1439     if (!selection.isNonOrphanedCaretOrRange() || !selection.isContentEditable())
   1440         return "";
   1441     Element* formatBlockElement = FormatBlockCommand::elementForFormatBlockCommand(selection.firstRange().get());
   1442     if (!formatBlockElement)
   1443         return "";
   1444     return formatBlockElement->localName();
   1445 }
   1446 
   1447 // Map of functions
   1448 
   1449 struct CommandEntry {
   1450     const char* name;
   1451     EditorInternalCommand command;
   1452 };
   1453 
   1454 static const CommandMap& createCommandMap()
   1455 {
   1456     // If you add new commands, you should assign new Id to each idForUserMetrics and update MappedEditingCommands
   1457     // in chrome/trunk/src/tools/metrics/histograms/histograms.xml.
   1458     static const CommandEntry commands[] = {
   1459         { "AlignCenter", {139, executeJustifyCenter, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1460         { "AlignJustified", {1, executeJustifyFull, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1461         { "AlignLeft", {2, executeJustifyLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1462         { "AlignRight", {3, executeJustifyRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1463         { "BackColor", {4, executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueBackColor, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1464         { "BackwardDelete", {5, executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, // FIXME: remove BackwardDelete when Safari for Windows stops using it.
   1465         { "Bold", {6, executeToggleBold, supported, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1466         { "Copy", {7, executeCopy, supportedCopyCut, enabledCopy, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } },
   1467         { "CreateLink", {8, executeCreateLink, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1468         { "Cut", {9, executeCut, supportedCopyCut, enabledCut, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } },
   1469         { "DefaultParagraphSeparator", {10, executeDefaultParagraphSeparator, supported, enabled, stateNone, valueDefaultParagraphSeparator, notTextInsertion, doNotAllowExecutionWhenDisabled} },
   1470         { "Delete", {11, executeDelete, supported, enabledDelete, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1471         { "DeleteBackward", {12, executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1472         { "DeleteBackwardByDecomposingPreviousCharacter", {13, executeDeleteBackwardByDecomposingPreviousCharacter, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1473         { "DeleteForward", {14, executeDeleteForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1474         { "DeleteToBeginningOfLine", {15, executeDeleteToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1475         { "DeleteToBeginningOfParagraph", {16, executeDeleteToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1476         { "DeleteToEndOfLine", {17, executeDeleteToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1477         { "DeleteToEndOfParagraph", {18, executeDeleteToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1478         { "DeleteToMark", {19, executeDeleteToMark, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1479         { "DeleteWordBackward", {20, executeDeleteWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1480         { "DeleteWordForward", {21, executeDeleteWordForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1481         { "FindString", {22, executeFindString, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1482         { "FontName", {23, executeFontName, supported, enabledInEditableText, stateNone, valueFontName, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1483         { "FontSize", {24, executeFontSize, supported, enabledInEditableText, stateNone, valueFontSize, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1484         { "FontSizeDelta", {25, executeFontSizeDelta, supported, enabledInEditableText, stateNone, valueFontSizeDelta, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1485         { "ForeColor", {26, executeForeColor, supported, enabledInRichlyEditableText, stateNone, valueForeColor, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1486         { "FormatBlock", {27, executeFormatBlock, supported, enabledInRichlyEditableText, stateNone, valueFormatBlock, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1487         { "ForwardDelete", {28, executeForwardDelete, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1488         { "HiliteColor", {29, executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1489         { "IgnoreSpelling", {30, executeIgnoreSpelling, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1490         { "Indent", {31, executeIndent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1491         { "InsertBacktab", {32, executeInsertBacktab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } },
   1492         { "InsertHTML", {33, executeInsertHTML, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1493         { "InsertHorizontalRule", {34, executeInsertHorizontalRule, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1494         { "InsertImage", {35, executeInsertImage, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1495         { "InsertLineBreak", {36, executeInsertLineBreak, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } },
   1496         { "InsertNewline", {37, executeInsertNewline, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } },
   1497         { "InsertNewlineInQuotedContent", {38, executeInsertNewlineInQuotedContent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1498         { "InsertOrderedList", {39, executeInsertOrderedList, supported, enabledInRichlyEditableText, stateOrderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1499         { "InsertParagraph", {40, executeInsertParagraph, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1500         { "InsertTab", {41, executeInsertTab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } },
   1501         { "InsertText", {42, executeInsertText, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } },
   1502         { "InsertUnorderedList", {43, executeInsertUnorderedList, supported, enabledInRichlyEditableText, stateUnorderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1503         { "Italic", {44, executeToggleItalic, supported, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1504         { "JustifyCenter", {45, executeJustifyCenter, supported, enabledInRichlyEditableText, stateJustifyCenter, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1505         { "JustifyFull", {46, executeJustifyFull, supported, enabledInRichlyEditableText, stateJustifyFull, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1506         { "JustifyLeft", {47, executeJustifyLeft, supported, enabledInRichlyEditableText, stateJustifyLeft, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1507         { "JustifyNone", {48, executeJustifyLeft, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1508         { "JustifyRight", {49, executeJustifyRight, supported, enabledInRichlyEditableText, stateJustifyRight, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1509         { "MakeTextWritingDirectionLeftToRight", {50, executeMakeTextWritingDirectionLeftToRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionLeftToRight, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1510         { "MakeTextWritingDirectionNatural", {51, executeMakeTextWritingDirectionNatural, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionNatural, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1511         { "MakeTextWritingDirectionRightToLeft", {52, executeMakeTextWritingDirectionRightToLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionRightToLeft, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1512         { "MoveBackward", {53, executeMoveBackward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1513         { "MoveBackwardAndModifySelection", {54, executeMoveBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1514         { "MoveDown", {55, executeMoveDown, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1515         { "MoveDownAndModifySelection", {56, executeMoveDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1516         { "MoveForward", {57, executeMoveForward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1517         { "MoveForwardAndModifySelection", {58, executeMoveForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1518         { "MoveLeft", {59, executeMoveLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1519         { "MoveLeftAndModifySelection", {60, executeMoveLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1520         { "MovePageDown", {61, executeMovePageDown, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1521         { "MovePageDownAndModifySelection", {62, executeMovePageDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1522         { "MovePageUp", {63, executeMovePageUp, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1523         { "MovePageUpAndModifySelection", {64, executeMovePageUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1524         { "MoveParagraphBackward", {65, executeMoveParagraphBackward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1525         { "MoveParagraphBackwardAndModifySelection", {66, executeMoveParagraphBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1526         { "MoveParagraphForward", {67, executeMoveParagraphForward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1527         { "MoveParagraphForwardAndModifySelection", {68, executeMoveParagraphForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1528         { "MoveRight", {69, executeMoveRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1529         { "MoveRightAndModifySelection", {70, executeMoveRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1530         { "MoveToBeginningOfDocument", {71, executeMoveToBeginningOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1531         { "MoveToBeginningOfDocumentAndModifySelection", {72, executeMoveToBeginningOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1532         { "MoveToBeginningOfLine", {73, executeMoveToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1533         { "MoveToBeginningOfLineAndModifySelection", {74, executeMoveToBeginningOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1534         { "MoveToBeginningOfParagraph", {75, executeMoveToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1535         { "MoveToBeginningOfParagraphAndModifySelection", {76, executeMoveToBeginningOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1536         { "MoveToBeginningOfSentence", {77, executeMoveToBeginningOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1537         { "MoveToBeginningOfSentenceAndModifySelection", {78, executeMoveToBeginningOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1538         { "MoveToEndOfDocument", {79, executeMoveToEndOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1539         { "MoveToEndOfDocumentAndModifySelection", {80, executeMoveToEndOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1540         { "MoveToEndOfLine", {81, executeMoveToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1541         { "MoveToEndOfLineAndModifySelection", {82, executeMoveToEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1542         { "MoveToEndOfParagraph", {83, executeMoveToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1543         { "MoveToEndOfParagraphAndModifySelection", {84, executeMoveToEndOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1544         { "MoveToEndOfSentence", {85, executeMoveToEndOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1545         { "MoveToEndOfSentenceAndModifySelection", {86, executeMoveToEndOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1546         { "MoveToLeftEndOfLine", {87, executeMoveToLeftEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1547         { "MoveToLeftEndOfLineAndModifySelection", {88, executeMoveToLeftEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1548         { "MoveToRightEndOfLine", {89, executeMoveToRightEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1549         { "MoveToRightEndOfLineAndModifySelection", {90, executeMoveToRightEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1550         { "MoveUp", {91, executeMoveUp, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1551         { "MoveUpAndModifySelection", {92, executeMoveUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1552         { "MoveWordBackward", {93, executeMoveWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1553         { "MoveWordBackwardAndModifySelection", {94, executeMoveWordBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1554         { "MoveWordForward", {95, executeMoveWordForward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1555         { "MoveWordForwardAndModifySelection", {96, executeMoveWordForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1556         { "MoveWordLeft", {97, executeMoveWordLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1557         { "MoveWordLeftAndModifySelection", {98, executeMoveWordLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1558         { "MoveWordRight", {99, executeMoveWordRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1559         { "MoveWordRightAndModifySelection", {100, executeMoveWordRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1560         { "Outdent", {101, executeOutdent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1561         { "OverWrite", {102, executeToggleOverwrite, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1562         { "Paste", {103, executePaste, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } },
   1563         { "PasteAndMatchStyle", {104, executePasteAndMatchStyle, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } },
   1564         { "PasteGlobalSelection", {105, executePasteGlobalSelection, supportedFromMenuOrKeyBinding, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } },
   1565         { "Print", {106, executePrint, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1566         { "Redo", {107, executeRedo, supported, enabledRedo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1567         { "RemoveFormat", {108, executeRemoveFormat, supported, enabledRangeInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1568         { "ScrollPageBackward", {109, executeScrollPageBackward, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1569         { "ScrollPageForward", {110, executeScrollPageForward, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1570         { "ScrollLineUp", {111, executeScrollLineUp, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1571         { "ScrollLineDown", {112, executeScrollLineDown, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1572         { "ScrollToBeginningOfDocument", {113, executeScrollToBeginningOfDocument, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1573         { "ScrollToEndOfDocument", {114, executeScrollToEndOfDocument, supportedFromMenuOrKeyBinding, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1574         { "SelectAll", {115, executeSelectAll, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1575         { "SelectLine", {116, executeSelectLine, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1576         { "SelectParagraph", {117, executeSelectParagraph, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1577         { "SelectSentence", {118, executeSelectSentence, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1578         { "SelectToMark", {119, executeSelectToMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1579         { "SelectWord", {120, executeSelectWord, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1580         { "SetMark", {121, executeSetMark, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1581         { "Strikethrough", {122, executeStrikethrough, supported, enabledInRichlyEditableText, stateStrikethrough, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1582         { "StyleWithCSS", {123, executeStyleWithCSS, supported, enabled, stateStyleWithCSS, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1583         { "Subscript", {124, executeSubscript, supported, enabledInRichlyEditableText, stateSubscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1584         { "Superscript", {125, executeSuperscript, supported, enabledInRichlyEditableText, stateSuperscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1585         { "SwapWithMark", {126, executeSwapWithMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1586         { "ToggleBold", {127, executeToggleBold, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1587         { "ToggleItalic", {128, executeToggleItalic, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1588         { "ToggleUnderline", {129, executeUnderline, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1589         { "Transpose", {130, executeTranspose, supported, enableCaretInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1590         { "Underline", {131, executeUnderline, supported, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1591         { "Undo", {132, executeUndo, supported, enabledUndo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1592         { "Unlink", {133, executeUnlink, supported, enabledRangeInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1593         { "Unscript", {134, executeUnscript, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1594         { "Unselect", {135, executeUnselect, supported, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1595         { "UseCSS", {136, executeUseCSS, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1596         { "Yank", {137, executeYank, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1597         { "YankAndSelect", {138, executeYankAndSelect, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } },
   1598     };
   1599 
   1600     // These unsupported commands are listed here since they appear in the Microsoft
   1601     // documentation used as the starting point for our DOM executeCommand support.
   1602     //
   1603     // 2D-Position (not supported)
   1604     // AbsolutePosition (not supported)
   1605     // BlockDirLTR (not supported)
   1606     // BlockDirRTL (not supported)
   1607     // BrowseMode (not supported)
   1608     // ClearAuthenticationCache (not supported)
   1609     // CreateBookmark (not supported)
   1610     // DirLTR (not supported)
   1611     // DirRTL (not supported)
   1612     // EditMode (not supported)
   1613     // InlineDirLTR (not supported)
   1614     // InlineDirRTL (not supported)
   1615     // InsertButton (not supported)
   1616     // InsertFieldSet (not supported)
   1617     // InsertIFrame (not supported)
   1618     // InsertInputButton (not supported)
   1619     // InsertInputCheckbox (not supported)
   1620     // InsertInputFileUpload (not supported)
   1621     // InsertInputHidden (not supported)
   1622     // InsertInputImage (not supported)
   1623     // InsertInputPassword (not supported)
   1624     // InsertInputRadio (not supported)
   1625     // InsertInputReset (not supported)
   1626     // InsertInputSubmit (not supported)
   1627     // InsertInputText (not supported)
   1628     // InsertMarquee (not supported)
   1629     // InsertSelectDropDown (not supported)
   1630     // InsertSelectListBox (not supported)
   1631     // InsertTextArea (not supported)
   1632     // LiveResize (not supported)
   1633     // MultipleSelection (not supported)
   1634     // Open (not supported)
   1635     // PlayImage (not supported)
   1636     // Refresh (not supported)
   1637     // RemoveParaFormat (not supported)
   1638     // SaveAs (not supported)
   1639     // SizeToControl (not supported)
   1640     // SizeToControlHeight (not supported)
   1641     // SizeToControlWidth (not supported)
   1642     // Stop (not supported)
   1643     // StopImage (not supported)
   1644     // Unbookmark (not supported)
   1645 
   1646     CommandMap& commandMap = *new CommandMap;
   1647 #if ENABLE(ASSERT)
   1648     HashSet<int> idSet;
   1649 #endif
   1650     for (size_t i = 0; i < WTF_ARRAY_LENGTH(commands); ++i) {
   1651         const CommandEntry& command = commands[i];
   1652         ASSERT(!commandMap.get(command.name));
   1653         commandMap.set(command.name, &command.command);
   1654 #if ENABLE(ASSERT)
   1655         ASSERT(!idSet.contains(command.command.idForUserMetrics));
   1656         idSet.add(command.command.idForUserMetrics);
   1657 #endif
   1658     }
   1659 
   1660     return commandMap;
   1661 }
   1662 
   1663 static const EditorInternalCommand* internalCommand(const String& commandName)
   1664 {
   1665     static const CommandMap& commandMap = createCommandMap();
   1666     return commandName.isEmpty() ? 0 : commandMap.get(commandName);
   1667 }
   1668 
   1669 Editor::Command Editor::command(const String& commandName)
   1670 {
   1671     return Command(internalCommand(commandName), CommandFromMenuOrKeyBinding, m_frame);
   1672 }
   1673 
   1674 Editor::Command Editor::command(const String& commandName, EditorCommandSource source)
   1675 {
   1676     return Command(internalCommand(commandName), source, m_frame);
   1677 }
   1678 
   1679 bool Editor::executeCommand(const String& commandName)
   1680 {
   1681     // Specially handling commands that Editor::execCommand does not directly
   1682     // support.
   1683     if (commandName == "DeleteToEndOfParagraph") {
   1684         if (!deleteWithDirection(DirectionForward, ParagraphBoundary, true, false))
   1685             deleteWithDirection(DirectionForward, CharacterGranularity, true, false);
   1686         return true;
   1687     }
   1688     if (commandName == "DeleteBackward")
   1689         return command(AtomicString("BackwardDelete")).execute();
   1690     if (commandName == "DeleteForward")
   1691         return command(AtomicString("ForwardDelete")).execute();
   1692     if (commandName == "AdvanceToNextMisspelling") {
   1693         // Wee need to pass false here or else the currently selected word will never be skipped.
   1694         spellChecker().advanceToNextMisspelling(false);
   1695         return true;
   1696     }
   1697     if (commandName == "ToggleSpellPanel") {
   1698         spellChecker().showSpellingGuessPanel();
   1699         return true;
   1700     }
   1701     return command(commandName).execute();
   1702 }
   1703 
   1704 bool Editor::executeCommand(const String& commandName, const String& value)
   1705 {
   1706     // moveToBeginningOfDocument and moveToEndfDocument are only handled by WebKit for editable nodes.
   1707     if (!canEdit() && commandName == "moveToBeginningOfDocument")
   1708         return frame().eventHandler().bubblingScroll(ScrollUp, ScrollByDocument);
   1709 
   1710     if (!canEdit() && commandName == "moveToEndOfDocument")
   1711         return frame().eventHandler().bubblingScroll(ScrollDown, ScrollByDocument);
   1712 
   1713     if (commandName == "showGuessPanel") {
   1714         spellChecker().showSpellingGuessPanel();
   1715         return true;
   1716     }
   1717 
   1718     return command(commandName).execute(value);
   1719 }
   1720 
   1721 Editor::Command::Command()
   1722     : m_command(0)
   1723 {
   1724 }
   1725 
   1726 Editor::Command::Command(const EditorInternalCommand* command, EditorCommandSource source, PassRefPtrWillBeRawPtr<LocalFrame> frame)
   1727     : m_command(command)
   1728     , m_source(source)
   1729     , m_frame(command ? frame : nullptr)
   1730 {
   1731     // Use separate assertions so we can tell which bad thing happened.
   1732     if (!command)
   1733         ASSERT(!m_frame);
   1734     else
   1735         ASSERT(m_frame);
   1736 }
   1737 
   1738 bool Editor::Command::execute(const String& parameter, Event* triggeringEvent) const
   1739 {
   1740     if (!isEnabled(triggeringEvent)) {
   1741         // Let certain commands be executed when performed explicitly even if they are disabled.
   1742         if (!isSupported() || !m_frame || !m_command->allowExecutionWhenDisabled)
   1743             return false;
   1744     }
   1745     frame().document()->updateLayoutIgnorePendingStylesheets();
   1746     blink::Platform::current()->histogramSparse("WebCore.Editing.Commands", m_command->idForUserMetrics);
   1747     return m_command->execute(*m_frame, triggeringEvent, m_source, parameter);
   1748 }
   1749 
   1750 bool Editor::Command::execute(Event* triggeringEvent) const
   1751 {
   1752     return execute(String(), triggeringEvent);
   1753 }
   1754 
   1755 bool Editor::Command::isSupported() const
   1756 {
   1757     if (!m_command)
   1758         return false;
   1759     switch (m_source) {
   1760     case CommandFromMenuOrKeyBinding:
   1761         return true;
   1762     case CommandFromDOM:
   1763     case CommandFromDOMWithUserInterface:
   1764         return m_command->isSupportedFromDOM(m_frame.get());
   1765     }
   1766     ASSERT_NOT_REACHED();
   1767     return false;
   1768 }
   1769 
   1770 bool Editor::Command::isEnabled(Event* triggeringEvent) const
   1771 {
   1772     if (!isSupported() || !m_frame)
   1773         return false;
   1774     return m_command->isEnabled(*m_frame, triggeringEvent, m_source);
   1775 }
   1776 
   1777 TriState Editor::Command::state(Event* triggeringEvent) const
   1778 {
   1779     if (!isSupported() || !m_frame)
   1780         return FalseTriState;
   1781     return m_command->state(*m_frame, triggeringEvent);
   1782 }
   1783 
   1784 String Editor::Command::value(Event* triggeringEvent) const
   1785 {
   1786     if (!isSupported() || !m_frame)
   1787         return String();
   1788     if (m_command->value == valueNull && m_command->state != stateNone)
   1789         return m_command->state(*m_frame, triggeringEvent) == TrueTriState ? "true" : "false";
   1790     return m_command->value(*m_frame, triggeringEvent);
   1791 }
   1792 
   1793 bool Editor::Command::isTextInsertion() const
   1794 {
   1795     return m_command && m_command->isTextInsertion;
   1796 }
   1797 
   1798 int Editor::Command::idForHistogram() const
   1799 {
   1800     return isSupported() ? m_command->idForUserMetrics : 0;
   1801 }
   1802 
   1803 } // namespace blink
   1804