--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/editing/ApplyStyleCommand.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,1892 @@
+/*
+ * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
+ *
+ * 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 "ApplyStyleCommand.h"
+
+#include "CSSComputedStyleDeclaration.h"
+#include "CSSMutableStyleDeclaration.h"
+#include "CSSParser.h"
+#include "CSSProperty.h"
+#include "CSSPropertyNames.h"
+#include "CSSValueKeywords.h"
+#include "Document.h"
+#include "Editor.h"
+#include "Frame.h"
+#include "HTMLElement.h"
+#include "HTMLInterchange.h"
+#include "HTMLNames.h"
+#include "NodeList.h"
+#include "Range.h"
+#include "RenderObject.h"
+#include "Text.h"
+#include "TextIterator.h"
+#include "htmlediting.h"
+#include "visible_units.h"
+#include <wtf/StdLibExtras.h>
+
+namespace WebCore {
+
+using namespace HTMLNames;
+
+class StyleChange {
+public:
+ explicit StyleChange(CSSStyleDeclaration*, const Position&);
+
+ String cssStyle() const { return m_cssStyle; }
+ bool applyBold() const { return m_applyBold; }
+ bool applyItalic() const { return m_applyItalic; }
+ bool applyUnderline() const { return m_applyUnderline; }
+ bool applyLineThrough() const { return m_applyLineThrough; }
+ bool applySubscript() const { return m_applySubscript; }
+ bool applySuperscript() const { return m_applySuperscript; }
+ bool applyFontColor() const { return m_applyFontColor.length() > 0; }
+ bool applyFontFace() const { return m_applyFontFace.length() > 0; }
+ bool applyFontSize() const { return m_applyFontSize.length() > 0; }
+
+ String fontColor() { return m_applyFontColor; }
+ String fontFace() { return m_applyFontFace; }
+ String fontSize() { return m_applyFontSize; }
+
+private:
+ void init(PassRefPtr<CSSStyleDeclaration>, const Position&);
+ void reconcileTextDecorationProperties(CSSMutableStyleDeclaration*);
+ void extractTextStyles(CSSMutableStyleDeclaration*);
+
+ String m_cssStyle;
+ bool m_applyBold;
+ bool m_applyItalic;
+ bool m_applyUnderline;
+ bool m_applyLineThrough;
+ bool m_applySubscript;
+ bool m_applySuperscript;
+ String m_applyFontColor;
+ String m_applyFontFace;
+ String m_applyFontSize;
+};
+
+
+StyleChange::StyleChange(CSSStyleDeclaration* style, const Position& position)
+ : m_applyBold(false)
+ , m_applyItalic(false)
+ , m_applyUnderline(false)
+ , m_applyLineThrough(false)
+ , m_applySubscript(false)
+ , m_applySuperscript(false)
+{
+ init(style, position);
+}
+
+void StyleChange::init(PassRefPtr<CSSStyleDeclaration> style, const Position& position)
+{
+ Document* document = position.node() ? position.node()->document() : 0;
+ if (!document || !document->frame())
+ return;
+
+ RefPtr<CSSComputedStyleDeclaration> computedStyle = position.computedStyle();
+ RefPtr<CSSMutableStyleDeclaration> mutableStyle = getPropertiesNotInComputedStyle(style.get(), computedStyle.get());
+
+ reconcileTextDecorationProperties(mutableStyle.get());
+ if (!document->frame()->editor()->shouldStyleWithCSS())
+ extractTextStyles(mutableStyle.get());
+
+ // Changing the whitespace style in a tab span would collapse the tab into a space.
+ if (isTabSpanTextNode(position.node()) || isTabSpanNode((position.node())))
+ mutableStyle->removeProperty(CSSPropertyWhiteSpace);
+
+ // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.
+ // FIXME: Shouldn't this be done in getPropertiesNotInComputedStyle?
+ if (mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi) && !style->getPropertyCSSValue(CSSPropertyDirection))
+ mutableStyle->setProperty(CSSPropertyDirection, style->getPropertyValue(CSSPropertyDirection));
+
+ // Save the result for later
+ m_cssStyle = mutableStyle->cssText().stripWhiteSpace();
+}
+
+void StyleChange::reconcileTextDecorationProperties(CSSMutableStyleDeclaration* style)
+{
+ RefPtr<CSSValue> textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+ RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration);
+ // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.
+ ASSERT(!textDecorationsInEffect || !textDecoration);
+ if (textDecorationsInEffect) {
+ style->setProperty(CSSPropertyTextDecoration, textDecorationsInEffect->cssText());
+ style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
+ textDecoration = textDecorationsInEffect;
+ }
+
+ // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".
+ if (textDecoration && !textDecoration->isValueList())
+ style->removeProperty(CSSPropertyTextDecoration);
+}
+
+static int getIdentifierValue(CSSMutableStyleDeclaration* style, int propertyID)
+{
+ if (!style)
+ return 0;
+
+ RefPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);
+ if (!value || !value->isPrimitiveValue())
+ return 0;
+
+ return static_cast<CSSPrimitiveValue*>(value.get())->getIdent();
+}
+
+static void setTextDecorationProperty(CSSMutableStyleDeclaration* style, const CSSValueList* newTextDecoration, int propertyID)
+{
+ if (newTextDecoration->length())
+ style->setProperty(propertyID, newTextDecoration->cssText(), style->getPropertyPriority(propertyID));
+ else {
+ // text-decoration: none is redundant since it does not remove any text decorations.
+ ASSERT(!style->getPropertyPriority(propertyID));
+ style->removeProperty(propertyID);
+ }
+}
+
+void StyleChange::extractTextStyles(CSSMutableStyleDeclaration* style)
+{
+ ASSERT(style);
+
+ if (getIdentifierValue(style, CSSPropertyFontWeight) == CSSValueBold) {
+ style->removeProperty(CSSPropertyFontWeight);
+ m_applyBold = true;
+ }
+
+ int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);
+ if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {
+ style->removeProperty(CSSPropertyFontStyle);
+ m_applyItalic = true;
+ }
+
+ // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect
+ // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.
+ if (RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration)) {
+ ASSERT(textDecoration->isValueList());
+ DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
+ DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+
+ RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();
+ if (newTextDecoration->removeAll(underline.get()))
+ m_applyUnderline = true;
+ if (newTextDecoration->removeAll(lineThrough.get()))
+ m_applyLineThrough = true;
+
+ // If trimTextDecorations, delete underline and line-through
+ setTextDecorationProperty(style, newTextDecoration.get(), CSSPropertyTextDecoration);
+ }
+
+ int verticalAlign = getIdentifierValue(style, CSSPropertyVerticalAlign);
+ switch (verticalAlign) {
+ case CSSValueSub:
+ style->removeProperty(CSSPropertyVerticalAlign);
+ m_applySubscript = true;
+ break;
+ case CSSValueSuper:
+ style->removeProperty(CSSPropertyVerticalAlign);
+ m_applySuperscript = true;
+ break;
+ }
+
+ if (RefPtr<CSSValue> colorValue = style->getPropertyCSSValue(CSSPropertyColor)) {
+ ASSERT(colorValue->isPrimitiveValue());
+ CSSPrimitiveValue* primitiveColor = static_cast<CSSPrimitiveValue*>(colorValue.get());
+ RGBA32 rgba = 0;
+ if (primitiveColor->primitiveType() != CSSPrimitiveValue::CSS_RGBCOLOR) {
+ CSSParser::parseColor(rgba, colorValue->cssText());
+ // Need to take care of named color such as green and black
+ // This code should be removed after https://bugs.webkit.org/show_bug.cgi?id=28282 is fixed.
+ } else
+ rgba = primitiveColor->getRGBA32Value();
+ m_applyFontColor = Color(rgba).name();
+ style->removeProperty(CSSPropertyColor);
+ }
+
+ m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);
+ style->removeProperty(CSSPropertyFontFamily);
+
+ if (RefPtr<CSSValue> fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {
+ if (!fontSize->isPrimitiveValue())
+ style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.
+ else {
+ CSSPrimitiveValue* value = static_cast<CSSPrimitiveValue*>(fontSize.get());
+
+ // Only accept absolute scale
+ if (value->primitiveType() >= CSSPrimitiveValue::CSS_PX && value->primitiveType() <= CSSPrimitiveValue::CSS_PC) {
+ float number = value->getFloatValue(CSSPrimitiveValue::CSS_PX);
+ if (number <= 9)
+ m_applyFontSize = "1";
+ else if (number <= 10)
+ m_applyFontSize = "2";
+ else if (number <= 13)
+ m_applyFontSize = "3";
+ else if (number <= 16)
+ m_applyFontSize = "4";
+ else if (number <= 18)
+ m_applyFontSize = "5";
+ else if (number <= 24)
+ m_applyFontSize = "6";
+ else
+ m_applyFontSize = "7";
+ }
+ // Huge quirk in Microsoft Entourage is that they understand CSS font-size, but also write
+ // out legacy 1-7 values in font tags (I guess for mailers that are not CSS-savvy at all,
+ // like Eudora). Yes, they write out *both*. We need to write out both as well.
+ }
+ }
+}
+
+static String& styleSpanClassString()
+{
+ DEFINE_STATIC_LOCAL(String, styleSpanClassString, ((AppleStyleSpanClass)));
+ return styleSpanClassString;
+}
+
+bool isStyleSpan(const Node *node)
+{
+ if (!node || !node->isHTMLElement())
+ return false;
+
+ const HTMLElement* elem = static_cast<const HTMLElement*>(node);
+ return elem->hasLocalName(spanAttr) && elem->getAttribute(classAttr) == styleSpanClassString();
+}
+
+static bool isUnstyledStyleSpan(const Node* node)
+{
+ if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))
+ return false;
+
+ const HTMLElement* elem = static_cast<const HTMLElement*>(node);
+ CSSMutableStyleDeclaration* inlineStyleDecl = elem->inlineStyleDecl();
+ return (!inlineStyleDecl || inlineStyleDecl->isEmpty()) && elem->getAttribute(classAttr) == styleSpanClassString();
+}
+
+static bool isSpanWithoutAttributesOrUnstyleStyleSpan(const Node* node)
+{
+ if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))
+ return false;
+
+ const HTMLElement* elem = static_cast<const HTMLElement*>(node);
+ NamedNodeMap* attributes = elem->attributes(true); // readonly
+ if (attributes->isEmpty())
+ return true;
+
+ return isUnstyledStyleSpan(node);
+}
+
+static bool isEmptyFontTag(const Node *node)
+{
+ if (!node || !node->hasTagName(fontTag))
+ return false;
+
+ const Element *elem = static_cast<const Element *>(node);
+ NamedNodeMap *map = elem->attributes(true); // true for read-only
+ if (!map)
+ return true;
+ return map->isEmpty() || (map->length() == 1 && elem->getAttribute(classAttr) == styleSpanClassString());
+}
+
+static PassRefPtr<Element> createFontElement(Document* document)
+{
+ RefPtr<Element> fontNode = createHTMLElement(document, fontTag);
+ fontNode->setAttribute(classAttr, styleSpanClassString());
+ return fontNode.release();
+}
+
+PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)
+{
+ RefPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);
+ styleElement->setAttribute(classAttr, styleSpanClassString());
+ return styleElement.release();
+}
+
+static void diffTextDecorations(CSSMutableStyleDeclaration* style, int propertID, CSSValue* refTextDecoration)
+{
+ RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(propertID);
+ if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())
+ return;
+
+ RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();
+ CSSValueList* valuesInRefTextDecoration = static_cast<CSSValueList*>(refTextDecoration);
+
+ for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
+ newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));
+
+ setTextDecorationProperty(style, newTextDecoration.get(), propertID);
+}
+
+static bool fontWeightIsBold(CSSStyleDeclaration* style)
+{
+ ASSERT(style);
+ RefPtr<CSSValue> fontWeight = style->getPropertyCSSValue(CSSPropertyFontWeight);
+
+ if (!fontWeight)
+ return false;
+ if (!fontWeight->isPrimitiveValue())
+ return false;
+
+ // Because b tag can only bold text, there are only two states in plain html: bold and not bold.
+ // Collapse all other values to either one of these two states for editing purposes.
+ switch (static_cast<CSSPrimitiveValue*>(fontWeight.get())->getIdent()) {
+ case CSSValue100:
+ case CSSValue200:
+ case CSSValue300:
+ case CSSValue400:
+ case CSSValue500:
+ case CSSValueNormal:
+ return false;
+ case CSSValueBold:
+ case CSSValue600:
+ case CSSValue700:
+ case CSSValue800:
+ case CSSValue900:
+ return true;
+ }
+
+ ASSERT_NOT_REACHED(); // For CSSValueBolder and CSSValueLighter
+ return false; // Make compiler happy
+}
+
+RefPtr<CSSMutableStyleDeclaration> getPropertiesNotInComputedStyle(CSSStyleDeclaration* style, CSSComputedStyleDeclaration* computedStyle)
+{
+ ASSERT(style);
+ ASSERT(computedStyle);
+ RefPtr<CSSMutableStyleDeclaration> result = style->copy();
+ computedStyle->diff(result.get());
+
+ RefPtr<CSSValue> computedTextDecorationsInEffect = computedStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+ diffTextDecorations(result.get(), CSSPropertyTextDecoration, computedTextDecorationsInEffect.get());
+ diffTextDecorations(result.get(), CSSPropertyWebkitTextDecorationsInEffect, computedTextDecorationsInEffect.get());
+
+ if (fontWeightIsBold(result.get()) == fontWeightIsBold(computedStyle))
+ result->removeProperty(CSSPropertyFontWeight);
+
+ return result;
+}
+
+// Editing style properties must be preserved during editing operation.
+// e.g. when a user inserts a new paragraph, all properties listed here must be copied to the new paragraph.
+// FIXME: The current editingStyleProperties contains all inheritableProperties but we may not need to preserve all inheritable properties
+static const int editingStyleProperties[] = {
+ // CSS inheritable properties
+ CSSPropertyBorderCollapse,
+ CSSPropertyColor,
+ CSSPropertyFontFamily,
+ CSSPropertyFontSize,
+ CSSPropertyFontStyle,
+ CSSPropertyFontVariant,
+ CSSPropertyFontWeight,
+ CSSPropertyLetterSpacing,
+ CSSPropertyLineHeight,
+ CSSPropertyOrphans,
+ CSSPropertyTextAlign,
+ CSSPropertyTextIndent,
+ CSSPropertyTextTransform,
+ CSSPropertyWhiteSpace,
+ CSSPropertyWidows,
+ CSSPropertyWordSpacing,
+ CSSPropertyWebkitBorderHorizontalSpacing,
+ CSSPropertyWebkitBorderVerticalSpacing,
+ CSSPropertyWebkitTextDecorationsInEffect,
+ CSSPropertyWebkitTextFillColor,
+ CSSPropertyWebkitTextSizeAdjust,
+ CSSPropertyWebkitTextStrokeColor,
+ CSSPropertyWebkitTextStrokeWidth,
+};
+size_t numEditingStyleProperties = sizeof(editingStyleProperties)/sizeof(editingStyleProperties[0]);
+
+PassRefPtr<CSSMutableStyleDeclaration> ApplyStyleCommand::editingStyleAtPosition(Position pos, ShouldIncludeTypingStyle shouldIncludeTypingStyle)
+{
+ RefPtr<CSSComputedStyleDeclaration> computedStyleAtPosition = pos.computedStyle();
+ RefPtr<CSSMutableStyleDeclaration> style;
+ if (!computedStyleAtPosition)
+ style = CSSMutableStyleDeclaration::create();
+ else
+ style = computedStyleAtPosition->copyPropertiesInSet(editingStyleProperties, numEditingStyleProperties);
+
+ if (style && pos.node() && pos.node()->computedStyle()) {
+ RenderStyle* renderStyle = pos.node()->computedStyle();
+ // If a node's text fill color is invalid, then its children use
+ // their font-color as their text fill color (they don't
+ // inherit it). Likewise for stroke color.
+ ExceptionCode ec = 0;
+ if (!renderStyle->textFillColor().isValid())
+ style->removeProperty(CSSPropertyWebkitTextFillColor, ec);
+ if (!renderStyle->textStrokeColor().isValid())
+ style->removeProperty(CSSPropertyWebkitTextStrokeColor, ec);
+ ASSERT(ec == 0);
+ if (renderStyle->fontDescription().keywordSize())
+ style->setProperty(CSSPropertyFontSize, computedStyleAtPosition->getFontSizeCSSValuePreferringKeyword()->cssText());
+ }
+
+ if (shouldIncludeTypingStyle == IncludeTypingStyle) {
+ CSSMutableStyleDeclaration* typingStyle = pos.node()->document()->frame()->typingStyle();
+ if (typingStyle)
+ style->merge(typingStyle);
+ }
+
+ return style.release();
+}
+
+void prepareEditingStyleToApplyAt(CSSMutableStyleDeclaration* editingStyle, Position pos)
+{
+ // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.
+ // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate
+ // which one of editingStyleAtPosition or computedStyle is called.
+ RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(pos);
+ style->diff(editingStyle);
+
+ // if alpha value is zero, we don't add the background color.
+ RefPtr<CSSValue> backgroundColor = editingStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
+ if (backgroundColor && backgroundColor->isPrimitiveValue()) {
+ CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(backgroundColor.get());
+ Color color = Color(primitiveValue->getRGBA32Value());
+ ExceptionCode ec;
+ if (color.alpha() == 0)
+ editingStyle->removeProperty(CSSPropertyBackgroundColor, ec);
+ }
+}
+
+void removeStylesAddedByNode(CSSMutableStyleDeclaration* editingStyle, Node* node)
+{
+ ASSERT(node);
+ ASSERT(node->parentNode());
+ RefPtr<CSSMutableStyleDeclaration> parentStyle = ApplyStyleCommand::editingStyleAtPosition(Position(node->parentNode(), 0));
+ RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(Position(node, 0));
+ parentStyle->diff(style.get());
+ style->diff(editingStyle);
+}
+
+ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, EditAction editingAction, EPropertyLevel propertyLevel)
+ : CompositeEditCommand(document)
+ , m_style(style->makeMutable())
+ , m_editingAction(editingAction)
+ , m_propertyLevel(propertyLevel)
+ , m_start(endingSelection().start().downstream())
+ , m_end(endingSelection().end().upstream())
+ , m_useEndingSelection(true)
+ , m_styledInlineElement(0)
+ , m_removeOnly(false)
+{
+}
+
+ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)
+ : CompositeEditCommand(document)
+ , m_style(style->makeMutable())
+ , m_editingAction(editingAction)
+ , m_propertyLevel(propertyLevel)
+ , m_start(start)
+ , m_end(end)
+ , m_useEndingSelection(false)
+ , m_styledInlineElement(0)
+ , m_removeOnly(false)
+{
+}
+
+ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)
+ : CompositeEditCommand(element->document())
+ , m_style(CSSMutableStyleDeclaration::create())
+ , m_editingAction(editingAction)
+ , m_propertyLevel(PropertyDefault)
+ , m_start(endingSelection().start().downstream())
+ , m_end(endingSelection().end().upstream())
+ , m_useEndingSelection(true)
+ , m_styledInlineElement(element)
+ , m_removeOnly(removeOnly)
+{
+}
+
+void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)
+{
+ ASSERT(comparePositions(newEnd, newStart) >= 0);
+
+ if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))
+ m_useEndingSelection = true;
+
+ setEndingSelection(VisibleSelection(newStart, newEnd, VP_DEFAULT_AFFINITY));
+ m_start = newStart;
+ m_end = newEnd;
+}
+
+Position ApplyStyleCommand::startPosition()
+{
+ if (m_useEndingSelection)
+ return endingSelection().start();
+
+ return m_start;
+}
+
+Position ApplyStyleCommand::endPosition()
+{
+ if (m_useEndingSelection)
+ return endingSelection().end();
+
+ return m_end;
+}
+
+void ApplyStyleCommand::doApply()
+{
+ switch (m_propertyLevel) {
+ case PropertyDefault: {
+ // apply the block-centric properties of the style
+ RefPtr<CSSMutableStyleDeclaration> blockStyle = m_style->copyBlockProperties();
+ if (blockStyle->length())
+ applyBlockStyle(blockStyle.get());
+ // apply any remaining styles to the inline elements
+ // NOTE: hopefully, this string comparison is the same as checking for a non-null diff
+ if (blockStyle->length() < m_style->length() || m_styledInlineElement) {
+ RefPtr<CSSMutableStyleDeclaration> inlineStyle = m_style->copy();
+ applyRelativeFontStyleChange(inlineStyle.get());
+ blockStyle->diff(inlineStyle.get());
+ applyInlineStyle(inlineStyle.get());
+ }
+ break;
+ }
+ case ForceBlockProperties:
+ // Force all properties to be applied as block styles.
+ applyBlockStyle(m_style.get());
+ break;
+ }
+}
+
+EditAction ApplyStyleCommand::editingAction() const
+{
+ return m_editingAction;
+}
+
+void ApplyStyleCommand::applyBlockStyle(CSSMutableStyleDeclaration *style)
+{
+ // update document layout once before removing styles
+ // so that we avoid the expense of updating before each and every call
+ // to check a computed style
+ updateLayout();
+
+ // get positions we want to use for applying style
+ Position start = startPosition();
+ Position end = endPosition();
+ if (comparePositions(end, start) < 0) {
+ Position swap = start;
+ start = end;
+ end = swap;
+ }
+
+ VisiblePosition visibleStart(start);
+ VisiblePosition visibleEnd(end);
+ // Save and restore the selection endpoints using their indices in the document, since
+ // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
+ // Calculate start and end indices from the start of the tree that they're in.
+ Node* scope = highestAncestor(visibleStart.deepEquivalent().node());
+ Position rangeStart(scope, 0);
+ RefPtr<Range> startRange = Range::create(document(), rangeStart, rangeCompliantEquivalent(visibleStart.deepEquivalent()));
+ RefPtr<Range> endRange = Range::create(document(), rangeStart, rangeCompliantEquivalent(visibleEnd.deepEquivalent()));
+ int startIndex = TextIterator::rangeLength(startRange.get(), true);
+ int endIndex = TextIterator::rangeLength(endRange.get(), true);
+
+ VisiblePosition paragraphStart(startOfParagraph(visibleStart));
+ VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());
+ VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());
+ while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
+ StyleChange styleChange(style, paragraphStart.deepEquivalent());
+ if (styleChange.cssStyle().length() || m_removeOnly) {
+ RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().node());
+ RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
+ if (newBlock)
+ block = newBlock;
+ ASSERT(block->isHTMLElement());
+ if (block->isHTMLElement()) {
+ removeCSSStyle(style, static_cast<HTMLElement*>(block.get()));
+ if (!m_removeOnly)
+ addBlockStyle(styleChange, static_cast<HTMLElement*>(block.get()));
+ }
+
+ if (nextParagraphStart.isOrphan())
+ nextParagraphStart = endOfParagraph(paragraphStart).next();
+ }
+
+ paragraphStart = nextParagraphStart;
+ nextParagraphStart = endOfParagraph(paragraphStart).next();
+ }
+
+ startRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), startIndex, 0, true);
+ endRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), endIndex, 0, true);
+ if (startRange && endRange)
+ updateStartEnd(startRange->startPosition(), endRange->startPosition());
+}
+
+#define NoFontDelta (0.0f)
+#define MinimumFontSize (0.1f)
+
+void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclaration *style)
+{
+ RefPtr<CSSValue> value = style->getPropertyCSSValue(CSSPropertyFontSize);
+ if (value) {
+ // Explicit font size overrides any delta.
+ style->removeProperty(CSSPropertyWebkitFontSizeDelta);
+ return;
+ }
+
+ // Get the adjustment amount out of the style.
+ value = style->getPropertyCSSValue(CSSPropertyWebkitFontSizeDelta);
+ if (!value)
+ return;
+ float adjustment = NoFontDelta;
+ if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
+ CSSPrimitiveValue *primitiveValue = static_cast<CSSPrimitiveValue *>(value.get());
+ if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_PX) {
+ // Only PX handled now. If we handle more types in the future, perhaps
+ // a switch statement here would be more appropriate.
+ adjustment = primitiveValue->getFloatValue();
+ }
+ }
+ style->removeProperty(CSSPropertyWebkitFontSizeDelta);
+ if (adjustment == NoFontDelta)
+ return;
+
+ Position start = startPosition();
+ Position end = endPosition();
+ if (comparePositions(end, start) < 0) {
+ Position swap = start;
+ start = end;
+ end = swap;
+ }
+
+ // Join up any adjacent text nodes.
+ if (start.node()->isTextNode()) {
+ joinChildTextNodes(start.node()->parentNode(), start, end);
+ start = startPosition();
+ end = endPosition();
+ }
+ if (end.node()->isTextNode() && start.node()->parentNode() != end.node()->parentNode()) {
+ joinChildTextNodes(end.node()->parentNode(), start, end);
+ start = startPosition();
+ end = endPosition();
+ }
+
+ // Split the start text nodes if needed to apply style.
+ bool splitStart = splitTextAtStartIfNeeded(start, end);
+ if (splitStart) {
+ start = startPosition();
+ end = endPosition();
+ }
+ bool splitEnd = splitTextAtEndIfNeeded(start, end);
+ if (splitEnd) {
+ start = startPosition();
+ end = endPosition();
+ }
+
+ // Calculate loop end point.
+ // If the end node is before the start node (can only happen if the end node is
+ // an ancestor of the start node), we gather nodes up to the next sibling of the end node
+ Node *beyondEnd;
+ if (start.node()->isDescendantOf(end.node()))
+ beyondEnd = end.node()->traverseNextSibling();
+ else
+ beyondEnd = end.node()->traverseNextNode();
+
+ start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
+ Node *startNode = start.node();
+ if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
+ startNode = startNode->traverseNextNode();
+
+ // Store away font size before making any changes to the document.
+ // This ensures that changes to one node won't effect another.
+ HashMap<Node*, float> startingFontSizes;
+ for (Node *node = startNode; node != beyondEnd; node = node->traverseNextNode())
+ startingFontSizes.set(node, computedFontSize(node));
+
+ // These spans were added by us. If empty after font size changes, they can be removed.
+ Vector<RefPtr<HTMLElement> > unstyledSpans;
+
+ Node* lastStyledNode = 0;
+ for (Node* node = startNode; node != beyondEnd; node = node->traverseNextNode()) {
+ RefPtr<HTMLElement> element;
+ if (node->isHTMLElement()) {
+ // Only work on fully selected nodes.
+ if (!nodeFullySelected(node, start, end))
+ continue;
+ element = static_cast<HTMLElement*>(node);
+ } else if (node->isTextNode() && node->renderer() && node->parentNode() != lastStyledNode) {
+ // Last styled node was not parent node of this text node, but we wish to style this
+ // text node. To make this possible, add a style span to surround this text node.
+ RefPtr<HTMLElement> span = createStyleSpanElement(document());
+ surroundNodeRangeWithElement(node, node, span.get());
+ element = span.release();
+ } else {
+ // Only handle HTML elements and text nodes.
+ continue;
+ }
+ lastStyledNode = node;
+
+ CSSMutableStyleDeclaration* inlineStyleDecl = element->getInlineStyleDecl();
+ float currentFontSize = computedFontSize(node);
+ float desiredFontSize = max(MinimumFontSize, startingFontSizes.get(node) + adjustment);
+ RefPtr<CSSValue> value = inlineStyleDecl->getPropertyCSSValue(CSSPropertyFontSize);
+ if (value) {
+ inlineStyleDecl->removeProperty(CSSPropertyFontSize, true);
+ currentFontSize = computedFontSize(node);
+ }
+ if (currentFontSize != desiredFontSize) {
+ inlineStyleDecl->setProperty(CSSPropertyFontSize, String::number(desiredFontSize) + "px", false, false);
+ setNodeAttribute(element.get(), styleAttr, inlineStyleDecl->cssText());
+ }
+ if (inlineStyleDecl->isEmpty()) {
+ removeNodeAttribute(element.get(), styleAttr);
+ // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan? Need a test.
+ if (isUnstyledStyleSpan(element.get()))
+ unstyledSpans.append(element.release());
+ }
+ }
+
+ size_t size = unstyledSpans.size();
+ for (size_t i = 0; i < size; ++i)
+ removeNodePreservingChildren(unstyledSpans[i].get());
+}
+
+#undef NoFontDelta
+#undef MinimumFontSize
+
+static Node* dummySpanAncestorForNode(const Node* node)
+{
+ while (node && !isStyleSpan(node))
+ node = node->parent();
+
+ return node ? node->parent() : 0;
+}
+
+void ApplyStyleCommand::cleanupUnstyledAppleStyleSpans(Node* dummySpanAncestor)
+{
+ if (!dummySpanAncestor)
+ return;
+
+ // Dummy spans are created when text node is split, so that style information
+ // can be propagated, which can result in more splitting. If a dummy span gets
+ // cloned/split, the new node is always a sibling of it. Therefore, we scan
+ // all the children of the dummy's parent
+ Node* next;
+ for (Node* node = dummySpanAncestor->firstChild(); node; node = next) {
+ next = node->nextSibling();
+ if (isUnstyledStyleSpan(node))
+ removeNodePreservingChildren(node);
+ node = next;
+ }
+}
+
+HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool before, RefPtr<CSSPrimitiveValue> allowedDirection)
+{
+ // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
+ // In that case, we return the unsplit ancestor. Otherwise, we return 0.
+ Node* block = enclosingBlock(node);
+ if (!block)
+ return 0;
+
+ Node* highestAncestorWithUnicodeBidi = 0;
+ Node* nextHighestAncestorWithUnicodeBidi = 0;
+ RefPtr<CSSPrimitiveValue> highestAncestorUnicodeBidi;
+ for (Node* n = node->parent(); n != block; n = n->parent()) {
+ RefPtr<CSSValue> unicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+ if (unicodeBidi) {
+ ASSERT(unicodeBidi->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() != CSSValueNormal) {
+ highestAncestorUnicodeBidi = static_cast<CSSPrimitiveValue*>(unicodeBidi.get());
+ nextHighestAncestorWithUnicodeBidi = highestAncestorWithUnicodeBidi;
+ highestAncestorWithUnicodeBidi = n;
+ }
+ }
+ }
+
+ if (!highestAncestorWithUnicodeBidi)
+ return 0;
+
+ HTMLElement* unsplitAncestor = 0;
+
+ if (allowedDirection && highestAncestorUnicodeBidi->getIdent() != CSSValueBidiOverride) {
+ RefPtr<CSSValue> highestAncestorDirection = computedStyle(highestAncestorWithUnicodeBidi)->getPropertyCSSValue(CSSPropertyDirection);
+ ASSERT(highestAncestorDirection->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(highestAncestorDirection.get())->getIdent() == allowedDirection->getIdent() && highestAncestorWithUnicodeBidi->isHTMLElement()) {
+ if (!nextHighestAncestorWithUnicodeBidi)
+ return static_cast<HTMLElement*>(highestAncestorWithUnicodeBidi);
+
+ unsplitAncestor = static_cast<HTMLElement*>(highestAncestorWithUnicodeBidi);
+ highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;
+ }
+ }
+
+ // Split every ancestor through highest ancestor with embedding.
+ Node* n = node;
+ while (true) {
+ Element* parent = static_cast<Element*>(n->parent());
+ if (before ? n->previousSibling() : n->nextSibling())
+ splitElement(parent, before ? n : n->nextSibling());
+ if (parent == highestAncestorWithUnicodeBidi)
+ break;
+ n = n->parent();
+ }
+ return unsplitAncestor;
+}
+
+void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, Node* unsplitAncestor)
+{
+ Node* block = enclosingBlock(node);
+ if (!block)
+ return;
+
+ Node* n = node->parent();
+ while (n != block && n != unsplitAncestor) {
+ Node* parent = n->parent();
+ if (!n->isStyledElement()) {
+ n = parent;
+ continue;
+ }
+
+ StyledElement* element = static_cast<StyledElement*>(n);
+ RefPtr<CSSValue> unicodeBidi = computedStyle(element)->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+ if (unicodeBidi) {
+ ASSERT(unicodeBidi->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() != CSSValueNormal) {
+ // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,
+ // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
+ // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
+ // otherwise it sets the property in the inline style declaration.
+ if (element->hasAttribute(dirAttr)) {
+ // FIXME: If this is a BDO element, we should probably just remove it if it has no
+ // other attributes, like we (should) do with B and I elements.
+ removeNodeAttribute(element, dirAttr);
+ } else {
+ RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->getInlineStyleDecl()->copy();
+ inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
+ inlineStyle->removeProperty(CSSPropertyDirection);
+ setNodeAttribute(element, styleAttr, inlineStyle->cssText());
+ // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan? Need a test.
+ if (isUnstyledStyleSpan(element))
+ removeNodePreservingChildren(element);
+ }
+ }
+ }
+ n = parent;
+ }
+}
+
+void ApplyStyleCommand::applyInlineStyle(CSSMutableStyleDeclaration *style)
+{
+ Node* startDummySpanAncestor = 0;
+ Node* endDummySpanAncestor = 0;
+
+ // update document layout once before removing styles
+ // so that we avoid the expense of updating before each and every call
+ // to check a computed style
+ updateLayout();
+
+ // adjust to the positions we want to use for applying style
+ Position start = startPosition();
+ Position end = endPosition();
+ if (comparePositions(end, start) < 0) {
+ Position swap = start;
+ start = end;
+ end = swap;
+ }
+
+ // split the start node and containing element if the selection starts inside of it
+ bool splitStart = splitTextElementAtStartIfNeeded(start, end);
+ if (splitStart) {
+ start = startPosition();
+ end = endPosition();
+ startDummySpanAncestor = dummySpanAncestorForNode(start.node());
+ }
+
+ // split the end node and containing element if the selection ends inside of it
+ bool splitEnd = splitTextElementAtEndIfNeeded(start, end);
+ if (splitEnd) {
+ start = startPosition();
+ end = endPosition();
+ endDummySpanAncestor = dummySpanAncestorForNode(end.node());
+ }
+
+ RefPtr<CSSValue> unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+ RefPtr<CSSValue> direction;
+ HTMLElement* startUnsplitAncestor = 0;
+ HTMLElement* endUnsplitAncestor = 0;
+ if (unicodeBidi) {
+ RefPtr<CSSPrimitiveValue> allowedDirection;
+ ASSERT(unicodeBidi->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() == CSSValueEmbed) {
+ // Leave alone an ancestor that provides the desired single level embedding, if there is one.
+ direction = style->getPropertyCSSValue(CSSPropertyDirection);
+ ASSERT(direction->isPrimitiveValue());
+ allowedDirection = static_cast<CSSPrimitiveValue*>(direction.get());
+ }
+ startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.node(), true, allowedDirection);
+ endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.node(), false, allowedDirection);
+ removeEmbeddingUpToEnclosingBlock(start.node(), startUnsplitAncestor);
+ removeEmbeddingUpToEnclosingBlock(end.node(), endUnsplitAncestor);
+ }
+
+ // Remove style from the selection.
+ // Use the upstream position of the start for removing style.
+ // This will ensure we remove all traces of the relevant styles from the selection
+ // and prevent us from adding redundant ones, as described in:
+ // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
+ Position removeStart = start.upstream();
+ Position embeddingRemoveStart = removeStart;
+ Position embeddingRemoveEnd = end;
+ if (unicodeBidi) {
+ // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
+ if (startUnsplitAncestor && nodeFullySelected(startUnsplitAncestor, removeStart, end))
+ embeddingRemoveStart = positionInParentAfterNode(startUnsplitAncestor);
+ if (endUnsplitAncestor && nodeFullySelected(endUnsplitAncestor, removeStart, end))
+ embeddingRemoveEnd = positionInParentBeforeNode(endUnsplitAncestor).downstream();
+ }
+
+ if (embeddingRemoveStart != removeStart || embeddingRemoveEnd != end) {
+ RefPtr<CSSMutableStyleDeclaration> embeddingStyle = CSSMutableStyleDeclaration::create();
+ embeddingStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);
+ embeddingStyle->setProperty(CSSPropertyDirection, static_cast<CSSPrimitiveValue*>(direction.get())->getIdent());
+ if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0)
+ removeInlineStyle(embeddingStyle, embeddingRemoveStart, embeddingRemoveEnd);
+
+ RefPtr<CSSMutableStyleDeclaration> styleWithoutEmbedding = style->copy();
+ styleWithoutEmbedding->removeProperty(CSSPropertyUnicodeBidi);
+ styleWithoutEmbedding->removeProperty(CSSPropertyDirection);
+ removeInlineStyle(styleWithoutEmbedding, removeStart, end);
+ } else
+ removeInlineStyle(style, removeStart, end);
+
+ start = startPosition();
+ end = endPosition();
+
+ if (splitStart) {
+ bool mergedStart = mergeStartWithPreviousIfIdentical(start, end);
+ if (mergedStart) {
+ start = startPosition();
+ end = endPosition();
+ }
+ }
+
+ if (splitEnd) {
+ mergeEndWithNextIfIdentical(start, end);
+ start = startPosition();
+ end = endPosition();
+ }
+
+ // update document layout once before running the rest of the function
+ // so that we avoid the expense of updating before each and every call
+ // to check a computed style
+ updateLayout();
+
+ Position embeddingApplyStart = start;
+ Position embeddingApplyEnd = end;
+ if (unicodeBidi) {
+ // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
+ Node* startEnclosingBlock = enclosingBlock(start.node());
+ for (Node* n = start.node(); n != startEnclosingBlock; n = n->parent()) {
+ if (n->isHTMLElement()) {
+ RefPtr<CSSValue> ancestorUnicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+ if (ancestorUnicodeBidi) {
+ ASSERT(ancestorUnicodeBidi->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(ancestorUnicodeBidi.get())->getIdent() == CSSValueEmbed) {
+ embeddingApplyStart = positionInParentAfterNode(n);
+ break;
+ }
+ }
+ }
+ }
+
+ Node* endEnclosingBlock = enclosingBlock(end.node());
+ for (Node* n = end.node(); n != endEnclosingBlock; n = n->parent()) {
+ if (n->isHTMLElement()) {
+ RefPtr<CSSValue> ancestorUnicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+ if (ancestorUnicodeBidi) {
+ ASSERT(ancestorUnicodeBidi->isPrimitiveValue());
+ if (static_cast<CSSPrimitiveValue*>(ancestorUnicodeBidi.get())->getIdent() == CSSValueEmbed) {
+ embeddingApplyEnd = positionInParentBeforeNode(n);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (embeddingApplyStart != start || embeddingApplyEnd != end) {
+ if (embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull()) {
+ RefPtr<CSSMutableStyleDeclaration> embeddingStyle = CSSMutableStyleDeclaration::create();
+ embeddingStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);
+ embeddingStyle->setProperty(CSSPropertyDirection, static_cast<CSSPrimitiveValue*>(direction.get())->getIdent());
+ applyInlineStyleToRange(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd);
+ }
+
+ RefPtr<CSSMutableStyleDeclaration> styleWithoutEmbedding = style->copy();
+ styleWithoutEmbedding->removeProperty(CSSPropertyUnicodeBidi);
+ styleWithoutEmbedding->removeProperty(CSSPropertyDirection);
+ applyInlineStyleToRange(styleWithoutEmbedding.get(), start, end);
+ } else
+ applyInlineStyleToRange(style, start, end);
+
+ // Remove dummy style spans created by splitting text elements.
+ cleanupUnstyledAppleStyleSpans(startDummySpanAncestor);
+ if (endDummySpanAncestor != startDummySpanAncestor)
+ cleanupUnstyledAppleStyleSpans(endDummySpanAncestor);
+}
+
+void ApplyStyleCommand::applyInlineStyleToRange(CSSMutableStyleDeclaration* style, const Position& start, const Position& rangeEnd)
+{
+ Node* node = start.node();
+ Position end = rangeEnd;
+
+ bool rangeIsEmpty = false;
+
+ if (start.deprecatedEditingOffset() >= caretMaxOffset(start.node())) {
+ node = node->traverseNextNode();
+ Position newStart = Position(node, 0);
+ if (!node || comparePositions(end, newStart) < 0)
+ rangeIsEmpty = true;
+ }
+
+ if (!rangeIsEmpty) {
+ // pastEndNode is the node after the last fully selected node.
+ Node* pastEndNode = end.node();
+ if (end.deprecatedEditingOffset() >= caretMaxOffset(end.node()))
+ pastEndNode = end.node()->traverseNextSibling();
+ // FIXME: Callers should perform this operation on a Range that includes the br
+ // if they want style applied to the empty line.
+ if (start == end && start.node()->hasTagName(brTag))
+ pastEndNode = start.node()->traverseNextNode();
+ // Add the style to selected inline runs.
+ for (Node* next; node && node != pastEndNode; node = next) {
+
+ next = node->traverseNextNode();
+
+ if (!node->renderer() || !node->isContentEditable())
+ continue;
+
+ if (!node->isContentRichlyEditable() && node->isHTMLElement()) {
+ // This is a plaintext-only region. Only proceed if it's fully selected.
+ // pastEndNode is the node after the last fully selected node, so if it's inside node then
+ // node isn't fully selected.
+ if (pastEndNode && pastEndNode->isDescendantOf(node))
+ break;
+ // Add to this element's inline style and skip over its contents.
+ HTMLElement* element = static_cast<HTMLElement*>(node);
+ RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->getInlineStyleDecl()->copy();
+ inlineStyle->merge(style);
+ setNodeAttribute(element, styleAttr, inlineStyle->cssText());
+ next = node->traverseNextSibling();
+ continue;
+ }
+
+ if (isBlock(node))
+ continue;
+
+ if (node->childNodeCount()) {
+ if (editingIgnoresContent(node)) {
+ next = node->traverseNextSibling();
+ continue;
+ }
+ continue;
+ }
+
+ Node* runStart = node;
+ // Find the end of the run.
+ Node* sibling = node->nextSibling();
+ while (sibling && sibling != pastEndNode && (!sibling->isElementNode() || sibling->hasTagName(brTag)) && !isBlock(sibling)) {
+ node = sibling;
+ sibling = node->nextSibling();
+ }
+ // Recompute next, since node has changed.
+ next = node->traverseNextNode();
+ // Apply the style to the run.
+ addInlineStyleIfNeeded(style, runStart, node);
+ }
+ }
+}
+
+bool ApplyStyleCommand::shouldRemoveTextDecorationTag(CSSStyleDeclaration* styleToApply, int textDecorationAddedByTag) const
+{
+ // Honor text-decorations-in-effect
+ RefPtr<CSSValue> textDecorationsToApply = styleToApply->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+ if (!textDecorationsToApply || !textDecorationsToApply->isValueList())
+ textDecorationsToApply = styleToApply->getPropertyCSSValue(CSSPropertyTextDecoration);
+
+ // When there is no text decorations to apply, remove any one of u, s, & strike
+ if (!textDecorationsToApply || !textDecorationsToApply->isValueList())
+ return true;
+
+ // Remove node if it implicitly adds style not present in styleToApply
+ CSSValueList* valueList = static_cast<CSSValueList*>(textDecorationsToApply.get());
+ RefPtr<CSSPrimitiveValue> value = CSSPrimitiveValue::createIdentifier(textDecorationAddedByTag);
+ return !valueList->hasValue(value.get());
+}
+
+// This function maps from styling tags to CSS styles. Used for knowing which
+// styling tags should be removed when toggling styles.
+bool ApplyStyleCommand::implicitlyStyledElementShouldBeRemovedWhenApplyingStyle(HTMLElement* elem, CSSMutableStyleDeclaration* style)
+{
+ CSSMutableStyleDeclaration::const_iterator end = style->end();
+ for (CSSMutableStyleDeclaration::const_iterator it = style->begin(); it != end; ++it) {
+ const CSSProperty& property = *it;
+ // FIXME: This should probably be re-written to lookup the tagname in a
+ // hash and match against an expected property/value pair.
+ switch (property.id()) {
+ case CSSPropertyFontWeight:
+ // IE inserts "strong" tags for execCommand("bold"), so we remove them, even though they're not strictly presentational
+ if (elem->hasLocalName(bTag) || elem->hasLocalName(strongTag))
+ return !equalIgnoringCase(property.value()->cssText(), "bold") || !elem->hasChildNodes();
+ break;
+ case CSSPropertyVerticalAlign:
+ if (elem->hasLocalName(subTag))
+ return !equalIgnoringCase(property.value()->cssText(), "sub") || !elem->hasChildNodes();
+ if (elem->hasLocalName(supTag))
+ return !equalIgnoringCase(property.value()->cssText(), "sup") || !elem->hasChildNodes();
+ break;
+ case CSSPropertyFontStyle:
+ // IE inserts "em" tags for execCommand("italic"), so we remove them, even though they're not strictly presentational
+ if (elem->hasLocalName(iTag) || elem->hasLocalName(emTag))
+ return !equalIgnoringCase(property.value()->cssText(), "italic") || !elem->hasChildNodes();
+ break;
+ case CSSPropertyTextDecoration:
+ case CSSPropertyWebkitTextDecorationsInEffect:
+ if (elem->hasLocalName(uTag))
+ return shouldRemoveTextDecorationTag(style, CSSValueUnderline) || !elem->hasChildNodes();
+ else if (elem->hasLocalName(sTag) || elem->hasTagName(strikeTag))
+ return shouldRemoveTextDecorationTag(style,CSSValueLineThrough) || !elem->hasChildNodes();
+ }
+ }
+ return false;
+}
+
+void ApplyStyleCommand::replaceWithSpanOrRemoveIfWithoutAttributes(HTMLElement*& elem)
+{
+ bool removeNode = false;
+
+ // Similar to isSpanWithoutAttributesOrUnstyleStyleSpan, but does not look for Apple-style-span.
+ NamedNodeMap* attributes = elem->attributes(true); // readonly
+ if (!attributes || attributes->isEmpty())
+ removeNode = true;
+ else if (attributes->length() == 1 && elem->hasAttribute(styleAttr)) {
+ // Remove the element even if it has just style='' (this might be redundantly checked later too)
+ CSSMutableStyleDeclaration* inlineStyleDecl = elem->inlineStyleDecl();
+ if (!inlineStyleDecl || inlineStyleDecl->isEmpty())
+ removeNode = true;
+ }
+
+ if (removeNode)
+ removeNodePreservingChildren(elem);
+ else {
+ HTMLElement* newSpanElement = replaceNodeWithSpanPreservingChildrenAndAttributes(elem);
+ ASSERT(newSpanElement && newSpanElement->inDocument());
+ elem = newSpanElement;
+ }
+}
+
+void ApplyStyleCommand::removeHTMLFontStyle(CSSMutableStyleDeclaration *style, HTMLElement *elem)
+{
+ ASSERT(style);
+ ASSERT(elem);
+
+ if (!elem->hasLocalName(fontTag))
+ return;
+
+ CSSMutableStyleDeclaration::const_iterator end = style->end();
+ for (CSSMutableStyleDeclaration::const_iterator it = style->begin(); it != end; ++it) {
+ switch ((*it).id()) {
+ case CSSPropertyColor:
+ removeNodeAttribute(elem, colorAttr);
+ break;
+ case CSSPropertyFontFamily:
+ removeNodeAttribute(elem, faceAttr);
+ break;
+ case CSSPropertyFontSize:
+ removeNodeAttribute(elem, sizeAttr);
+ break;
+ }
+ }
+
+ if (isEmptyFontTag(elem))
+ removeNodePreservingChildren(elem);
+}
+
+void ApplyStyleCommand::removeHTMLBidiEmbeddingStyle(CSSMutableStyleDeclaration *style, HTMLElement *elem)
+{
+ ASSERT(style);
+ ASSERT(elem);
+
+ if (!elem->hasAttribute(dirAttr))
+ return;
+
+ if (!style->getPropertyCSSValue(CSSPropertyUnicodeBidi) && !style->getPropertyCSSValue(CSSPropertyDirection))
+ return;
+
+ removeNodeAttribute(elem, dirAttr);
+
+ // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan? Need a test.
+ if (isUnstyledStyleSpan(elem))
+ removeNodePreservingChildren(elem);
+}
+
+void ApplyStyleCommand::removeCSSStyle(CSSMutableStyleDeclaration* style, HTMLElement* elem)
+{
+ ASSERT(style);
+ ASSERT(elem);
+
+ CSSMutableStyleDeclaration* decl = elem->inlineStyleDecl();
+ if (!decl)
+ return;
+
+ CSSMutableStyleDeclaration::const_iterator end = style->end();
+ for (CSSMutableStyleDeclaration::const_iterator it = style->begin(); it != end; ++it) {
+ CSSPropertyID propertyID = static_cast<CSSPropertyID>((*it).id());
+ RefPtr<CSSValue> value = decl->getPropertyCSSValue(propertyID);
+ if (value && (propertyID != CSSPropertyWhiteSpace || !isTabSpanNode(elem))) {
+ removeCSSProperty(decl, propertyID);
+ if (propertyID == CSSPropertyUnicodeBidi && !decl->getPropertyValue(CSSPropertyDirection).isEmpty())
+ removeCSSProperty(decl, CSSPropertyDirection);
+ }
+ }
+
+ // No need to serialize <foo style=""> if we just removed the last css property
+ if (decl->isEmpty())
+ removeNodeAttribute(elem, styleAttr);
+
+ if (isSpanWithoutAttributesOrUnstyleStyleSpan(elem))
+ removeNodePreservingChildren(elem);
+}
+
+static bool hasTextDecorationProperty(Node *node)
+{
+ if (!node->isElementNode())
+ return false;
+
+ RefPtr<CSSValue> value = computedStyle(node)->getPropertyCSSValue(CSSPropertyTextDecoration, DoNotUpdateLayout);
+ return value && !equalIgnoringCase(value->cssText(), "none");
+}
+
+static Node* highestAncestorWithTextDecoration(Node *node)
+{
+ ASSERT(node);
+ Node* result = 0;
+ Node* unsplittableElement = unsplittableElementForPosition(Position(node, 0));
+
+ for (Node *n = node; n; n = n->parentNode()) {
+ if (hasTextDecorationProperty(n))
+ result = n;
+ // Should stop at the editable root (cannot cross editing boundary) and
+ // also stop at the unsplittable element to be consistent with other UAs
+ if (n == unsplittableElement)
+ break;
+ }
+
+ return result;
+}
+
+PassRefPtr<CSSMutableStyleDeclaration> ApplyStyleCommand::extractTextDecorationStyle(Node* node)
+{
+ ASSERT(node);
+ ASSERT(node->isElementNode());
+
+ // non-html elements not handled yet
+ if (!node->isHTMLElement())
+ return 0;
+
+ HTMLElement *element = static_cast<HTMLElement *>(node);
+ RefPtr<CSSMutableStyleDeclaration> style = element->inlineStyleDecl();
+ if (!style)
+ return 0;
+
+ int properties[1] = { CSSPropertyTextDecoration };
+ RefPtr<CSSMutableStyleDeclaration> textDecorationStyle = style->copyPropertiesInSet(properties, 1);
+
+ RefPtr<CSSValue> property = style->getPropertyCSSValue(CSSPropertyTextDecoration);
+ if (property && !equalIgnoringCase(property->cssText(), "none"))
+ removeCSSProperty(style.get(), CSSPropertyTextDecoration);
+
+ return textDecorationStyle.release();
+}
+
+PassRefPtr<CSSMutableStyleDeclaration> ApplyStyleCommand::extractAndNegateTextDecorationStyle(Node* node)
+{
+ ASSERT(node);
+ ASSERT(node->isElementNode());
+
+ // non-html elements not handled yet
+ if (!node->isHTMLElement())
+ return 0;
+
+ RefPtr<CSSComputedStyleDeclaration> nodeStyle = computedStyle(node);
+ ASSERT(nodeStyle);
+
+ int properties[1] = { CSSPropertyTextDecoration };
+ RefPtr<CSSMutableStyleDeclaration> textDecorationStyle = nodeStyle->copyPropertiesInSet(properties, 1);
+
+ RefPtr<CSSValue> property = nodeStyle->getPropertyCSSValue(CSSPropertyTextDecoration);
+ if (property && !equalIgnoringCase(property->cssText(), "none")) {
+ RefPtr<CSSMutableStyleDeclaration> newStyle = textDecorationStyle->copy();
+ newStyle->setProperty(CSSPropertyTextDecoration, "none");
+ applyTextDecorationStyle(node, newStyle.get());
+ }
+
+ return textDecorationStyle.release();
+}
+
+void ApplyStyleCommand::applyTextDecorationStyle(Node *node, CSSMutableStyleDeclaration *style)
+{
+ ASSERT(node);
+
+ if (!style || style->cssText().isEmpty())
+ return;
+
+ StyleChange styleChange(style, Position(node, 0));
+ if (styleChange.cssStyle().length()) {
+ if (node->isTextNode()) {
+ RefPtr<HTMLElement> styleSpan = createStyleSpanElement(document());
+ surroundNodeRangeWithElement(node, node, styleSpan.get());
+ node = styleSpan.get();
+ }
+
+ if (!node->isElementNode())
+ return;
+
+ HTMLElement *element = static_cast<HTMLElement *>(node);
+ String cssText = styleChange.cssStyle();
+ CSSMutableStyleDeclaration *decl = element->inlineStyleDecl();
+ if (decl)
+ cssText += decl->cssText();
+ setNodeAttribute(element, styleAttr, cssText);
+ }
+
+ if (styleChange.applyUnderline())
+ surroundNodeRangeWithElement(node, node, createHTMLElement(document(), uTag));
+
+ if (styleChange.applyLineThrough())
+ surroundNodeRangeWithElement(node, node, createHTMLElement(document(), sTag));
+}
+
+void ApplyStyleCommand::pushDownTextDecorationStyleAroundNode(Node* targetNode, bool forceNegate)
+{
+ ASSERT(targetNode);
+ Node* highestAncestor = highestAncestorWithTextDecoration(targetNode);
+ if (!highestAncestor)
+ return;
+
+ // The outer loop is traversing the tree vertically from highestAncestor to targetNode
+ Node* current = highestAncestor;
+ while (current != targetNode) {
+ ASSERT(current);
+ ASSERT(current->contains(targetNode));
+ RefPtr<CSSMutableStyleDeclaration> decoration = forceNegate ? extractAndNegateTextDecorationStyle(current) : extractTextDecorationStyle(current);
+
+ // The inner loop will go through children on each level
+ Node* child = current->firstChild();
+ while (child) {
+ Node* nextChild = child->nextSibling();
+
+ // Apply text decoration to all nodes containing targetNode and their siblings but NOT to targetNode
+ if (child != targetNode)
+ applyTextDecorationStyle(child, decoration.get());
+
+ // We found the next node for the outer loop (contains targetNode)
+ // When reached targetNode, stop the outer loop upon the completion of the current inner loop
+ if (child == targetNode || child->contains(targetNode))
+ current = child;
+
+ child = nextChild;
+ }
+ }
+}
+
+void ApplyStyleCommand::pushDownTextDecorationStyleAtBoundaries(const Position &start, const Position &end)
+{
+ // We need to work in two passes. First we push down any inline
+ // styles that set text decoration. Then we look for any remaining
+ // styles (caused by stylesheets) and explicitly negate text
+ // decoration while pushing down.
+
+ pushDownTextDecorationStyleAroundNode(start.node(), false);
+ updateLayout();
+ pushDownTextDecorationStyleAroundNode(start.node(), true);
+
+ pushDownTextDecorationStyleAroundNode(end.node(), false);
+ updateLayout();
+ pushDownTextDecorationStyleAroundNode(end.node(), true);
+}
+
+// FIXME: Why does this exist? Callers should either use lastOffsetForEditing or lastOffsetInNode
+static int maxRangeOffset(Node *n)
+{
+ if (n->offsetInCharacters())
+ return n->maxCharacterOffset();
+
+ if (n->isElementNode())
+ return n->childNodeCount();
+
+ return 1;
+}
+
+void ApplyStyleCommand::removeInlineStyle(PassRefPtr<CSSMutableStyleDeclaration> style, const Position &start, const Position &end)
+{
+ ASSERT(start.isNotNull());
+ ASSERT(end.isNotNull());
+ ASSERT(start.node()->inDocument());
+ ASSERT(end.node()->inDocument());
+ ASSERT(comparePositions(start, end) <= 0);
+
+ RefPtr<CSSValue> textDecorationSpecialProperty = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+
+ if (textDecorationSpecialProperty) {
+ pushDownTextDecorationStyleAtBoundaries(start.downstream(), end.upstream());
+ style = style->copy();
+ style->setProperty(CSSPropertyTextDecoration, textDecorationSpecialProperty->cssText(), style->getPropertyPriority(CSSPropertyWebkitTextDecorationsInEffect));
+ }
+
+ // The s and e variables store the positions used to set the ending selection after style removal
+ // takes place. This will help callers to recognize when either the start node or the end node
+ // are removed from the document during the work of this function.
+ Position s = start;
+ Position e = end;
+
+ Node* node = start.node();
+ while (node) {
+ Node* next = node->traverseNextNode();
+ if (node->isHTMLElement() && nodeFullySelected(node, start, end)) {
+ HTMLElement* elem = static_cast<HTMLElement*>(node);
+ Node* prev = elem->traversePreviousNodePostOrder();
+ Node* next = elem->traverseNextNode();
+ if (m_styledInlineElement && elem->hasTagName(m_styledInlineElement->tagQName()))
+ removeNodePreservingChildren(elem);
+
+ if (implicitlyStyledElementShouldBeRemovedWhenApplyingStyle(elem, style.get()))
+ replaceWithSpanOrRemoveIfWithoutAttributes(elem);
+
+ // If the node was converted to a span, the span may still contain relevant
+ // styles which must be removed (e.g. <b style='font-weight: bold'>)
+ if (elem->inDocument()) {
+ removeHTMLFontStyle(style.get(), elem);
+ removeHTMLBidiEmbeddingStyle(style.get(), elem);
+ removeCSSStyle(style.get(), elem);
+ }
+ if (!elem->inDocument()) {
+ if (s.node() == elem) {
+ // Since elem must have been fully selected, and it is at the start
+ // of the selection, it is clear we can set the new s offset to 0.
+ ASSERT(s.deprecatedEditingOffset() <= caretMinOffset(s.node()));
+ s = Position(next, 0);
+ }
+ if (e.node() == elem) {
+ // Since elem must have been fully selected, and it is at the end
+ // of the selection, it is clear we can set the new e offset to
+ // the max range offset of prev.
+ ASSERT(e.deprecatedEditingOffset() >= maxRangeOffset(e.node()));
+ e = Position(prev, maxRangeOffset(prev));
+ }
+ }
+ }
+ if (node == end.node())
+ break;
+ node = next;
+ }
+
+ ASSERT(s.node()->inDocument());
+ ASSERT(e.node()->inDocument());
+ updateStartEnd(s, e);
+}
+
+bool ApplyStyleCommand::nodeFullySelected(Node *node, const Position &start, const Position &end) const
+{
+ ASSERT(node);
+ ASSERT(node->isElementNode());
+
+ Position pos = Position(node, node->childNodeCount()).upstream();
+ return comparePositions(Position(node, 0), start) >= 0 && comparePositions(pos, end) <= 0;
+}
+
+bool ApplyStyleCommand::nodeFullyUnselected(Node *node, const Position &start, const Position &end) const
+{
+ ASSERT(node);
+ ASSERT(node->isElementNode());
+
+ Position pos = Position(node, node->childNodeCount()).upstream();
+ bool isFullyBeforeStart = comparePositions(pos, start) < 0;
+ bool isFullyAfterEnd = comparePositions(Position(node, 0), end) > 0;
+
+ return isFullyBeforeStart || isFullyAfterEnd;
+}
+
+
+bool ApplyStyleCommand::splitTextAtStartIfNeeded(const Position &start, const Position &end)
+{
+ if (start.node()->isTextNode() && start.deprecatedEditingOffset() > caretMinOffset(start.node()) && start.deprecatedEditingOffset() < caretMaxOffset(start.node())) {
+ int endOffsetAdjustment = start.node() == end.node() ? start.deprecatedEditingOffset() : 0;
+ Text *text = static_cast<Text *>(start.node());
+ splitTextNode(text, start.deprecatedEditingOffset());
+ updateStartEnd(Position(start.node(), 0), Position(end.node(), end.deprecatedEditingOffset() - endOffsetAdjustment));
+ return true;
+ }
+ return false;
+}
+
+bool ApplyStyleCommand::splitTextAtEndIfNeeded(const Position &start, const Position &end)
+{
+ if (end.node()->isTextNode() && end.deprecatedEditingOffset() > caretMinOffset(end.node()) && end.deprecatedEditingOffset() < caretMaxOffset(end.node())) {
+ Text *text = static_cast<Text *>(end.node());
+ splitTextNode(text, end.deprecatedEditingOffset());
+
+ Node *prevNode = text->previousSibling();
+ ASSERT(prevNode);
+ Node *startNode = start.node() == end.node() ? prevNode : start.node();
+ ASSERT(startNode);
+ updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(prevNode, caretMaxOffset(prevNode)));
+ return true;
+ }
+ return false;
+}
+
+bool ApplyStyleCommand::splitTextElementAtStartIfNeeded(const Position &start, const Position &end)
+{
+ if (start.node()->isTextNode() && start.deprecatedEditingOffset() > caretMinOffset(start.node()) && start.deprecatedEditingOffset() < caretMaxOffset(start.node())) {
+ int endOffsetAdjustment = start.node() == end.node() ? start.deprecatedEditingOffset() : 0;
+ Text *text = static_cast<Text *>(start.node());
+ splitTextNodeContainingElement(text, start.deprecatedEditingOffset());
+
+ updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex()), Position(end.node(), end.deprecatedEditingOffset() - endOffsetAdjustment));
+ return true;
+ }
+ return false;
+}
+
+bool ApplyStyleCommand::splitTextElementAtEndIfNeeded(const Position &start, const Position &end)
+{
+ if (end.node()->isTextNode() && end.deprecatedEditingOffset() > caretMinOffset(end.node()) && end.deprecatedEditingOffset() < caretMaxOffset(end.node())) {
+ Text *text = static_cast<Text *>(end.node());
+ splitTextNodeContainingElement(text, end.deprecatedEditingOffset());
+
+ Node *prevNode = text->parent()->previousSibling()->lastChild();
+ ASSERT(prevNode);
+ Node *startNode = start.node() == end.node() ? prevNode : start.node();
+ ASSERT(startNode);
+ updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(prevNode->parent(), prevNode->nodeIndex() + 1));
+ return true;
+ }
+ return false;
+}
+
+static bool areIdenticalElements(Node *first, Node *second)
+{
+ // check that tag name and all attribute names and values are identical
+
+ if (!first->isElementNode())
+ return false;
+
+ if (!second->isElementNode())
+ return false;
+
+ Element *firstElement = static_cast<Element *>(first);
+ Element *secondElement = static_cast<Element *>(second);
+
+ if (!firstElement->tagQName().matches(secondElement->tagQName()))
+ return false;
+
+ NamedNodeMap *firstMap = firstElement->attributes();
+ NamedNodeMap *secondMap = secondElement->attributes();
+
+ unsigned firstLength = firstMap->length();
+
+ if (firstLength != secondMap->length())
+ return false;
+
+ for (unsigned i = 0; i < firstLength; i++) {
+ Attribute *attribute = firstMap->attributeItem(i);
+ Attribute *secondAttribute = secondMap->getAttributeItem(attribute->name());
+
+ if (!secondAttribute || attribute->value() != secondAttribute->value())
+ return false;
+ }
+
+ return true;
+}
+
+bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position &start, const Position &end)
+{
+ Node *startNode = start.node();
+ int startOffset = start.deprecatedEditingOffset();
+
+ if (isAtomicNode(start.node())) {
+ if (start.deprecatedEditingOffset() != 0)
+ return false;
+
+ // note: prior siblings could be unrendered elements. it's silly to miss the
+ // merge opportunity just for that.
+ if (start.node()->previousSibling())
+ return false;
+
+ startNode = start.node()->parent();
+ startOffset = 0;
+ }
+
+ if (!startNode->isElementNode())
+ return false;
+
+ if (startOffset != 0)
+ return false;
+
+ Node *previousSibling = startNode->previousSibling();
+
+ if (previousSibling && areIdenticalElements(startNode, previousSibling)) {
+ Element *previousElement = static_cast<Element *>(previousSibling);
+ Element *element = static_cast<Element *>(startNode);
+ Node *startChild = element->firstChild();
+ ASSERT(startChild);
+ mergeIdenticalElements(previousElement, element);
+
+ int startOffsetAdjustment = startChild->nodeIndex();
+ int endOffsetAdjustment = startNode == end.node() ? startOffsetAdjustment : 0;
+ updateStartEnd(Position(startNode, startOffsetAdjustment), Position(end.node(), end.deprecatedEditingOffset() + endOffsetAdjustment));
+ return true;
+ }
+
+ return false;
+}
+
+bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position &start, const Position &end)
+{
+ Node *endNode = end.node();
+ int endOffset = end.deprecatedEditingOffset();
+
+ if (isAtomicNode(endNode)) {
+ if (endOffset < caretMaxOffset(endNode))
+ return false;
+
+ unsigned parentLastOffset = end.node()->parent()->childNodes()->length() - 1;
+ if (end.node()->nextSibling())
+ return false;
+
+ endNode = end.node()->parent();
+ endOffset = parentLastOffset;
+ }
+
+ if (!endNode->isElementNode() || endNode->hasTagName(brTag))
+ return false;
+
+ Node *nextSibling = endNode->nextSibling();
+
+ if (nextSibling && areIdenticalElements(endNode, nextSibling)) {
+ Element *nextElement = static_cast<Element *>(nextSibling);
+ Element *element = static_cast<Element *>(endNode);
+ Node *nextChild = nextElement->firstChild();
+
+ mergeIdenticalElements(element, nextElement);
+
+ Node *startNode = start.node() == endNode ? nextElement : start.node();
+ ASSERT(startNode);
+
+ int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
+ updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(nextElement, endOffset));
+ return true;
+ }
+
+ return false;
+}
+
+void ApplyStyleCommand::surroundNodeRangeWithElement(Node* startNode, Node* endNode, PassRefPtr<Element> elementToInsert)
+{
+ ASSERT(startNode);
+ ASSERT(endNode);
+ ASSERT(elementToInsert);
+ RefPtr<Element> element = elementToInsert;
+
+ insertNodeBefore(element, startNode);
+
+ Node* node = startNode;
+ while (1) {
+ Node* next = node->traverseNextNode();
+ if (node->childNodeCount() == 0 && node->renderer() && node->renderer()->isInline()) {
+ removeNode(node);
+ appendNode(node, element);
+ }
+ if (node == endNode)
+ break;
+ node = next;
+ }
+
+ Node* nextSibling = element->nextSibling();
+ Node* previousSibling = element->previousSibling();
+ if (nextSibling && nextSibling->isElementNode() && nextSibling->isContentEditable()
+ && areIdenticalElements(element.get(), static_cast<Element*>(nextSibling)))
+ mergeIdenticalElements(element, static_cast<Element*>(nextSibling));
+
+ if (previousSibling && previousSibling->isElementNode() && previousSibling->isContentEditable()) {
+ Node* mergedElement = previousSibling->nextSibling();
+ if (mergedElement->isElementNode() && mergedElement->isContentEditable()
+ && areIdenticalElements(static_cast<Element*>(previousSibling), static_cast<Element*>(mergedElement)))
+ mergeIdenticalElements(static_cast<Element*>(previousSibling), static_cast<Element*>(mergedElement));
+ }
+
+ // FIXME: We should probably call updateStartEnd if the start or end was in the node
+ // range so that the endingSelection() is canonicalized. See the comments at the end of
+ // VisibleSelection::validate().
+}
+
+void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange, HTMLElement* block)
+{
+ // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
+ // inline content.
+ if (!block)
+ return;
+
+ String cssText = styleChange.cssStyle();
+ CSSMutableStyleDeclaration* decl = block->inlineStyleDecl();
+ if (decl)
+ cssText += decl->cssText();
+ setNodeAttribute(block, styleAttr, cssText);
+}
+
+static bool fontColorChangesComputedStyle(const Color& computedStyleColor, StyleChange styleChange)
+{
+ if (styleChange.applyFontColor()) {
+ if (Color(styleChange.fontColor()) != computedStyleColor)
+ return true;
+ }
+ return false;
+}
+
+static bool fontSizeChangesComputedStyle(RenderStyle* computedStyle, StyleChange styleChange)
+{
+ if (styleChange.applyFontSize()) {
+ if (styleChange.fontSize().toInt() != computedStyle->fontSize())
+ return true;
+ }
+ return false;
+}
+
+static bool fontFaceChangesComputedStyle(RenderStyle* computedStyle, StyleChange styleChange)
+{
+ if (styleChange.applyFontFace()) {
+ if (computedStyle->fontDescription().family().family().string() != styleChange.fontFace())
+ return true;
+ }
+ return false;
+}
+
+void ApplyStyleCommand::addInlineStyleIfNeeded(CSSMutableStyleDeclaration *style, Node *startNode, Node *endNode)
+{
+ if (m_removeOnly)
+ return;
+
+ StyleChange styleChange(style, Position(startNode, 0));
+
+ //
+ // Font tags need to go outside of CSS so that CSS font sizes override leagcy font sizes.
+ //
+ if (styleChange.applyFontColor() || styleChange.applyFontFace() || styleChange.applyFontSize()) {
+ RefPtr<Element> fontElement = createFontElement(document());
+ RenderStyle* computedStyle = startNode->computedStyle();
+
+ // We only want to insert a font element if it will end up changing the style of the
+ // text somehow. Otherwise it will be a garbage node that will create problems for us
+ // most notably when we apply a blockquote style for a message reply.
+ if (fontColorChangesComputedStyle(computedStyle->color(), styleChange)
+ || fontFaceChangesComputedStyle(computedStyle, styleChange)
+ || fontSizeChangesComputedStyle(computedStyle, styleChange)) {
+ if (styleChange.applyFontColor())
+ fontElement->setAttribute(colorAttr, styleChange.fontColor());
+ if (styleChange.applyFontFace())
+ fontElement->setAttribute(faceAttr, styleChange.fontFace());
+ if (styleChange.applyFontSize())
+ fontElement->setAttribute(sizeAttr, styleChange.fontSize());
+ surroundNodeRangeWithElement(startNode, endNode, fontElement.get());
+ }
+ }
+
+ if (styleChange.cssStyle().length()) {
+ RefPtr<Element> styleElement = createStyleSpanElement(document());
+ styleElement->setAttribute(styleAttr, styleChange.cssStyle());
+ surroundNodeRangeWithElement(startNode, endNode, styleElement.release());
+ }
+
+ if (styleChange.applyBold())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), bTag));
+
+ if (styleChange.applyItalic())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), iTag));
+
+ if (styleChange.applyUnderline())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), uTag));
+
+ if (styleChange.applyLineThrough())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), sTag));
+
+ if (styleChange.applySubscript())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), subTag));
+ else if (styleChange.applySuperscript())
+ surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), supTag));
+
+ if (m_styledInlineElement)
+ surroundNodeRangeWithElement(startNode, endNode, m_styledInlineElement->cloneElementWithoutChildren());
+}
+
+float ApplyStyleCommand::computedFontSize(const Node *node)
+{
+ if (!node)
+ return 0;
+
+ Position pos(const_cast<Node *>(node), 0);
+ RefPtr<CSSComputedStyleDeclaration> computedStyle = pos.computedStyle();
+ if (!computedStyle)
+ return 0;
+
+ RefPtr<CSSPrimitiveValue> value = static_pointer_cast<CSSPrimitiveValue>(computedStyle->getPropertyCSSValue(CSSPropertyFontSize));
+ if (!value)
+ return 0;
+
+ return value->getFloatValue(CSSPrimitiveValue::CSS_PX);
+}
+
+void ApplyStyleCommand::joinChildTextNodes(Node *node, const Position &start, const Position &end)
+{
+ if (!node)
+ return;
+
+ Position newStart = start;
+ Position newEnd = end;
+
+ Node *child = node->firstChild();
+ while (child) {
+ Node *next = child->nextSibling();
+ if (child->isTextNode() && next && next->isTextNode()) {
+ Text *childText = static_cast<Text *>(child);
+ Text *nextText = static_cast<Text *>(next);
+ if (next == start.node())
+ newStart = Position(childText, childText->length() + start.deprecatedEditingOffset());
+ if (next == end.node())
+ newEnd = Position(childText, childText->length() + end.deprecatedEditingOffset());
+ String textToMove = nextText->data();
+ insertTextIntoNode(childText, childText->length(), textToMove);
+ removeNode(next);
+ // don't move child node pointer. it may want to merge with more text nodes.
+ }
+ else {
+ child = child->nextSibling();
+ }
+ }
+
+ updateStartEnd(newStart, newEnd);
+}
+
+}