diff options
| author | Steve Block <steveblock@google.com> | 2011-05-13 06:44:40 -0700 |
|---|---|---|
| committer | Android (Google) Code Review <android-gerrit@google.com> | 2011-05-13 06:44:40 -0700 |
| commit | 08014c20784f3db5df3a89b73cce46037b77eb59 (patch) | |
| tree | 47749210d31e19e6e2f64036fa8fae2ad693476f /Source/WebCore/editing/EditorCommand.cpp | |
| parent | 860220379e56aeb66424861ad602b07ee22b4055 (diff) | |
| parent | 4c3661f7918f8b3f139f824efb7855bedccb4c94 (diff) | |
| download | external_webkit-08014c20784f3db5df3a89b73cce46037b77eb59.zip external_webkit-08014c20784f3db5df3a89b73cce46037b77eb59.tar.gz external_webkit-08014c20784f3db5df3a89b73cce46037b77eb59.tar.bz2 | |
Merge changes Ide388898,Ic49f367c,I1158a808,Iacb6ca5d,I2100dd3a,I5c1abe54,Ib0ef9902,I31dbc523,I570314b3
* changes:
Merge WebKit at r75315: Update WebKit version
Merge WebKit at r75315: Add FrameLoaderClient PageCache stubs
Merge WebKit at r75315: Stub out AXObjectCache::remove()
Merge WebKit at r75315: Fix ImageBuffer
Merge WebKit at r75315: Fix PluginData::initPlugins()
Merge WebKit at r75315: Fix conflicts
Merge WebKit at r75315: Fix Makefiles
Merge WebKit at r75315: Move Android-specific WebCore files to Source
Merge WebKit at r75315: Initial merge by git.
Diffstat (limited to 'Source/WebCore/editing/EditorCommand.cpp')
| -rw-r--r-- | Source/WebCore/editing/EditorCommand.cpp | 1666 |
1 files changed, 1666 insertions, 0 deletions
diff --git a/Source/WebCore/editing/EditorCommand.cpp b/Source/WebCore/editing/EditorCommand.cpp new file mode 100644 index 0000000..5de44a6 --- /dev/null +++ b/Source/WebCore/editing/EditorCommand.cpp @@ -0,0 +1,1666 @@ +/* + * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. + * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies) + * Copyright (C) 2009 Igalia S.L. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "Editor.h" + +#include "CSSComputedStyleDeclaration.h" +#include "CSSMutableStyleDeclaration.h" +#include "CSSPropertyNames.h" +#include "CSSValueKeywords.h" +#include "Chrome.h" +#include "CreateLinkCommand.h" +#include "DocumentFragment.h" +#include "EditorClient.h" +#include "Event.h" +#include "EventHandler.h" +#include "FormatBlockCommand.h" +#include "Frame.h" +#include "FrameView.h" +#include "HTMLFontElement.h" +#include "HTMLHRElement.h" +#include "HTMLImageElement.h" +#include "IndentOutdentCommand.h" +#include "InsertListCommand.h" +#include "KillRing.h" +#include "Page.h" +#include "RenderBox.h" +#include "ReplaceSelectionCommand.h" +#include "Scrollbar.h" +#include "Settings.h" +#include "Sound.h" +#include "TypingCommand.h" +#include "UnlinkCommand.h" +#include "htmlediting.h" +#include "markup.h" +#include <wtf/text/AtomicString.h> + +namespace WebCore { + +using namespace HTMLNames; + +class EditorInternalCommand { +public: + bool (*execute)(Frame*, Event*, EditorCommandSource, const String&); + bool (*isSupportedFromDOM)(Frame*); + bool (*isEnabled)(Frame*, Event*, EditorCommandSource); + TriState (*state)(Frame*, Event*); + String (*value)(Frame*, Event*); + bool isTextInsertion; + bool allowExecutionWhenDisabled; +}; + +typedef HashMap<String, const EditorInternalCommand*, CaseFoldingHash> CommandMap; + +static const bool notTextInsertion = false; +static const bool isTextInsertion = true; + +static const bool allowExecutionWhenDisabled = true; +static const bool doNotAllowExecutionWhenDisabled = false; + +// Related to Editor::selectionForCommand. +// Certain operations continue to use the target control's selection even if the event handler +// already moved the selection outside of the text control. +static Frame* targetFrame(Frame* frame, Event* event) +{ + if (!event) + return frame; + Node* node = event->target()->toNode(); + if (!node) + return frame; + return node->document()->frame(); +} + +static bool applyCommandToFrame(Frame* frame, EditorCommandSource source, EditAction action, CSSMutableStyleDeclaration* style) +{ + // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that? + switch (source) { + case CommandFromMenuOrKeyBinding: + frame->editor()->applyStyleToSelection(style, action); + return true; + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + frame->editor()->applyStyle(style); + return true; + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(propertyID, propertyValue); + return applyCommandToFrame(frame, source, action, style.get()); +} + +static bool executeApplyStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, int propertyValue) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(propertyID, propertyValue); + return applyCommandToFrame(frame, source, action, style.get()); +} + +// FIXME: executeToggleStyleInList does not handle complicated cases such as <b><u>hello</u>world</b> properly. +// This function must use Editor::selectionHasStyle to determine the current style but we cannot fix this +// until https://bugs.webkit.org/show_bug.cgi?id=27818 is resolved. +static bool executeToggleStyleInList(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, CSSValue* value) +{ + ExceptionCode ec = 0; + bool shouldUseFixedFontDefaultSize; + RefPtr<CSSMutableStyleDeclaration> selectionStyle = frame->editor()->selectionComputedStyle(shouldUseFixedFontDefaultSize); + if (!selectionStyle) + return false; + + RefPtr<CSSValue> selectedCSSValue = selectionStyle->getPropertyCSSValue(propertyID); + String newStyle = "none"; + if (selectedCSSValue->isValueList()) { + RefPtr<CSSValueList> selectedCSSValueList = static_cast<CSSValueList*>(selectedCSSValue.get()); + if (!selectedCSSValueList->removeAll(value)) + selectedCSSValueList->append(value); + if (selectedCSSValueList->length()) + newStyle = selectedCSSValueList->cssText(); + + } else if (selectedCSSValue->cssText() == "none") + newStyle = value->cssText(); + + // FIXME: We shouldn't be having to convert new style into text. We should have setPropertyCSSValue. + RefPtr<CSSMutableStyleDeclaration> newMutableStyle = CSSMutableStyleDeclaration::create(); + newMutableStyle->setProperty(propertyID, newStyle, ec); + return applyCommandToFrame(frame, source, action, newMutableStyle.get()); +} + +static bool executeToggleStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const char* offValue, const char* onValue) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(propertyID, onValue); // We need to add this style to pass it to selectionStartHasStyle / selectionHasStyle + + // Style is considered present when + // Mac: present at the beginning of selection + // other: present throughout the selection + + bool styleIsPresent; + if (frame->editor()->behavior().shouldToggleStyleBasedOnStartOfSelection()) + styleIsPresent = frame->editor()->selectionStartHasStyle(style.get()); + else + styleIsPresent = frame->editor()->selectionHasStyle(style.get()) == TrueTriState; + + style->setProperty(propertyID, styleIsPresent ? offValue : onValue); + return applyCommandToFrame(frame, source, action, style.get()); +} + +static bool executeApplyParagraphStyle(Frame* frame, EditorCommandSource source, EditAction action, int propertyID, const String& propertyValue) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(propertyID, propertyValue); + // FIXME: We don't call shouldApplyStyle when the source is DOM; is there a good reason for that? + switch (source) { + case CommandFromMenuOrKeyBinding: + frame->editor()->applyParagraphStyleToSelection(style.get(), action); + return true; + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + frame->editor()->applyParagraphStyle(style.get()); + return true; + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool executeInsertFragment(Frame* frame, PassRefPtr<DocumentFragment> fragment) +{ + applyCommand(ReplaceSelectionCommand::create(frame->document(), fragment, + false, false, false, true, false, EditActionUnspecified)); + return true; +} + +static bool executeInsertNode(Frame* frame, PassRefPtr<Node> content) +{ + RefPtr<DocumentFragment> fragment = DocumentFragment::create(frame->document()); + ExceptionCode ec = 0; + fragment->appendChild(content, ec); + if (ec) + return false; + return executeInsertFragment(frame, fragment.release()); +} + +static bool expandSelectionToGranularity(Frame* frame, TextGranularity granularity) +{ + VisibleSelection selection = frame->selection()->selection(); + selection.expandUsingGranularity(granularity); + RefPtr<Range> newRange = selection.toNormalizedRange(); + if (!newRange) + return false; + ExceptionCode ec = 0; + if (newRange->collapsed(ec)) + return false; + RefPtr<Range> oldRange = frame->selection()->selection().toNormalizedRange(); + EAffinity affinity = frame->selection()->affinity(); + if (!frame->editor()->client()->shouldChangeSelectedRange(oldRange.get(), newRange.get(), affinity, false)) + return false; + frame->selection()->setSelectedRange(newRange.get(), affinity, true); + return true; +} + +static TriState stateStyle(Frame* frame, int propertyID, const char* desiredValue) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(propertyID, desiredValue); + + if (frame->editor()->behavior().shouldToggleStyleBasedOnStartOfSelection()) + return frame->editor()->selectionStartHasStyle(style.get()) ? TrueTriState : FalseTriState; + return frame->editor()->selectionHasStyle(style.get()); +} + +static String valueStyle(Frame* frame, int propertyID) +{ + // FIXME: Rather than retrieving the style at the start of the current selection, + // we should retrieve the style present throughout the selection for non-Mac platforms. + return frame->editor()->selectionStartCSSPropertyValue(propertyID); +} + +static TriState stateTextWritingDirection(Frame* frame, WritingDirection direction) +{ + bool hasNestedOrMultipleEmbeddings; + WritingDirection selectionDirection = frame->editor()->textDirectionForSelection(hasNestedOrMultipleEmbeddings); + return (selectionDirection == direction && !hasNestedOrMultipleEmbeddings) ? TrueTriState : FalseTriState; +} + +static int verticalScrollDistance(Frame* frame) +{ + Node* focusedNode = frame->document()->focusedNode(); + if (!focusedNode) + return 0; + RenderObject* renderer = focusedNode->renderer(); + if (!renderer || !renderer->isBox()) + return 0; + RenderStyle* style = renderer->style(); + if (!style) + return 0; + if (!(style->overflowY() == OSCROLL || style->overflowY() == OAUTO || focusedNode->isContentEditable())) + return 0; + int height = std::min<int>(toRenderBox(renderer)->clientHeight(), + frame->view()->visibleHeight()); + return max(max<int>(height * Scrollbar::minFractionToStepWhenPaging(), height - Scrollbar::maxOverlapBetweenPages()), 1); +} + +static RefPtr<Range> unionDOMRanges(Range* a, Range* b) +{ + ExceptionCode ec = 0; + Range* start = a->compareBoundaryPoints(Range::START_TO_START, b, ec) <= 0 ? a : b; + ASSERT(!ec); + Range* end = a->compareBoundaryPoints(Range::END_TO_END, b, ec) <= 0 ? b : a; + ASSERT(!ec); + + return Range::create(a->startContainer(ec)->ownerDocument(), start->startContainer(ec), start->startOffset(ec), end->endContainer(ec), end->endOffset(ec)); +} + +// Execute command functions + +static bool executeBackColor(Frame* frame, Event*, EditorCommandSource source, const String& value) +{ + return executeApplyStyle(frame, source, EditActionSetBackgroundColor, CSSPropertyBackgroundColor, value); +} + +static bool executeCopy(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->copy(); + return true; +} + +static bool executeCreateLink(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + // FIXME: If userInterface is true, we should display a dialog box to let the user enter a URL. + if (value.isEmpty()) + return false; + applyCommand(CreateLinkCommand::create(frame->document(), value)); + return true; +} + +static bool executeCut(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->cut(); + return true; +} + +static bool executeDelete(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + switch (source) { + case CommandFromMenuOrKeyBinding: + // Doesn't modify the text if the current selection isn't a range. + frame->editor()->performDelete(); + return true; + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + // If the current selection is a caret, delete the preceding character. IE performs forwardDelete, but we currently side with Firefox. + // Doesn't scroll to make the selection visible, or modify the kill ring (this time, siding with IE, not Firefox). + TypingCommand::deleteKeyPressed(frame->document(), frame->selection()->granularity() == WordGranularity); + return true; + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool executeDeleteBackward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionBackward, CharacterGranularity, false, true); + return true; +} + +static bool executeDeleteBackwardByDecomposingPreviousCharacter(Frame* frame, Event*, EditorCommandSource, const String&) +{ + LOG_ERROR("DeleteBackwardByDecomposingPreviousCharacter is not implemented, doing DeleteBackward instead"); + frame->editor()->deleteWithDirection(DirectionBackward, CharacterGranularity, false, true); + return true; +} + +static bool executeDeleteForward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionForward, CharacterGranularity, false, true); + return true; +} + +static bool executeDeleteToBeginningOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionBackward, LineBoundary, true, false); + return true; +} + +static bool executeDeleteToBeginningOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionBackward, ParagraphBoundary, true, false); + return true; +} + +static bool executeDeleteToEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + // Despite its name, this command should delete the newline at the end of + // a paragraph if you are at the end of a paragraph (like DeleteToEndOfParagraph). + frame->editor()->deleteWithDirection(DirectionForward, LineBoundary, true, false); + return true; +} + +static bool executeDeleteToEndOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + // Despite its name, this command should delete the newline at the end of + // a paragraph if you are at the end of a paragraph. + frame->editor()->deleteWithDirection(DirectionForward, ParagraphBoundary, true, false); + return true; +} + +static bool executeDeleteToMark(Frame* frame, Event*, EditorCommandSource, const String&) +{ + RefPtr<Range> mark = frame->editor()->mark().toNormalizedRange(); + if (mark) { + SelectionController* selection = frame->selection(); + bool selected = selection->setSelectedRange(unionDOMRanges(mark.get(), frame->editor()->selectedRange().get()).get(), DOWNSTREAM, true); + ASSERT(selected); + if (!selected) + return false; + } + frame->editor()->performDelete(); + frame->editor()->setMark(frame->selection()->selection()); + return true; +} + +static bool executeDeleteWordBackward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionBackward, WordGranularity, true, false); + return true; +} + +static bool executeDeleteWordForward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->deleteWithDirection(DirectionForward, WordGranularity, true, false); + return true; +} + +static bool executeFindString(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + return frame->editor()->findString(value, true, false, true, false); +} + +static bool executeFontName(Frame* frame, Event*, EditorCommandSource source, const String& value) +{ + return executeApplyStyle(frame, source, EditActionSetFont, CSSPropertyFontFamily, value); +} + +static bool executeFontSize(Frame* frame, Event*, EditorCommandSource source, const String& value) +{ + int size; + if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size)) + return false; + return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontSize, size); +} + +static bool executeFontSizeDelta(Frame* frame, Event*, EditorCommandSource source, const String& value) +{ + return executeApplyStyle(frame, source, EditActionChangeAttributes, CSSPropertyWebkitFontSizeDelta, value); +} + +static bool executeForeColor(Frame* frame, Event*, EditorCommandSource source, const String& value) +{ + return executeApplyStyle(frame, source, EditActionSetColor, CSSPropertyColor, value); +} + +static bool executeFormatBlock(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + String tagName = value.lower(); + if (tagName[0] == '<' && tagName[tagName.length() - 1] == '>') + tagName = tagName.substring(1, tagName.length() - 2); + + ExceptionCode ec; + String localName, prefix; + if (!Document::parseQualifiedName(tagName, prefix, localName, ec)) + return false; + QualifiedName qualifiedTagName(prefix, localName, xhtmlNamespaceURI); + + RefPtr<FormatBlockCommand> command = FormatBlockCommand::create(frame->document(), qualifiedTagName); + applyCommand(command); + return command->didApply(); +} + +static bool executeForwardDelete(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + switch (source) { + case CommandFromMenuOrKeyBinding: + frame->editor()->deleteWithDirection(DirectionForward, CharacterGranularity, false, true); + return true; + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + // Doesn't scroll to make the selection visible, or modify the kill ring. + // ForwardDelete is not implemented in IE or Firefox, so this behavior is only needed for + // backward compatibility with ourselves, and for consistency with Delete. + TypingCommand::forwardDeleteKeyPressed(frame->document()); + return true; + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool executeIgnoreSpelling(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->ignoreSpelling(); + return true; +} + +static bool executeIndent(Frame* frame, Event*, EditorCommandSource, const String&) +{ + applyCommand(IndentOutdentCommand::create(frame->document(), IndentOutdentCommand::Indent)); + return true; +} + +static bool executeInsertBacktab(Frame* frame, Event* event, EditorCommandSource, const String&) +{ + return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\t", event, false, true); +} + +static bool executeInsertHorizontalRule(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + RefPtr<HTMLHRElement> rule = HTMLHRElement::create(frame->document()); + if (!value.isEmpty()) + rule->setIdAttribute(value); + return executeInsertNode(frame, rule.release()); +} + +static bool executeInsertHTML(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + return executeInsertFragment(frame, createFragmentFromMarkup(frame->document(), value, "")); +} + +static bool executeInsertImage(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + // FIXME: If userInterface is true, we should display a dialog box and let the user choose a local image. + RefPtr<HTMLImageElement> image = HTMLImageElement::create(frame->document()); + image->setSrc(value); + return executeInsertNode(frame, image.release()); +} + +static bool executeInsertLineBreak(Frame* frame, Event* event, EditorCommandSource source, const String&) +{ + switch (source) { + case CommandFromMenuOrKeyBinding: + return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\n", event, true); + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + // Doesn't scroll to make the selection visible, or modify the kill ring. + // InsertLineBreak is not implemented in IE or Firefox, so this behavior is only needed for + // backward compatibility with ourselves, and for consistency with other commands. + TypingCommand::insertLineBreak(frame->document()); + return true; + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool executeInsertNewline(Frame* frame, Event* event, EditorCommandSource, const String&) +{ + Frame* targetFrame = WebCore::targetFrame(frame, event); + return targetFrame->eventHandler()->handleTextInputEvent("\n", event, !targetFrame->editor()->canEditRichly()); +} + +static bool executeInsertNewlineInQuotedContent(Frame* frame, Event*, EditorCommandSource, const String&) +{ + TypingCommand::insertParagraphSeparatorInQuotedContent(frame->document()); + return true; +} + +static bool executeInsertOrderedList(Frame* frame, Event*, EditorCommandSource, const String&) +{ + applyCommand(InsertListCommand::create(frame->document(), InsertListCommand::OrderedList)); + return true; +} + +static bool executeInsertParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + TypingCommand::insertParagraphSeparator(frame->document()); + return true; +} + +static bool executeInsertTab(Frame* frame, Event* event, EditorCommandSource, const String&) +{ + return targetFrame(frame, event)->eventHandler()->handleTextInputEvent("\t", event, false, false); +} + +static bool executeInsertText(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + TypingCommand::insertText(frame->document(), value); + return true; +} + +static bool executeInsertUnorderedList(Frame* frame, Event*, EditorCommandSource, const String&) +{ + applyCommand(InsertListCommand::create(frame->document(), InsertListCommand::UnorderedList)); + return true; +} + +static bool executeJustifyCenter(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeApplyParagraphStyle(frame, source, EditActionCenter, CSSPropertyTextAlign, "center"); +} + +static bool executeJustifyFull(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeApplyParagraphStyle(frame, source, EditActionJustify, CSSPropertyTextAlign, "justify"); +} + +static bool executeJustifyLeft(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeApplyParagraphStyle(frame, source, EditActionAlignLeft, CSSPropertyTextAlign, "left"); +} + +static bool executeJustifyRight(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeApplyParagraphStyle(frame, source, EditActionAlignRight, CSSPropertyTextAlign, "right"); +} + +static bool executeMakeTextWritingDirectionLeftToRight(Frame* frame, Event*, EditorCommandSource, const String&) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed); + style->setProperty(CSSPropertyDirection, CSSValueLtr); + frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); + return true; +} + +static bool executeMakeTextWritingDirectionNatural(Frame* frame, Event*, EditorCommandSource, const String&) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal); + frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); + return true; +} + +static bool executeMakeTextWritingDirectionRightToLeft(Frame* frame, Event*, EditorCommandSource, const String&) +{ + RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create(); + style->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed); + style->setProperty(CSSPropertyDirection, CSSValueRtl); + frame->editor()->applyStyle(style.get(), EditActionSetWritingDirection); + return true; +} + +static bool executeMoveBackward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, CharacterGranularity, true); + return true; +} + +static bool executeMoveBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, CharacterGranularity, true); + return true; +} + +static bool executeMoveDown(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, LineGranularity, true); +} + +static bool executeMoveDownAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, LineGranularity, true); + return true; +} + +static bool executeMoveForward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, CharacterGranularity, true); + return true; +} + +static bool executeMoveForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, CharacterGranularity, true); + return true; +} + +static bool executeMoveLeft(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return frame->selection()->modify(SelectionController::AlterationMove, DirectionLeft, CharacterGranularity, true); +} + +static bool executeMoveLeftAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionLeft, CharacterGranularity, true); + return true; +} + +static bool executeMovePageDown(Frame* frame, Event*, EditorCommandSource, const String&) +{ + int distance = verticalScrollDistance(frame); + if (!distance) + return false; + return frame->selection()->modify(SelectionController::AlterationMove, distance, true, SelectionController::AlignCursorOnScrollAlways); +} + +static bool executeMovePageDownAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + int distance = verticalScrollDistance(frame); + if (!distance) + return false; + return frame->selection()->modify(SelectionController::AlterationExtend, distance, true, SelectionController::AlignCursorOnScrollAlways); +} + +static bool executeMovePageUp(Frame* frame, Event*, EditorCommandSource, const String&) +{ + int distance = verticalScrollDistance(frame); + if (!distance) + return false; + return frame->selection()->modify(SelectionController::AlterationMove, -distance, true, SelectionController::AlignCursorOnScrollAlways); +} + +static bool executeMovePageUpAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + int distance = verticalScrollDistance(frame); + if (!distance) + return false; + return frame->selection()->modify(SelectionController::AlterationExtend, -distance, true, SelectionController::AlignCursorOnScrollAlways); +} + +static bool executeMoveRight(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return frame->selection()->modify(SelectionController::AlterationMove, DirectionRight, CharacterGranularity, true); +} + +static bool executeMoveRightAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionRight, CharacterGranularity, true); + return true; +} + +static bool executeMoveToBeginningOfDocument(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, DocumentBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfDocumentAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, DocumentBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, LineBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, LineBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, ParagraphBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfParagraphAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, ParagraphBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfSentence(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, SentenceBoundary, true); + return true; +} + +static bool executeMoveToBeginningOfSentenceAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, SentenceBoundary, true); + return true; +} + +static bool executeMoveToEndOfDocument(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, DocumentBoundary, true); + return true; +} + +static bool executeMoveToEndOfDocumentAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, DocumentBoundary, true); + return true; +} + +static bool executeMoveToEndOfSentence(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, SentenceBoundary, true); + return true; +} + +static bool executeMoveToEndOfSentenceAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, SentenceBoundary, true); + return true; +} + +static bool executeMoveToEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, LineBoundary, true); + return true; +} + +static bool executeMoveToEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, LineBoundary, true); + return true; +} + +static bool executeMoveToEndOfParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, ParagraphBoundary, true); + return true; +} + +static bool executeMoveToEndOfParagraphAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, ParagraphBoundary, true); + return true; +} + +static bool executeMoveParagraphBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, ParagraphGranularity, true); + return true; +} + +static bool executeMoveParagraphForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, ParagraphGranularity, true); + return true; +} + +static bool executeMoveUp(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, LineGranularity, true); +} + +static bool executeMoveUpAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, LineGranularity, true); + return true; +} + +static bool executeMoveWordBackward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionBackward, WordGranularity, true); + return true; +} + +static bool executeMoveWordBackwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionBackward, WordGranularity, true); + return true; +} + +static bool executeMoveWordForward(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionForward, WordGranularity, true); + return true; +} + +static bool executeMoveWordForwardAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionForward, WordGranularity, true); + return true; +} + +static bool executeMoveWordLeft(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionLeft, WordGranularity, true); + return true; +} + +static bool executeMoveWordLeftAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionLeft, WordGranularity, true); + return true; +} + +static bool executeMoveWordRight(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionRight, WordGranularity, true); + return true; +} + +static bool executeMoveWordRightAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionRight, WordGranularity, true); + return true; +} + +static bool executeMoveToLeftEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionLeft, LineBoundary, true); + return true; +} + +static bool executeMoveToLeftEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionLeft, LineBoundary, true); + return true; +} + +static bool executeMoveToRightEndOfLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationMove, DirectionRight, LineBoundary, true); + return true; +} + +static bool executeMoveToRightEndOfLineAndModifySelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->modify(SelectionController::AlterationExtend, DirectionRight, LineBoundary, true); + return true; +} + +static bool executeOutdent(Frame* frame, Event*, EditorCommandSource, const String&) +{ + applyCommand(IndentOutdentCommand::create(frame->document(), IndentOutdentCommand::Outdent)); + return true; +} + +static bool executePaste(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->paste(); + return true; +} + +static bool executePasteAndMatchStyle(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->pasteAsPlainText(); + return true; +} + +static bool executePasteAsPlainText(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->pasteAsPlainText(); + return true; +} + +static bool executePrint(Frame* frame, Event*, EditorCommandSource, const String&) +{ + Page* page = frame->page(); + if (!page) + return false; + page->chrome()->print(frame); + return true; +} + +static bool executeRedo(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->redo(); + return true; +} + +static bool executeRemoveFormat(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->removeFormattingAndStyle(); + return true; +} + +static bool executeSelectAll(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->selectAll(); + return true; +} + +static bool executeSelectLine(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return expandSelectionToGranularity(frame, LineGranularity); +} + +static bool executeSelectParagraph(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return expandSelectionToGranularity(frame, ParagraphGranularity); +} + +static bool executeSelectSentence(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return expandSelectionToGranularity(frame, SentenceGranularity); +} + +static bool executeSelectToMark(Frame* frame, Event*, EditorCommandSource, const String&) +{ + RefPtr<Range> mark = frame->editor()->mark().toNormalizedRange(); + RefPtr<Range> selection = frame->editor()->selectedRange(); + if (!mark || !selection) { + systemBeep(); + return false; + } + frame->selection()->setSelectedRange(unionDOMRanges(mark.get(), selection.get()).get(), DOWNSTREAM, true); + return true; +} + +static bool executeSelectWord(Frame* frame, Event*, EditorCommandSource, const String&) +{ + return expandSelectionToGranularity(frame, WordGranularity); +} + +static bool executeSetMark(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->setMark(frame->selection()->selection()); + return true; +} + +static bool executeStrikethrough(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + RefPtr<CSSPrimitiveValue> lineThrough = CSSPrimitiveValue::createIdentifier(CSSValueLineThrough); + return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, lineThrough.get()); +} + +static bool executeStyleWithCSS(Frame* frame, Event*, EditorCommandSource, const String& value) +{ + if (value != "false" && value != "true") + return false; + + frame->editor()->setShouldStyleWithCSS(value == "true" ? true : false); + return true; +} + +static bool executeSubscript(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeToggleStyle(frame, source, EditActionSubscript, CSSPropertyVerticalAlign, "baseline", "sub"); +} + +static bool executeSuperscript(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeToggleStyle(frame, source, EditActionSuperscript, CSSPropertyVerticalAlign, "baseline", "super"); +} + +static bool executeSwapWithMark(Frame* frame, Event*, EditorCommandSource, const String&) +{ + const VisibleSelection& mark = frame->editor()->mark(); + const VisibleSelection& selection = frame->selection()->selection(); + if (mark.isNone() || selection.isNone()) { + systemBeep(); + return false; + } + frame->selection()->setSelection(mark); + frame->editor()->setMark(selection); + return true; +} + +#if PLATFORM(MAC) +static bool executeTakeFindStringFromSelection(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->takeFindStringFromSelection(); + return true; +} +#endif + +static bool executeToggleBold(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeToggleStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontWeight, "normal", "bold"); +} + +static bool executeToggleItalic(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeToggleStyle(frame, source, EditActionChangeAttributes, CSSPropertyFontStyle, "normal", "italic"); +} + +static bool executeTranspose(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->transpose(); + return true; +} + +static bool executeUnderline(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + RefPtr<CSSPrimitiveValue> underline = CSSPrimitiveValue::createIdentifier(CSSValueUnderline); + return executeToggleStyleInList(frame, source, EditActionUnderline, CSSPropertyWebkitTextDecorationsInEffect, underline.get()); +} + +static bool executeUndo(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->undo(); + return true; +} + +static bool executeUnlink(Frame* frame, Event*, EditorCommandSource, const String&) +{ + applyCommand(UnlinkCommand::create(frame->document())); + return true; +} + +static bool executeUnscript(Frame* frame, Event*, EditorCommandSource source, const String&) +{ + return executeApplyStyle(frame, source, EditActionUnscript, CSSPropertyVerticalAlign, "baseline"); +} + +static bool executeUnselect(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->selection()->clear(); + return true; +} + +static bool executeYank(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->insertTextWithoutSendingTextEvent(frame->editor()->killRing()->yank(), false, 0); + frame->editor()->killRing()->setToYankedState(); + return true; +} + +static bool executeYankAndSelect(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->insertTextWithoutSendingTextEvent(frame->editor()->killRing()->yank(), true, 0); + frame->editor()->killRing()->setToYankedState(); + return true; +} + +#if SUPPORT_AUTOCORRECTION_PANEL +static bool executeCancelOperation(Frame* frame, Event*, EditorCommandSource, const String&) +{ + frame->editor()->handleCancelOperation(); + return true; +} +#endif + +// Supported functions + +static bool supported(Frame*) +{ + return true; +} + +static bool supportedFromMenuOrKeyBinding(Frame*) +{ + return false; +} + +static bool supportedCopyCut(Frame* frame) +{ + Settings* settings = frame ? frame->settings() : 0; + return settings && settings->javaScriptCanAccessClipboard(); +} + +static bool supportedPaste(Frame* frame) +{ + Settings* settings = frame ? frame->settings() : 0; + return settings && (settings->javaScriptCanAccessClipboard() ? settings->isDOMPasteAllowed() : 0); +} + +// Enabled functions + +static bool enabled(Frame*, Event*, EditorCommandSource) +{ + return true; +} + +static bool enabledVisibleSelection(Frame* frame, Event* event, EditorCommandSource) +{ + // The term "visible" here includes a caret in editable text or a range in any text. + const VisibleSelection& selection = frame->editor()->selectionForCommand(event); + return (selection.isCaret() && selection.isContentEditable()) || selection.isRange(); +} + +static bool caretBrowsingEnabled(Frame* frame) +{ + return frame->settings() && frame->settings()->caretBrowsingEnabled(); +} + +static EditorCommandSource dummyEditorCommandSource = static_cast<EditorCommandSource>(0); + +static bool enabledVisibleSelectionOrCaretBrowsing(Frame* frame, Event* event, EditorCommandSource) +{ + // The EditorCommandSource parameter is unused in enabledVisibleSelection, so just pass a dummy variable + return caretBrowsingEnabled(frame) || enabledVisibleSelection(frame, event, dummyEditorCommandSource); +} + +static bool enabledVisibleSelectionAndMark(Frame* frame, Event* event, EditorCommandSource) +{ + const VisibleSelection& selection = frame->editor()->selectionForCommand(event); + return ((selection.isCaret() && selection.isContentEditable()) || selection.isRange()) + && frame->editor()->mark().isCaretOrRange(); +} + +static bool enableCaretInEditableText(Frame* frame, Event* event, EditorCommandSource) +{ + const VisibleSelection& selection = frame->editor()->selectionForCommand(event); + return selection.isCaret() && selection.isContentEditable(); +} + +static bool enabledCopy(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canDHTMLCopy() || frame->editor()->canCopy(); +} + +static bool enabledCut(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canDHTMLCut() || frame->editor()->canCut(); +} + +static bool enabledDelete(Frame* frame, Event* event, EditorCommandSource source) +{ + switch (source) { + case CommandFromMenuOrKeyBinding: + // "Delete" from menu only affects selected range, just like Cut but without affecting pasteboard + return frame->editor()->canDHTMLCut() || frame->editor()->canCut(); + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + // "Delete" from DOM is like delete/backspace keypress, affects selected range if non-empty, + // otherwise removes a character + return frame->editor()->selectionForCommand(event).isContentEditable(); + } + ASSERT_NOT_REACHED(); + return false; +} + +static bool enabledInEditableText(Frame* frame, Event* event, EditorCommandSource) +{ + return frame->editor()->selectionForCommand(event).isContentEditable(); +} + +static bool enabledInEditableTextOrCaretBrowsing(Frame* frame, Event* event, EditorCommandSource) +{ + // The EditorCommandSource parameter is unused in enabledInEditableText, so just pass a dummy variable + return caretBrowsingEnabled(frame) || enabledInEditableText(frame, event, dummyEditorCommandSource); +} + +static bool enabledInRichlyEditableText(Frame* frame, Event*, EditorCommandSource) +{ + return frame->selection()->isCaretOrRange() && frame->selection()->isContentRichlyEditable(); +} + +static bool enabledPaste(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canPaste(); +} + +static bool enabledRangeInEditableText(Frame* frame, Event*, EditorCommandSource) +{ + return frame->selection()->isRange() && frame->selection()->isContentEditable(); +} + +static bool enabledRangeInRichlyEditableText(Frame* frame, Event*, EditorCommandSource) +{ + return frame->selection()->isRange() && frame->selection()->isContentRichlyEditable(); +} + +static bool enabledRedo(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canRedo(); +} + +#if PLATFORM(MAC) +static bool enabledTakeFindStringFromSelection(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canCopyExcludingStandaloneImages(); +} +#endif + +static bool enabledUndo(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->canUndo(); +} + +#if SUPPORT_AUTOCORRECTION_PANEL +static bool enabledDismissCorrectionPanel(Frame* frame, Event*, EditorCommandSource) +{ + return frame->editor()->isShowingCorrectionPanel(); +} +#endif + +// State functions + +static TriState stateNone(Frame*, Event*) +{ + return FalseTriState; +} + +static TriState stateBold(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyFontWeight, "bold"); +} + +static TriState stateItalic(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyFontStyle, "italic"); +} + +static TriState stateOrderedList(Frame* frame, Event*) +{ + return frame->editor()->selectionOrderedListState(); +} + +static TriState stateStrikethrough(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "line-through"); +} + +static TriState stateStyleWithCSS(Frame* frame, Event*) +{ + return frame->editor()->shouldStyleWithCSS() ? TrueTriState : FalseTriState; +} + +static TriState stateSubscript(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyVerticalAlign, "sub"); +} + +static TriState stateSuperscript(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyVerticalAlign, "super"); +} + +static TriState stateTextWritingDirectionLeftToRight(Frame* frame, Event*) +{ + return stateTextWritingDirection(frame, LeftToRightWritingDirection); +} + +static TriState stateTextWritingDirectionNatural(Frame* frame, Event*) +{ + return stateTextWritingDirection(frame, NaturalWritingDirection); +} + +static TriState stateTextWritingDirectionRightToLeft(Frame* frame, Event*) +{ + return stateTextWritingDirection(frame, RightToLeftWritingDirection); +} + +static TriState stateUnderline(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyWebkitTextDecorationsInEffect, "underline"); +} + +static TriState stateUnorderedList(Frame* frame, Event*) +{ + return frame->editor()->selectionUnorderedListState(); +} + +static TriState stateJustifyCenter(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyTextAlign, "center"); +} + +static TriState stateJustifyFull(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyTextAlign, "justify"); +} + +static TriState stateJustifyLeft(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyTextAlign, "left"); +} + +static TriState stateJustifyRight(Frame* frame, Event*) +{ + return stateStyle(frame, CSSPropertyTextAlign, "right"); +} + +// Value functions + +static String valueNull(Frame*, Event*) +{ + return String(); +} + +static String valueBackColor(Frame* frame, Event*) +{ + return valueStyle(frame, CSSPropertyBackgroundColor); +} + +static String valueFontName(Frame* frame, Event*) +{ + return valueStyle(frame, CSSPropertyFontFamily); +} + +static String valueFontSize(Frame* frame, Event*) +{ + return valueStyle(frame, CSSPropertyFontSize); +} + +static String valueFontSizeDelta(Frame* frame, Event*) +{ + return valueStyle(frame, CSSPropertyWebkitFontSizeDelta); +} + +static String valueForeColor(Frame* frame, Event*) +{ + return valueStyle(frame, CSSPropertyColor); +} + +static String valueFormatBlock(Frame* frame, Event*) +{ + const VisibleSelection& selection = frame->selection()->selection(); + if (!selection.isNonOrphanedCaretOrRange() || !selection.isContentEditable()) + return ""; + Element* formatBlockElement = FormatBlockCommand::elementForFormatBlockCommand(selection.firstRange().get()); + if (!formatBlockElement) + return ""; + return formatBlockElement->localName(); +} + +// Map of functions + +struct CommandEntry { + const char* name; + EditorInternalCommand command; +}; + +static const CommandMap& createCommandMap() +{ + static const CommandEntry commands[] = { + { "AlignCenter", { executeJustifyCenter, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "AlignJustified", { executeJustifyFull, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "AlignLeft", { executeJustifyLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "AlignRight", { executeJustifyRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "BackColor", { executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueBackColor, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "BackwardDelete", { executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, // FIXME: remove BackwardDelete when Safari for Windows stops using it. + { "Bold", { executeToggleBold, supported, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Copy", { executeCopy, supportedCopyCut, enabledCopy, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, + { "CreateLink", { executeCreateLink, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Cut", { executeCut, supportedCopyCut, enabledCut, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, + { "Delete", { executeDelete, supported, enabledDelete, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteBackward", { executeDeleteBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteBackwardByDecomposingPreviousCharacter", { executeDeleteBackwardByDecomposingPreviousCharacter, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteForward", { executeDeleteForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteToBeginningOfLine", { executeDeleteToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteToBeginningOfParagraph", { executeDeleteToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteToEndOfLine", { executeDeleteToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteToEndOfParagraph", { executeDeleteToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteToMark", { executeDeleteToMark, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteWordBackward", { executeDeleteWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "DeleteWordForward", { executeDeleteWordForward, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "FindString", { executeFindString, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "FontName", { executeFontName, supported, enabledInEditableText, stateNone, valueFontName, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "FontSize", { executeFontSize, supported, enabledInEditableText, stateNone, valueFontSize, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "FontSizeDelta", { executeFontSizeDelta, supported, enabledInEditableText, stateNone, valueFontSizeDelta, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "ForeColor", { executeForeColor, supported, enabledInRichlyEditableText, stateNone, valueForeColor, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "FormatBlock", { executeFormatBlock, supported, enabledInRichlyEditableText, stateNone, valueFormatBlock, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "ForwardDelete", { executeForwardDelete, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "HiliteColor", { executeBackColor, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "IgnoreSpelling", { executeIgnoreSpelling, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Indent", { executeIndent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertBacktab", { executeInsertBacktab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertHTML", { executeInsertHTML, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertHorizontalRule", { executeInsertHorizontalRule, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertImage", { executeInsertImage, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertLineBreak", { executeInsertLineBreak, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertNewline", { executeInsertNewline, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertNewlineInQuotedContent", { executeInsertNewlineInQuotedContent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertOrderedList", { executeInsertOrderedList, supported, enabledInRichlyEditableText, stateOrderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertParagraph", { executeInsertParagraph, supported, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertTab", { executeInsertTab, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertText", { executeInsertText, supported, enabledInEditableText, stateNone, valueNull, isTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "InsertUnorderedList", { executeInsertUnorderedList, supported, enabledInRichlyEditableText, stateUnorderedList, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Italic", { executeToggleItalic, supported, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "JustifyCenter", { executeJustifyCenter, supported, enabledInRichlyEditableText, stateJustifyCenter, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "JustifyFull", { executeJustifyFull, supported, enabledInRichlyEditableText, stateJustifyFull, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "JustifyLeft", { executeJustifyLeft, supported, enabledInRichlyEditableText, stateJustifyLeft, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "JustifyNone", { executeJustifyLeft, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "JustifyRight", { executeJustifyRight, supported, enabledInRichlyEditableText, stateJustifyRight, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MakeTextWritingDirectionLeftToRight", { executeMakeTextWritingDirectionLeftToRight, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionLeftToRight, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MakeTextWritingDirectionNatural", { executeMakeTextWritingDirectionNatural, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionNatural, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MakeTextWritingDirectionRightToLeft", { executeMakeTextWritingDirectionRightToLeft, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateTextWritingDirectionRightToLeft, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveBackward", { executeMoveBackward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveBackwardAndModifySelection", { executeMoveBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveDown", { executeMoveDown, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveDownAndModifySelection", { executeMoveDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveForward", { executeMoveForward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveForwardAndModifySelection", { executeMoveForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveLeft", { executeMoveLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveLeftAndModifySelection", { executeMoveLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MovePageDown", { executeMovePageDown, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MovePageDownAndModifySelection", { executeMovePageDownAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MovePageUp", { executeMovePageUp, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MovePageUpAndModifySelection", { executeMovePageUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveParagraphBackwardAndModifySelection", { executeMoveParagraphBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveParagraphForwardAndModifySelection", { executeMoveParagraphForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveRight", { executeMoveRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveRightAndModifySelection", { executeMoveRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfDocument", { executeMoveToBeginningOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfDocumentAndModifySelection", { executeMoveToBeginningOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfLine", { executeMoveToBeginningOfLine, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfLineAndModifySelection", { executeMoveToBeginningOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfParagraph", { executeMoveToBeginningOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfParagraphAndModifySelection", { executeMoveToBeginningOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfSentence", { executeMoveToBeginningOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToBeginningOfSentenceAndModifySelection", { executeMoveToBeginningOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfDocument", { executeMoveToEndOfDocument, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfDocumentAndModifySelection", { executeMoveToEndOfDocumentAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfLine", { executeMoveToEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfLineAndModifySelection", { executeMoveToEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfParagraph", { executeMoveToEndOfParagraph, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfParagraphAndModifySelection", { executeMoveToEndOfParagraphAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfSentence", { executeMoveToEndOfSentence, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToEndOfSentenceAndModifySelection", { executeMoveToEndOfSentenceAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToLeftEndOfLine", { executeMoveToLeftEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToLeftEndOfLineAndModifySelection", { executeMoveToLeftEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToRightEndOfLine", { executeMoveToRightEndOfLine, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveToRightEndOfLineAndModifySelection", { executeMoveToRightEndOfLineAndModifySelection, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveUp", { executeMoveUp, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveUpAndModifySelection", { executeMoveUpAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordBackward", { executeMoveWordBackward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordBackwardAndModifySelection", { executeMoveWordBackwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordForward", { executeMoveWordForward, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordForwardAndModifySelection", { executeMoveWordForwardAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordLeft", { executeMoveWordLeft, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordLeftAndModifySelection", { executeMoveWordLeftAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordRight", { executeMoveWordRight, supportedFromMenuOrKeyBinding, enabledInEditableTextOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "MoveWordRightAndModifySelection", { executeMoveWordRightAndModifySelection, supportedFromMenuOrKeyBinding, enabledVisibleSelectionOrCaretBrowsing, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Outdent", { executeOutdent, supported, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Paste", { executePaste, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, + { "PasteAndMatchStyle", { executePasteAndMatchStyle, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, + { "PasteAsPlainText", { executePasteAsPlainText, supportedPaste, enabledPaste, stateNone, valueNull, notTextInsertion, allowExecutionWhenDisabled } }, + { "Print", { executePrint, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Redo", { executeRedo, supported, enabledRedo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "RemoveFormat", { executeRemoveFormat, supported, enabledRangeInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectAll", { executeSelectAll, supported, enabled, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectLine", { executeSelectLine, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectParagraph", { executeSelectParagraph, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectSentence", { executeSelectSentence, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectToMark", { executeSelectToMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SelectWord", { executeSelectWord, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SetMark", { executeSetMark, supportedFromMenuOrKeyBinding, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Strikethrough", { executeStrikethrough, supported, enabledInRichlyEditableText, stateStrikethrough, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "StyleWithCSS", { executeStyleWithCSS, supported, enabled, stateStyleWithCSS, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Subscript", { executeSubscript, supported, enabledInRichlyEditableText, stateSubscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Superscript", { executeSuperscript, supported, enabledInRichlyEditableText, stateSuperscript, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "SwapWithMark", { executeSwapWithMark, supportedFromMenuOrKeyBinding, enabledVisibleSelectionAndMark, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "ToggleBold", { executeToggleBold, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateBold, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "ToggleItalic", { executeToggleItalic, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateItalic, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "ToggleUnderline", { executeUnderline, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Transpose", { executeTranspose, supported, enableCaretInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Underline", { executeUnderline, supported, enabledInRichlyEditableText, stateUnderline, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Undo", { executeUndo, supported, enabledUndo, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Unlink", { executeUnlink, supported, enabledRangeInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Unscript", { executeUnscript, supportedFromMenuOrKeyBinding, enabledInRichlyEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Unselect", { executeUnselect, supported, enabledVisibleSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "Yank", { executeYank, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + { "YankAndSelect", { executeYankAndSelect, supportedFromMenuOrKeyBinding, enabledInEditableText, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, + +#if PLATFORM(MAC) + { "TakeFindStringFromSelection", { executeTakeFindStringFromSelection, supportedFromMenuOrKeyBinding, enabledTakeFindStringFromSelection, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, +#endif + +#if SUPPORT_AUTOCORRECTION_PANEL + { "CancelOperation", { executeCancelOperation, supportedFromMenuOrKeyBinding, enabledDismissCorrectionPanel, stateNone, valueNull, notTextInsertion, doNotAllowExecutionWhenDisabled } }, +#endif + }; + + // These unsupported commands are listed here since they appear in the Microsoft + // documentation used as the starting point for our DOM executeCommand support. + // + // 2D-Position (not supported) + // AbsolutePosition (not supported) + // BlockDirLTR (not supported) + // BlockDirRTL (not supported) + // BrowseMode (not supported) + // ClearAuthenticationCache (not supported) + // CreateBookmark (not supported) + // DirLTR (not supported) + // DirRTL (not supported) + // EditMode (not supported) + // InlineDirLTR (not supported) + // InlineDirRTL (not supported) + // InsertButton (not supported) + // InsertFieldSet (not supported) + // InsertIFrame (not supported) + // InsertInputButton (not supported) + // InsertInputCheckbox (not supported) + // InsertInputFileUpload (not supported) + // InsertInputHidden (not supported) + // InsertInputImage (not supported) + // InsertInputPassword (not supported) + // InsertInputRadio (not supported) + // InsertInputReset (not supported) + // InsertInputSubmit (not supported) + // InsertInputText (not supported) + // InsertMarquee (not supported) + // InsertSelectDropDown (not supported) + // InsertSelectListBox (not supported) + // InsertTextArea (not supported) + // LiveResize (not supported) + // MultipleSelection (not supported) + // Open (not supported) + // Overwrite (not supported) + // PlayImage (not supported) + // Refresh (not supported) + // RemoveParaFormat (not supported) + // SaveAs (not supported) + // SizeToControl (not supported) + // SizeToControlHeight (not supported) + // SizeToControlWidth (not supported) + // Stop (not supported) + // StopImage (not supported) + // Unbookmark (not supported) + + CommandMap& commandMap = *new CommandMap; + + for (size_t i = 0; i < WTF_ARRAY_LENGTH(commands); ++i) { + ASSERT(!commandMap.get(commands[i].name)); + commandMap.set(commands[i].name, &commands[i].command); + } + + return commandMap; +} + +static const EditorInternalCommand* internalCommand(const String& commandName) +{ + static const CommandMap& commandMap = createCommandMap(); + return commandName.isEmpty() ? 0 : commandMap.get(commandName); +} + +Editor::Command Editor::command(const String& commandName) +{ + return Command(internalCommand(commandName), CommandFromMenuOrKeyBinding, m_frame); +} + +Editor::Command Editor::command(const String& commandName, EditorCommandSource source) +{ + return Command(internalCommand(commandName), source, m_frame); +} + +bool Editor::commandIsSupportedFromMenuOrKeyBinding(const String& commandName) +{ + return internalCommand(commandName); +} + +Editor::Command::Command() + : m_command(0) +{ +} + +Editor::Command::Command(const EditorInternalCommand* command, EditorCommandSource source, PassRefPtr<Frame> frame) + : m_command(command) + , m_source(source) + , m_frame(command ? frame : 0) +{ + // Use separate assertions so we can tell which bad thing happened. + if (!command) + ASSERT(!m_frame); + else + ASSERT(m_frame); +} + +bool Editor::Command::execute(const String& parameter, Event* triggeringEvent) const +{ + if (!isEnabled(triggeringEvent)) { + // Let certain commands be executed when performed explicitly even if they are disabled. + if (!isSupported() || !m_frame || !m_command->allowExecutionWhenDisabled) + return false; + } + m_frame->document()->updateLayoutIgnorePendingStylesheets(); + return m_command->execute(m_frame.get(), triggeringEvent, m_source, parameter); +} + +bool Editor::Command::execute(Event* triggeringEvent) const +{ + return execute(String(), triggeringEvent); +} + +bool Editor::Command::isSupported() const +{ + if (!m_command) + return false; + switch (m_source) { + case CommandFromMenuOrKeyBinding: + return true; + case CommandFromDOM: + case CommandFromDOMWithUserInterface: + return m_command->isSupportedFromDOM(m_frame.get()); + } + ASSERT_NOT_REACHED(); + return false; +} + +bool Editor::Command::isEnabled(Event* triggeringEvent) const +{ + if (!isSupported() || !m_frame) + return false; + return m_command->isEnabled(m_frame.get(), triggeringEvent, m_source); +} + +TriState Editor::Command::state(Event* triggeringEvent) const +{ + if (!isSupported() || !m_frame) + return FalseTriState; + return m_command->state(m_frame.get(), triggeringEvent); +} + +String Editor::Command::value(Event* triggeringEvent) const +{ + if (!isSupported() || !m_frame) + return String(); + if (m_command->value == valueNull && m_command->state != stateNone) + return m_command->state(m_frame.get(), triggeringEvent) == TrueTriState ? "true" : "false"; + return m_command->value(m_frame.get(), triggeringEvent); +} + +bool Editor::Command::isTextInsertion() const +{ + return m_command && m_command->isTextInsertion; +} + +} // namespace WebCore |