1 /*

     2  * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    24  */

    25 

    26 #include "config.h"

    27 #include "ApplyStyleCommand.h"

    28 

    29 #include "CSSComputedStyleDeclaration.h"

    30 #include "CSSMutableStyleDeclaration.h"

    31 #include "CSSParser.h"

    32 #include "CSSProperty.h"

    33 #include "CSSPropertyNames.h"

    34 #include "CSSValueKeywords.h"

    35 #include "Document.h"

    36 #include "Editor.h"

    37 #include "Frame.h"

    38 #include "HTMLElement.h"

    39 #include "HTMLInterchange.h"

    40 #include "HTMLNames.h"

    41 #include "NodeList.h"

    42 #include "Range.h"

    43 #include "RenderObject.h"

    44 #include "Text.h"

    45 #include "TextIterator.h"

    46 #include "htmlediting.h"

    47 #include "visible_units.h"

    48 #include <wtf/StdLibExtras.h>

    49 

    50 namespace WebCore {

    51 

    52 using namespace HTMLNames;

    53 

    54 class StyleChange {

    55 public:

    56     explicit StyleChange(CSSStyleDeclaration*, const Position&);

    57 

    58     String cssStyle() const { return m_cssStyle; }

    59     bool applyBold() const { return m_applyBold; }

    60     bool applyItalic() const { return m_applyItalic; }

    61     bool applyUnderline() const { return m_applyUnderline; }

    62     bool applyLineThrough() const { return m_applyLineThrough; }

    63     bool applySubscript() const { return m_applySubscript; }

    64     bool applySuperscript() const { return m_applySuperscript; }

    65     bool applyFontColor() const { return m_applyFontColor.length() > 0; }

    66     bool applyFontFace() const { return m_applyFontFace.length() > 0; }

    67     bool applyFontSize() const { return m_applyFontSize.length() > 0; }

    68 

    69     String fontColor() { return m_applyFontColor; }

    70     String fontFace() { return m_applyFontFace; }

    71     String fontSize() { return m_applyFontSize; }

    72 

    73 private:

    74     void init(PassRefPtr<CSSStyleDeclaration>, const Position&);

    75     void reconcileTextDecorationProperties(CSSMutableStyleDeclaration*);

    76     void extractTextStyles(CSSMutableStyleDeclaration*);

    77 

    78     String m_cssStyle;

    79     bool m_applyBold;

    80     bool m_applyItalic;

    81     bool m_applyUnderline;

    82     bool m_applyLineThrough;

    83     bool m_applySubscript;

    84     bool m_applySuperscript;

    85     String m_applyFontColor;

    86     String m_applyFontFace;

    87     String m_applyFontSize;

    88 };

    89 

    90 

    91 StyleChange::StyleChange(CSSStyleDeclaration* style, const Position& position)

    92     : m_applyBold(false)

    93     , m_applyItalic(false)

    94     , m_applyUnderline(false)

    95     , m_applyLineThrough(false)

    96     , m_applySubscript(false)

    97     , m_applySuperscript(false)

    98 {

    99     init(style, position);

   100 }

   101 

   102 void StyleChange::init(PassRefPtr<CSSStyleDeclaration> style, const Position& position)

   103 {

   104     Document* document = position.node() ? position.node()->document() : 0;

   105     if (!document || !document->frame())

   106         return;

   107 

   108     RefPtr<CSSComputedStyleDeclaration> computedStyle = position.computedStyle();

   109     RefPtr<CSSMutableStyleDeclaration> mutableStyle = getPropertiesNotInComputedStyle(style.get(), computedStyle.get());

   110 

   111     reconcileTextDecorationProperties(mutableStyle.get());

   112     if (!document->frame()->editor()->shouldStyleWithCSS())

   113         extractTextStyles(mutableStyle.get());

   114 

   115     // Changing the whitespace style in a tab span would collapse the tab into a space.

   116     if (isTabSpanTextNode(position.node()) || isTabSpanNode((position.node())))

   117         mutableStyle->removeProperty(CSSPropertyWhiteSpace);

   118 

   119     // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.

   120     // FIXME: Shouldn't this be done in getPropertiesNotInComputedStyle?

   121     if (mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi) && !style->getPropertyCSSValue(CSSPropertyDirection))

   122         mutableStyle->setProperty(CSSPropertyDirection, style->getPropertyValue(CSSPropertyDirection));

   123 

   124     // Save the result for later

   125     m_cssStyle = mutableStyle->cssText().stripWhiteSpace();

   126 }

   127 

   128 void StyleChange::reconcileTextDecorationProperties(CSSMutableStyleDeclaration* style)

   129 {    

   130     RefPtr<CSSValue> textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);

   131     RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration);

   132     // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.

   133     ASSERT(!textDecorationsInEffect || !textDecoration);

   134     if (textDecorationsInEffect) {

   135         style->setProperty(CSSPropertyTextDecoration, textDecorationsInEffect->cssText());

   136         style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);

   137         textDecoration = textDecorationsInEffect;

   138     }

   139 

   140     // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".

   141     if (textDecoration && !textDecoration->isValueList())

   142         style->removeProperty(CSSPropertyTextDecoration);

   143 }

   144 

   145 static int getIdentifierValue(CSSMutableStyleDeclaration* style, int propertyID)

   146 {

   147     if (!style)

   148         return 0;

   149 

   150     RefPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);

   151     if (!value || !value->isPrimitiveValue())

   152         return 0;

   153 

   154     return static_cast<CSSPrimitiveValue*>(value.get())->getIdent();

   155 }

   156 

   157 static void setTextDecorationProperty(CSSMutableStyleDeclaration* style, const CSSValueList* newTextDecoration, int propertyID)

   158 {

   159     if (newTextDecoration->length())

   160         style->setProperty(propertyID, newTextDecoration->cssText(), style->getPropertyPriority(propertyID));

   161     else {

   162         // text-decoration: none is redundant since it does not remove any text decorations.

   163         ASSERT(!style->getPropertyPriority(propertyID));

   164         style->removeProperty(propertyID);

   165     }

   166 }

   167 

   168 void StyleChange::extractTextStyles(CSSMutableStyleDeclaration* style)

   169 {

   170     ASSERT(style);

   171 

   172     if (getIdentifierValue(style, CSSPropertyFontWeight) == CSSValueBold) {

   173         style->removeProperty(CSSPropertyFontWeight);

   174         m_applyBold = true;

   175     }

   176 

   177     int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);

   178     if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {

   179         style->removeProperty(CSSPropertyFontStyle);

   180         m_applyItalic = true;

   181     }

   182 

   183     // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect

   184     // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.

   185     if (RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(CSSPropertyTextDecoration)) {

   186         ASSERT(textDecoration->isValueList());

   187         DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));

   188         DEFINE_STATIC_LOCAL(RefPtr<CSSPrimitiveValue>, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));

   189 

   190         RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();

   191         if (newTextDecoration->removeAll(underline.get()))

   192             m_applyUnderline = true;

   193         if (newTextDecoration->removeAll(lineThrough.get()))

   194             m_applyLineThrough = true;

   195 

   196         // If trimTextDecorations, delete underline and line-through

   197         setTextDecorationProperty(style, newTextDecoration.get(), CSSPropertyTextDecoration);

   198     }

   199 

   200     int verticalAlign = getIdentifierValue(style, CSSPropertyVerticalAlign);

   201     switch (verticalAlign) {

   202     case CSSValueSub:

   203         style->removeProperty(CSSPropertyVerticalAlign);

   204         m_applySubscript = true;

   205         break;

   206     case CSSValueSuper:

   207         style->removeProperty(CSSPropertyVerticalAlign);

   208         m_applySuperscript = true;

   209         break;

   210     }

   211 

   212     if (RefPtr<CSSValue> colorValue = style->getPropertyCSSValue(CSSPropertyColor)) {

   213         ASSERT(colorValue->isPrimitiveValue());

   214         CSSPrimitiveValue* primitiveColor = static_cast<CSSPrimitiveValue*>(colorValue.get());

   215         RGBA32 rgba = 0;

   216         if (primitiveColor->primitiveType() != CSSPrimitiveValue::CSS_RGBCOLOR) {

   217             CSSParser::parseColor(rgba, colorValue->cssText());

   218             // Need to take care of named color such as green and black

   219             // This code should be removed after https://bugs.webkit.org/show_bug.cgi?id=28282 is fixed.

   220         } else

   221             rgba = primitiveColor->getRGBA32Value();

   222         m_applyFontColor = Color(rgba).name();

   223         style->removeProperty(CSSPropertyColor);

   224     }

   225 

   226     m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);

   227     style->removeProperty(CSSPropertyFontFamily);

   228 

   229     if (RefPtr<CSSValue> fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {

   230         if (!fontSize->isPrimitiveValue())

   231             style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.

   232         else {

   233             CSSPrimitiveValue* value = static_cast<CSSPrimitiveValue*>(fontSize.get());

   234 

   235             // Only accept absolute scale

   236             if (value->primitiveType() >= CSSPrimitiveValue::CSS_PX && value->primitiveType() <= CSSPrimitiveValue::CSS_PC) {

   237                 float number = value->getFloatValue(CSSPrimitiveValue::CSS_PX);

   238                 if (number <= 9)

   239                     m_applyFontSize = "1";

   240                 else if (number <= 10)

   241                     m_applyFontSize = "2";

   242                 else if (number <= 13)

   243                     m_applyFontSize = "3";

   244                 else if (number <= 16)

   245                     m_applyFontSize = "4";

   246                 else if (number <= 18)

   247                     m_applyFontSize = "5";

   248                 else if (number <= 24)

   249                     m_applyFontSize = "6";

   250                 else

   251                     m_applyFontSize = "7";

   252             }

   253             // Huge quirk in Microsoft Entourage is that they understand CSS font-size, but also write 

   254             // out legacy 1-7 values in font tags (I guess for mailers that are not CSS-savvy at all, 

   255             // like Eudora). Yes, they write out *both*. We need to write out both as well.

   256         }

   257     }

   258 }

   259 

   260 static String& styleSpanClassString()

   261 {

   262     DEFINE_STATIC_LOCAL(String, styleSpanClassString, ((AppleStyleSpanClass)));

   263     return styleSpanClassString;

   264 }

   265 

   266 bool isStyleSpan(const Node *node)

   267 {

   268     if (!node || !node->isHTMLElement())

   269         return false;

   270 

   271     const HTMLElement* elem = static_cast<const HTMLElement*>(node);

   272     return elem->hasLocalName(spanAttr) && elem->getAttribute(classAttr) == styleSpanClassString();

   273 }

   274 

   275 static bool isUnstyledStyleSpan(const Node* node)

   276 {

   277     if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))

   278         return false;

   279 

   280     const HTMLElement* elem = static_cast<const HTMLElement*>(node);

   281     CSSMutableStyleDeclaration* inlineStyleDecl = elem->inlineStyleDecl();

   282     return (!inlineStyleDecl || inlineStyleDecl->isEmpty()) && elem->getAttribute(classAttr) == styleSpanClassString();

   283 }

   284 

   285 static bool isSpanWithoutAttributesOrUnstyleStyleSpan(const Node* node)

   286 {

   287     if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))

   288         return false;

   289 

   290     const HTMLElement* elem = static_cast<const HTMLElement*>(node);

   291     NamedNodeMap* attributes = elem->attributes(true); // readonly

   292     if (attributes->isEmpty())

   293         return true;

   294 

   295     return isUnstyledStyleSpan(node);

   296 }

   297 

   298 static bool isEmptyFontTag(const Node *node)

   299 {

   300     if (!node || !node->hasTagName(fontTag))

   301         return false;

   302 

   303     const Element *elem = static_cast<const Element *>(node);

   304     NamedNodeMap *map = elem->attributes(true); // true for read-only

   305     if (!map)

   306         return true;

   307     return map->isEmpty() || (map->length() == 1 && elem->getAttribute(classAttr) == styleSpanClassString());

   308 }

   309 

   310 static PassRefPtr<Element> createFontElement(Document* document)

   311 {

   312     RefPtr<Element> fontNode = createHTMLElement(document, fontTag);

   313     fontNode->setAttribute(classAttr, styleSpanClassString());

   314     return fontNode.release();

   315 }

   316 

   317 PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)

   318 {

   319     RefPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);

   320     styleElement->setAttribute(classAttr, styleSpanClassString());

   321     return styleElement.release();

   322 }

   323 

   324 static void diffTextDecorations(CSSMutableStyleDeclaration* style, int propertID, CSSValue* refTextDecoration)

   325 {

   326     RefPtr<CSSValue> textDecoration = style->getPropertyCSSValue(propertID);

   327     if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())

   328         return;

   329 

   330     RefPtr<CSSValueList> newTextDecoration = static_cast<CSSValueList*>(textDecoration.get())->copy();

   331     CSSValueList* valuesInRefTextDecoration = static_cast<CSSValueList*>(refTextDecoration);

   332 

   333     for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)

   334         newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));

   335 

   336     setTextDecorationProperty(style, newTextDecoration.get(), propertID);

   337 }

   338 

   339 static bool fontWeightIsBold(CSSStyleDeclaration* style)

   340 {

   341     ASSERT(style);

   342     RefPtr<CSSValue> fontWeight = style->getPropertyCSSValue(CSSPropertyFontWeight);

   343 

   344     if (!fontWeight)

   345         return false;

   346     if (!fontWeight->isPrimitiveValue())

   347         return false;

   348 

   349     // Because b tag can only bold text, there are only two states in plain html: bold and not bold.

   350     // Collapse all other values to either one of these two states for editing purposes.

   351     switch (static_cast<CSSPrimitiveValue*>(fontWeight.get())->getIdent()) {

   352         case CSSValue100:

   353         case CSSValue200:

   354         case CSSValue300:

   355         case CSSValue400:

   356         case CSSValue500:

   357         case CSSValueNormal:

   358             return false;

   359         case CSSValueBold:

   360         case CSSValue600:

   361         case CSSValue700:

   362         case CSSValue800:

   363         case CSSValue900:

   364             return true;

   365     }

   366 

   367     ASSERT_NOT_REACHED(); // For CSSValueBolder and CSSValueLighter

   368     return false; // Make compiler happy

   369 }

   370 

   371 RefPtr<CSSMutableStyleDeclaration> getPropertiesNotInComputedStyle(CSSStyleDeclaration* style, CSSComputedStyleDeclaration* computedStyle)

   372 {

   373     ASSERT(style);

   374     ASSERT(computedStyle);

   375     RefPtr<CSSMutableStyleDeclaration> result = style->copy();

   376     computedStyle->diff(result.get());

   377 

   378     RefPtr<CSSValue> computedTextDecorationsInEffect = computedStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);

   379     diffTextDecorations(result.get(), CSSPropertyTextDecoration, computedTextDecorationsInEffect.get());

   380     diffTextDecorations(result.get(), CSSPropertyWebkitTextDecorationsInEffect, computedTextDecorationsInEffect.get());

   381 

   382     if (fontWeightIsBold(result.get()) == fontWeightIsBold(computedStyle))

   383         result->removeProperty(CSSPropertyFontWeight);

   384 

   385     return result;

   386 }

   387 

   388 // Editing style properties must be preserved during editing operation.

   389 // e.g. when a user inserts a new paragraph, all properties listed here must be copied to the new paragraph.

   390 // FIXME: The current editingStyleProperties contains all inheritableProperties but we may not need to preserve all inheritable properties

   391 static const int editingStyleProperties[] = {

   392     // CSS inheritable properties

   393     CSSPropertyBorderCollapse,

   394     CSSPropertyColor,

   395     CSSPropertyFontFamily,

   396     CSSPropertyFontSize,

   397     CSSPropertyFontStyle,

   398     CSSPropertyFontVariant,

   399     CSSPropertyFontWeight,

   400     CSSPropertyLetterSpacing,

   401     CSSPropertyLineHeight,

   402     CSSPropertyOrphans,

   403     CSSPropertyTextAlign,

   404     CSSPropertyTextIndent,

   405     CSSPropertyTextTransform,

   406     CSSPropertyWhiteSpace,

   407     CSSPropertyWidows,

   408     CSSPropertyWordSpacing,

   409     CSSPropertyWebkitBorderHorizontalSpacing,

   410     CSSPropertyWebkitBorderVerticalSpacing,

   411     CSSPropertyWebkitTextDecorationsInEffect,

   412     CSSPropertyWebkitTextFillColor,

   413     CSSPropertyWebkitTextSizeAdjust,

   414     CSSPropertyWebkitTextStrokeColor,

   415     CSSPropertyWebkitTextStrokeWidth,

   416 };

   417 size_t numEditingStyleProperties = sizeof(editingStyleProperties)/sizeof(editingStyleProperties[0]);

   418 

   419 PassRefPtr<CSSMutableStyleDeclaration> ApplyStyleCommand::editingStyleAtPosition(Position pos, ShouldIncludeTypingStyle shouldIncludeTypingStyle)

   420 {

   421     RefPtr<CSSComputedStyleDeclaration> computedStyleAtPosition = pos.computedStyle();

   422     RefPtr<CSSMutableStyleDeclaration> style;

   423     if (!computedStyleAtPosition)

   424         style = CSSMutableStyleDeclaration::create();

   425     else

   426         style = computedStyleAtPosition->copyPropertiesInSet(editingStyleProperties, numEditingStyleProperties);

   427 

   428     if (style && pos.node() && pos.node()->computedStyle()) {

   429         RenderStyle* renderStyle = pos.node()->computedStyle();

   430         // If a node's text fill color is invalid, then its children use 

   431         // their font-color as their text fill color (they don't

   432         // inherit it).  Likewise for stroke color.

   433         ExceptionCode ec = 0;

   434         if (!renderStyle->textFillColor().isValid())

   435             style->removeProperty(CSSPropertyWebkitTextFillColor, ec);

   436         if (!renderStyle->textStrokeColor().isValid())

   437             style->removeProperty(CSSPropertyWebkitTextStrokeColor, ec);

   438         ASSERT(ec == 0);

   439         if (renderStyle->fontDescription().keywordSize())

   440             style->setProperty(CSSPropertyFontSize, computedStyleAtPosition->getFontSizeCSSValuePreferringKeyword()->cssText());

   441     }

   442 

   443     if (shouldIncludeTypingStyle == IncludeTypingStyle) {

   444         CSSMutableStyleDeclaration* typingStyle = pos.node()->document()->frame()->typingStyle();

   445         if (typingStyle)

   446             style->merge(typingStyle);

   447     }

   448 

   449     return style.release();

   450 }

   451 

   452 void prepareEditingStyleToApplyAt(CSSMutableStyleDeclaration* editingStyle, Position pos)

   453 {

   454     // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.

   455     // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate

   456     // which one of editingStyleAtPosition or computedStyle is called.

   457     RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(pos);

   458     style->diff(editingStyle);

   459 

   460     // if alpha value is zero, we don't add the background color.

   461     RefPtr<CSSValue> backgroundColor = editingStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);

   462     if (backgroundColor && backgroundColor->isPrimitiveValue()) {

   463         CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(backgroundColor.get());

   464         Color color = Color(primitiveValue->getRGBA32Value());

   465         ExceptionCode ec;

   466         if (color.alpha() == 0)

   467             editingStyle->removeProperty(CSSPropertyBackgroundColor, ec);

   468     }

   469 }

   470 

   471 void removeStylesAddedByNode(CSSMutableStyleDeclaration* editingStyle, Node* node)

   472 {

   473     ASSERT(node);

   474     ASSERT(node->parentNode());

   475     RefPtr<CSSMutableStyleDeclaration> parentStyle = ApplyStyleCommand::editingStyleAtPosition(Position(node->parentNode(), 0));

   476     RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(Position(node, 0));

   477     parentStyle->diff(style.get());

   478     style->diff(editingStyle);

   479 }

   480     

   481 ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, EditAction editingAction, EPropertyLevel propertyLevel)

   482     : CompositeEditCommand(document)

   483     , m_style(style->makeMutable())

   484     , m_editingAction(editingAction)

   485     , m_propertyLevel(propertyLevel)

   486     , m_start(endingSelection().start().downstream())

   487     , m_end(endingSelection().end().upstream())

   488     , m_useEndingSelection(true)

   489     , m_styledInlineElement(0)

   490     , m_removeOnly(false)

   491 {

   492 }

   493 

   494 ApplyStyleCommand::ApplyStyleCommand(Document* document, CSSStyleDeclaration* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)

   495     : CompositeEditCommand(document)

   496     , m_style(style->makeMutable())

   497     , m_editingAction(editingAction)

   498     , m_propertyLevel(propertyLevel)

   499     , m_start(start)

   500     , m_end(end)

   501     , m_useEndingSelection(false)

   502     , m_styledInlineElement(0)

   503     , m_removeOnly(false)

   504 {

   505 }

   506 

   507 ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)

   508     : CompositeEditCommand(element->document())

   509     , m_style(CSSMutableStyleDeclaration::create())

   510     , m_editingAction(editingAction)

   511     , m_propertyLevel(PropertyDefault)

   512     , m_start(endingSelection().start().downstream())

   513     , m_end(endingSelection().end().upstream())

   514     , m_useEndingSelection(true)

   515     , m_styledInlineElement(element)

   516     , m_removeOnly(removeOnly)

   517 {

   518 }

   519 

   520 void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)

   521 {

   522     ASSERT(comparePositions(newEnd, newStart) >= 0);

   523 

   524     if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))

   525         m_useEndingSelection = true;

   526 

   527     setEndingSelection(VisibleSelection(newStart, newEnd, VP_DEFAULT_AFFINITY));

   528     m_start = newStart;

   529     m_end = newEnd;

   530 }

   531 

   532 Position ApplyStyleCommand::startPosition()

   533 {

   534     if (m_useEndingSelection)

   535         return endingSelection().start();

   536     

   537     return m_start;

   538 }

   539 

   540 Position ApplyStyleCommand::endPosition()

   541 {

   542     if (m_useEndingSelection)

   543         return endingSelection().end();

   544     

   545     return m_end;

   546 }

   547 

   548 void ApplyStyleCommand::doApply()

   549 {

   550     switch (m_propertyLevel) {

   551         case PropertyDefault: {

   552             // apply the block-centric properties of the style

   553             RefPtr<CSSMutableStyleDeclaration> blockStyle = m_style->copyBlockProperties();

   554             if (blockStyle->length())

   555                 applyBlockStyle(blockStyle.get());

   556             // apply any remaining styles to the inline elements

   557             // NOTE: hopefully, this string comparison is the same as checking for a non-null diff

   558             if (blockStyle->length() < m_style->length() || m_styledInlineElement) {

   559                 RefPtr<CSSMutableStyleDeclaration> inlineStyle = m_style->copy();

   560                 applyRelativeFontStyleChange(inlineStyle.get());

   561                 blockStyle->diff(inlineStyle.get());

   562                 applyInlineStyle(inlineStyle.get());

   563             }

   564             break;

   565         }

   566         case ForceBlockProperties:

   567             // Force all properties to be applied as block styles.

   568             applyBlockStyle(m_style.get());

   569             break;

   570     }

   571 }

   572 

   573 EditAction ApplyStyleCommand::editingAction() const

   574 {

   575     return m_editingAction;

   576 }

   577 

   578 void ApplyStyleCommand::applyBlockStyle(CSSMutableStyleDeclaration *style)

   579 {

   580     // update document layout once before removing styles

   581     // so that we avoid the expense of updating before each and every call

   582     // to check a computed style

   583     updateLayout();

   584 

   585     // get positions we want to use for applying style

   586     Position start = startPosition();

   587     Position end = endPosition();

   588     if (comparePositions(end, start) < 0) {

   589         Position swap = start;

   590         start = end;

   591         end = swap;

   592     }

   593         

   594     VisiblePosition visibleStart(start);

   595     VisiblePosition visibleEnd(end);

   596     // Save and restore the selection endpoints using their indices in the document, since

   597     // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.

   598     // Calculate start and end indices from the start of the tree that they're in.

   599     Node* scope = highestAncestor(visibleStart.deepEquivalent().node());

   600     Position rangeStart(scope, 0);

   601     RefPtr<Range> startRange = Range::create(document(), rangeStart, rangeCompliantEquivalent(visibleStart.deepEquivalent()));

   602     RefPtr<Range> endRange = Range::create(document(), rangeStart, rangeCompliantEquivalent(visibleEnd.deepEquivalent()));

   603     int startIndex = TextIterator::rangeLength(startRange.get(), true);

   604     int endIndex = TextIterator::rangeLength(endRange.get(), true);

   605     

   606     VisiblePosition paragraphStart(startOfParagraph(visibleStart));

   607     VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());

   608     VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());

   609     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {

   610         StyleChange styleChange(style, paragraphStart.deepEquivalent());

   611         if (styleChange.cssStyle().length() || m_removeOnly) {

   612             RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().node());

   613             RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());

   614             if (newBlock)

   615                 block = newBlock;

   616             ASSERT(block->isHTMLElement());

   617             if (block->isHTMLElement()) {

   618                 removeCSSStyle(style, static_cast<HTMLElement*>(block.get()));

   619                 if (!m_removeOnly)

   620                     addBlockStyle(styleChange, static_cast<HTMLElement*>(block.get()));

   621             }

   622 

   623             if (nextParagraphStart.isOrphan())

   624                 nextParagraphStart = endOfParagraph(paragraphStart).next();

   625         }

   626 

   627         paragraphStart = nextParagraphStart;

   628         nextParagraphStart = endOfParagraph(paragraphStart).next();

   629     }

   630     

   631     startRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), startIndex, 0, true);

   632     endRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), endIndex, 0, true);

   633     if (startRange && endRange)

   634         updateStartEnd(startRange->startPosition(), endRange->startPosition());

   635 }

   636 

   637 #define NoFontDelta (0.0f)

   638 #define MinimumFontSize (0.1f)

   639 

   640 void ApplyStyleCommand::applyRelativeFontStyleChange(CSSMutableStyleDeclaration *style)

   641 {

   642     RefPtr<CSSValue> value = style->getPropertyCSSValue(CSSPropertyFontSize);

   643     if (value) {

   644         // Explicit font size overrides any delta.

   645         style->removeProperty(CSSPropertyWebkitFontSizeDelta);

   646         return;

   647     }

   648 

   649     // Get the adjustment amount out of the style.

   650     value = style->getPropertyCSSValue(CSSPropertyWebkitFontSizeDelta);

   651     if (!value)

   652         return;

   653     float adjustment = NoFontDelta;

   654     if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {

   655         CSSPrimitiveValue *primitiveValue = static_cast<CSSPrimitiveValue *>(value.get());

   656         if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_PX) {

   657             // Only PX handled now. If we handle more types in the future, perhaps

   658             // a switch statement here would be more appropriate.

   659             adjustment = primitiveValue->getFloatValue();

   660         }

   661     }

   662     style->removeProperty(CSSPropertyWebkitFontSizeDelta);

   663     if (adjustment == NoFontDelta)

   664         return;

   665     

   666     Position start = startPosition();

   667     Position end = endPosition();

   668     if (comparePositions(end, start) < 0) {

   669         Position swap = start;

   670         start = end;

   671         end = swap;

   672     }

   673     

   674     // Join up any adjacent text nodes.

   675     if (start.node()->isTextNode()) {

   676         joinChildTextNodes(start.node()->parentNode(), start, end);

   677         start = startPosition();

   678         end = endPosition();

   679     }

   680     if (end.node()->isTextNode() && start.node()->parentNode() != end.node()->parentNode()) {

   681         joinChildTextNodes(end.node()->parentNode(), start, end);

   682         start = startPosition();

   683         end = endPosition();

   684     }

   685 

   686     // Split the start text nodes if needed to apply style.

   687     bool splitStart = splitTextAtStartIfNeeded(start, end); 

   688     if (splitStart) {

   689         start = startPosition();

   690         end = endPosition();

   691     }

   692     bool splitEnd = splitTextAtEndIfNeeded(start, end);

   693     if (splitEnd) {

   694         start = startPosition();

   695         end = endPosition();

   696     }

   697 

   698     // Calculate loop end point.

   699     // If the end node is before the start node (can only happen if the end node is

   700     // an ancestor of the start node), we gather nodes up to the next sibling of the end node

   701     Node *beyondEnd;

   702     if (start.node()->isDescendantOf(end.node()))

   703         beyondEnd = end.node()->traverseNextSibling();

   704     else

   705         beyondEnd = end.node()->traverseNextNode();

   706     

   707     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.

   708     Node *startNode = start.node();

   709     if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.

   710         startNode = startNode->traverseNextNode();

   711 

   712     // Store away font size before making any changes to the document.

   713     // This ensures that changes to one node won't effect another.

   714     HashMap<Node*, float> startingFontSizes;

   715     for (Node *node = startNode; node != beyondEnd; node = node->traverseNextNode())

   716         startingFontSizes.set(node, computedFontSize(node));

   717 

   718     // These spans were added by us. If empty after font size changes, they can be removed.

   719     Vector<RefPtr<HTMLElement> > unstyledSpans;

   720     

   721     Node* lastStyledNode = 0;

   722     for (Node* node = startNode; node != beyondEnd; node = node->traverseNextNode()) {

   723         RefPtr<HTMLElement> element;

   724         if (node->isHTMLElement()) {

   725             // Only work on fully selected nodes.

   726             if (!nodeFullySelected(node, start, end))

   727                 continue;

   728             element = static_cast<HTMLElement*>(node);

   729         } else if (node->isTextNode() && node->renderer() && node->parentNode() != lastStyledNode) {

   730             // Last styled node was not parent node of this text node, but we wish to style this

   731             // text node. To make this possible, add a style span to surround this text node.

   732             RefPtr<HTMLElement> span = createStyleSpanElement(document());

   733             surroundNodeRangeWithElement(node, node, span.get());

   734             element = span.release();

   735         }  else {

   736             // Only handle HTML elements and text nodes.

   737             continue;

   738         }

   739         lastStyledNode = node;

   740 

   741         CSSMutableStyleDeclaration* inlineStyleDecl = element->getInlineStyleDecl();

   742         float currentFontSize = computedFontSize(node);

   743         float desiredFontSize = max(MinimumFontSize, startingFontSizes.get(node) + adjustment);

   744         RefPtr<CSSValue> value = inlineStyleDecl->getPropertyCSSValue(CSSPropertyFontSize);

   745         if (value) {

   746             inlineStyleDecl->removeProperty(CSSPropertyFontSize, true);

   747             currentFontSize = computedFontSize(node);

   748         }

   749         if (currentFontSize != desiredFontSize) {

   750             inlineStyleDecl->setProperty(CSSPropertyFontSize, String::number(desiredFontSize) + "px", false, false);

   751             setNodeAttribute(element.get(), styleAttr, inlineStyleDecl->cssText());

   752         }

   753         if (inlineStyleDecl->isEmpty()) {

   754             removeNodeAttribute(element.get(), styleAttr);

   755             // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan?  Need a test.

   756             if (isUnstyledStyleSpan(element.get()))

   757                 unstyledSpans.append(element.release());

   758         }

   759     }

   760 

   761     size_t size = unstyledSpans.size();

   762     for (size_t i = 0; i < size; ++i)

   763         removeNodePreservingChildren(unstyledSpans[i].get());

   764 }

   765 

   766 #undef NoFontDelta

   767 #undef MinimumFontSize

   768 

   769 static Node* dummySpanAncestorForNode(const Node* node)

   770 {

   771     while (node && !isStyleSpan(node))

   772         node = node->parent();

   773     

   774     return node ? node->parent() : 0;

   775 }

   776 

   777 void ApplyStyleCommand::cleanupUnstyledAppleStyleSpans(Node* dummySpanAncestor)

   778 {

   779     if (!dummySpanAncestor)

   780         return;

   781 

   782     // Dummy spans are created when text node is split, so that style information

   783     // can be propagated, which can result in more splitting. If a dummy span gets

   784     // cloned/split, the new node is always a sibling of it. Therefore, we scan

   785     // all the children of the dummy's parent

   786     Node* next;

   787     for (Node* node = dummySpanAncestor->firstChild(); node; node = next) {

   788         next = node->nextSibling();

   789         if (isUnstyledStyleSpan(node))

   790             removeNodePreservingChildren(node);

   791         node = next;

   792     }

   793 }

   794 

   795 HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool before, RefPtr<CSSPrimitiveValue> allowedDirection)

   796 {

   797     // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.

   798     // In that case, we return the unsplit ancestor. Otherwise, we return 0.

   799     Node* block = enclosingBlock(node);

   800     if (!block)

   801         return 0;

   802 

   803     Node* highestAncestorWithUnicodeBidi = 0;

   804     Node* nextHighestAncestorWithUnicodeBidi = 0;

   805     RefPtr<CSSPrimitiveValue> highestAncestorUnicodeBidi;

   806     for (Node* n = node->parent(); n != block; n = n->parent()) {

   807         RefPtr<CSSValue> unicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);

   808         if (unicodeBidi) {

   809             ASSERT(unicodeBidi->isPrimitiveValue());

   810             if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() != CSSValueNormal) {

   811                 highestAncestorUnicodeBidi = static_cast<CSSPrimitiveValue*>(unicodeBidi.get());

   812                 nextHighestAncestorWithUnicodeBidi = highestAncestorWithUnicodeBidi;

   813                 highestAncestorWithUnicodeBidi = n;

   814             }

   815         }

   816     }

   817 

   818     if (!highestAncestorWithUnicodeBidi)

   819         return 0;

   820 

   821     HTMLElement* unsplitAncestor = 0;

   822 

   823     if (allowedDirection && highestAncestorUnicodeBidi->getIdent() != CSSValueBidiOverride) {

   824         RefPtr<CSSValue> highestAncestorDirection = computedStyle(highestAncestorWithUnicodeBidi)->getPropertyCSSValue(CSSPropertyDirection);

   825         ASSERT(highestAncestorDirection->isPrimitiveValue());

   826         if (static_cast<CSSPrimitiveValue*>(highestAncestorDirection.get())->getIdent() == allowedDirection->getIdent() && highestAncestorWithUnicodeBidi->isHTMLElement()) {

   827             if (!nextHighestAncestorWithUnicodeBidi)

   828                 return static_cast<HTMLElement*>(highestAncestorWithUnicodeBidi);

   829 

   830             unsplitAncestor = static_cast<HTMLElement*>(highestAncestorWithUnicodeBidi);

   831             highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;

   832         }

   833     }

   834 

   835     // Split every ancestor through highest ancestor with embedding.

   836     Node* n = node;

   837     while (true) {

   838         Element* parent = static_cast<Element*>(n->parent());

   839         if (before ? n->previousSibling() : n->nextSibling())

   840             splitElement(parent, before ? n : n->nextSibling());

   841         if (parent == highestAncestorWithUnicodeBidi)

   842             break;

   843         n = n->parent();

   844     }

   845     return unsplitAncestor;

   846 }

   847 

   848 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, Node* unsplitAncestor)

   849 {

   850     Node* block = enclosingBlock(node);

   851     if (!block)

   852         return;

   853 

   854     Node* n = node->parent();

   855     while (n != block && n != unsplitAncestor) {

   856         Node* parent = n->parent();

   857         if (!n->isStyledElement()) {

   858             n = parent;

   859             continue;

   860         }

   861 

   862         StyledElement* element = static_cast<StyledElement*>(n);

   863         RefPtr<CSSValue> unicodeBidi = computedStyle(element)->getPropertyCSSValue(CSSPropertyUnicodeBidi);

   864         if (unicodeBidi) {

   865             ASSERT(unicodeBidi->isPrimitiveValue());

   866             if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() != CSSValueNormal) {

   867                 // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,

   868                 // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.

   869                 // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and

   870                 // otherwise it sets the property in the inline style declaration.

   871                 if (element->hasAttribute(dirAttr)) {

   872                     // FIXME: If this is a BDO element, we should probably just remove it if it has no

   873                     // other attributes, like we (should) do with B and I elements.

   874                     removeNodeAttribute(element, dirAttr);

   875                 } else {

   876                     RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->getInlineStyleDecl()->copy();

   877                     inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);

   878                     inlineStyle->removeProperty(CSSPropertyDirection);

   879                     setNodeAttribute(element, styleAttr, inlineStyle->cssText());

   880                     // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan?  Need a test.

   881                     if (isUnstyledStyleSpan(element))

   882                         removeNodePreservingChildren(element);

   883                 }

   884             }

   885         }

   886         n = parent;

   887     }

   888 }

   889 

   890 void ApplyStyleCommand::applyInlineStyle(CSSMutableStyleDeclaration *style)

   891 {

   892     Node* startDummySpanAncestor = 0;

   893     Node* endDummySpanAncestor = 0;

   894     

   895     // update document layout once before removing styles

   896     // so that we avoid the expense of updating before each and every call

   897     // to check a computed style

   898     updateLayout();

   899 

   900     // adjust to the positions we want to use for applying style

   901     Position start = startPosition();

   902     Position end = endPosition();

   903     if (comparePositions(end, start) < 0) {

   904         Position swap = start;

   905         start = end;

   906         end = swap;

   907     }

   908 

   909     // split the start node and containing element if the selection starts inside of it

   910     bool splitStart = splitTextElementAtStartIfNeeded(start, end); 

   911     if (splitStart) {

   912         start = startPosition();

   913         end = endPosition();

   914         startDummySpanAncestor = dummySpanAncestorForNode(start.node());

   915     }

   916 

   917     // split the end node and containing element if the selection ends inside of it

   918     bool splitEnd = splitTextElementAtEndIfNeeded(start, end);

   919     if (splitEnd) {

   920         start = startPosition();

   921         end = endPosition();

   922         endDummySpanAncestor = dummySpanAncestorForNode(end.node());

   923     }

   924 

   925     RefPtr<CSSValue> unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);

   926     RefPtr<CSSValue> direction;

   927     HTMLElement* startUnsplitAncestor = 0;

   928     HTMLElement* endUnsplitAncestor = 0;

   929     if (unicodeBidi) {

   930         RefPtr<CSSPrimitiveValue> allowedDirection;

   931         ASSERT(unicodeBidi->isPrimitiveValue());

   932         if (static_cast<CSSPrimitiveValue*>(unicodeBidi.get())->getIdent() == CSSValueEmbed) {

   933             // Leave alone an ancestor that provides the desired single level embedding, if there is one.

   934             direction = style->getPropertyCSSValue(CSSPropertyDirection);

   935             ASSERT(direction->isPrimitiveValue());

   936             allowedDirection = static_cast<CSSPrimitiveValue*>(direction.get());

   937         }

   938         startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.node(), true, allowedDirection);

   939         endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.node(), false, allowedDirection);

   940         removeEmbeddingUpToEnclosingBlock(start.node(), startUnsplitAncestor);

   941         removeEmbeddingUpToEnclosingBlock(end.node(), endUnsplitAncestor);

   942     }

   943 

   944     // Remove style from the selection.

   945     // Use the upstream position of the start for removing style.

   946     // This will ensure we remove all traces of the relevant styles from the selection

   947     // and prevent us from adding redundant ones, as described in:

   948     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags

   949     Position removeStart = start.upstream();

   950     Position embeddingRemoveStart = removeStart;

   951     Position embeddingRemoveEnd = end;

   952     if (unicodeBidi) {

   953         // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.

   954         if (startUnsplitAncestor && nodeFullySelected(startUnsplitAncestor, removeStart, end))

   955             embeddingRemoveStart = positionInParentAfterNode(startUnsplitAncestor);

   956         if (endUnsplitAncestor && nodeFullySelected(endUnsplitAncestor, removeStart, end))

   957             embeddingRemoveEnd = positionInParentBeforeNode(endUnsplitAncestor).downstream();

   958     }

   959 

   960     if (embeddingRemoveStart != removeStart || embeddingRemoveEnd != end) {

   961         RefPtr<CSSMutableStyleDeclaration> embeddingStyle = CSSMutableStyleDeclaration::create();

   962         embeddingStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);

   963         embeddingStyle->setProperty(CSSPropertyDirection, static_cast<CSSPrimitiveValue*>(direction.get())->getIdent());

   964         if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0)

   965             removeInlineStyle(embeddingStyle, embeddingRemoveStart, embeddingRemoveEnd);

   966 

   967         RefPtr<CSSMutableStyleDeclaration> styleWithoutEmbedding = style->copy();

   968         styleWithoutEmbedding->removeProperty(CSSPropertyUnicodeBidi);

   969         styleWithoutEmbedding->removeProperty(CSSPropertyDirection);

   970         removeInlineStyle(styleWithoutEmbedding, removeStart, end);

   971     } else

   972         removeInlineStyle(style, removeStart, end);

   973 

   974     start = startPosition();

   975     end = endPosition();

   976 

   977     if (splitStart) {

   978         bool mergedStart = mergeStartWithPreviousIfIdentical(start, end);

   979         if (mergedStart) {

   980             start = startPosition();

   981             end = endPosition();

   982         }

   983     }

   984 

   985     if (splitEnd) {

   986         mergeEndWithNextIfIdentical(start, end);

   987         start = startPosition();

   988         end = endPosition();

   989     }

   990 

   991     // update document layout once before running the rest of the function

   992     // so that we avoid the expense of updating before each and every call

   993     // to check a computed style

   994     updateLayout();

   995 

   996     Position embeddingApplyStart = start;

   997     Position embeddingApplyEnd = end;

   998     if (unicodeBidi) {

   999         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.

  1000         Node* startEnclosingBlock = enclosingBlock(start.node());

  1001         for (Node* n = start.node(); n != startEnclosingBlock; n = n->parent()) {

  1002             if (n->isHTMLElement()) {

  1003                 RefPtr<CSSValue> ancestorUnicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);

  1004                 if (ancestorUnicodeBidi) {

  1005                     ASSERT(ancestorUnicodeBidi->isPrimitiveValue());

  1006                     if (static_cast<CSSPrimitiveValue*>(ancestorUnicodeBidi.get())->getIdent() == CSSValueEmbed) {

  1007                         embeddingApplyStart = positionInParentAfterNode(n);

  1008                         break;

  1009                     }

  1010                 }

  1011             }

  1012         }

  1013 

  1014         Node* endEnclosingBlock = enclosingBlock(end.node());

  1015         for (Node* n = end.node(); n != endEnclosingBlock; n = n->parent()) {

  1016             if (n->isHTMLElement()) {

  1017                 RefPtr<CSSValue> ancestorUnicodeBidi = computedStyle(n)->getPropertyCSSValue(CSSPropertyUnicodeBidi);

  1018                 if (ancestorUnicodeBidi) {

  1019                     ASSERT(ancestorUnicodeBidi->isPrimitiveValue());

  1020                     if (static_cast<CSSPrimitiveValue*>(ancestorUnicodeBidi.get())->getIdent() == CSSValueEmbed) {

  1021                         embeddingApplyEnd = positionInParentBeforeNode(n);

  1022                         break;

  1023                     }

  1024                 }

  1025             }

  1026         }

  1027     }

  1028 

  1029     if (embeddingApplyStart != start || embeddingApplyEnd != end) {

  1030         if (embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull()) {

  1031             RefPtr<CSSMutableStyleDeclaration> embeddingStyle = CSSMutableStyleDeclaration::create();

  1032             embeddingStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed);

  1033             embeddingStyle->setProperty(CSSPropertyDirection, static_cast<CSSPrimitiveValue*>(direction.get())->getIdent());

  1034             applyInlineStyleToRange(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd);

  1035         }

  1036 

  1037         RefPtr<CSSMutableStyleDeclaration> styleWithoutEmbedding = style->copy();

  1038         styleWithoutEmbedding->removeProperty(CSSPropertyUnicodeBidi);

  1039         styleWithoutEmbedding->removeProperty(CSSPropertyDirection);

  1040         applyInlineStyleToRange(styleWithoutEmbedding.get(), start, end);

  1041     } else

  1042         applyInlineStyleToRange(style, start, end);

  1043 

  1044     // Remove dummy style spans created by splitting text elements.

  1045     cleanupUnstyledAppleStyleSpans(startDummySpanAncestor);

  1046     if (endDummySpanAncestor != startDummySpanAncestor)

  1047         cleanupUnstyledAppleStyleSpans(endDummySpanAncestor);

  1048 }

  1049 

  1050 void ApplyStyleCommand::applyInlineStyleToRange(CSSMutableStyleDeclaration* style, const Position& start, const Position& rangeEnd)

  1051 {

  1052     Node* node = start.node();

  1053     Position end = rangeEnd;

  1054 

  1055     bool rangeIsEmpty = false;

  1056 

  1057     if (start.deprecatedEditingOffset() >= caretMaxOffset(start.node())) {

  1058         node = node->traverseNextNode();

  1059         Position newStart = Position(node, 0);

  1060         if (!node || comparePositions(end, newStart) < 0)

  1061             rangeIsEmpty = true;

  1062     }

  1063 

  1064     if (!rangeIsEmpty) {

  1065         // pastEndNode is the node after the last fully selected node.

  1066         Node* pastEndNode = end.node();

  1067         if (end.deprecatedEditingOffset() >= caretMaxOffset(end.node()))

  1068             pastEndNode = end.node()->traverseNextSibling();

  1069         // FIXME: Callers should perform this operation on a Range that includes the br

  1070         // if they want style applied to the empty line.

  1071         if (start == end && start.node()->hasTagName(brTag))

  1072             pastEndNode = start.node()->traverseNextNode();

  1073         // Add the style to selected inline runs.

  1074         for (Node* next; node && node != pastEndNode; node = next) {

  1075             

  1076             next = node->traverseNextNode();

  1077             

  1078             if (!node->renderer() || !node->isContentEditable())

  1079                 continue;

  1080             

  1081             if (!node->isContentRichlyEditable() && node->isHTMLElement()) {

  1082                 // This is a plaintext-only region. Only proceed if it's fully selected.

  1083                 // pastEndNode is the node after the last fully selected node, so if it's inside node then

  1084                 // node isn't fully selected.

  1085                 if (pastEndNode && pastEndNode->isDescendantOf(node))

  1086                     break;

  1087                 // Add to this element's inline style and skip over its contents.

  1088                 HTMLElement* element = static_cast<HTMLElement*>(node);

  1089                 RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->getInlineStyleDecl()->copy();

  1090                 inlineStyle->merge(style);

  1091                 setNodeAttribute(element, styleAttr, inlineStyle->cssText());

  1092                 next = node->traverseNextSibling();

  1093                 continue;

  1094             }

  1095         

  1096             if (isBlock(node))

  1097                 continue;

  1098                 

  1099             if (node->childNodeCount()) {

  1100                 if (editingIgnoresContent(node)) {

  1101                     next = node->traverseNextSibling();

  1102                     continue;

  1103                 }

  1104                 continue;

  1105             }

  1106             

  1107             Node* runStart = node;

  1108             // Find the end of the run.

  1109             Node* sibling = node->nextSibling();

  1110             while (sibling && sibling != pastEndNode && (!sibling->isElementNode() || sibling->hasTagName(brTag)) && !isBlock(sibling)) {

  1111                 node = sibling;

  1112                 sibling = node->nextSibling();

  1113             }

  1114             // Recompute next, since node has changed.

  1115             next = node->traverseNextNode();

  1116             // Apply the style to the run.

  1117             addInlineStyleIfNeeded(style, runStart, node);

  1118         }

  1119     }

  1120 }

  1121 

  1122 bool ApplyStyleCommand::shouldRemoveTextDecorationTag(CSSStyleDeclaration* styleToApply, int textDecorationAddedByTag) const

  1123 {

  1124     // Honor text-decorations-in-effect

  1125     RefPtr<CSSValue> textDecorationsToApply = styleToApply->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);

  1126     if (!textDecorationsToApply || !textDecorationsToApply->isValueList())

  1127         textDecorationsToApply = styleToApply->getPropertyCSSValue(CSSPropertyTextDecoration);

  1128 

  1129     // When there is no text decorations to apply, remove any one of u, s, & strike

  1130     if (!textDecorationsToApply || !textDecorationsToApply->isValueList())

  1131         return true;

  1132 

  1133     // Remove node if it implicitly adds style not present in styleToApply

  1134     CSSValueList* valueList = static_cast<CSSValueList*>(textDecorationsToApply.get());

  1135     RefPtr<CSSPrimitiveValue> value = CSSPrimitiveValue::createIdentifier(textDecorationAddedByTag);