| /* |
| * 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); |
| } |
| |
| } |
