41735c55824977297f4506cbd0827288f52c962f
[WebKit-https.git] / Source / WebCore / editing / ApplyStyleCommand.cpp
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 "CSSStyleSelector.h"
35 #include "CSSValueKeywords.h"
36 #include "CSSValueList.h"
37 #include "Document.h"
38 #include "EditingStyle.h"
39 #include "Editor.h"
40 #include "Frame.h"
41 #include "HTMLFontElement.h"
42 #include "HTMLInterchange.h"
43 #include "HTMLNames.h"
44 #include "NodeList.h"
45 #include "Range.h"
46 #include "RenderObject.h"
47 #include "RenderText.h"
48 #include "Text.h"
49 #include "TextIterator.h"
50 #include "htmlediting.h"
51 #include "visible_units.h"
52 #include <wtf/StdLibExtras.h>
53
54 namespace WebCore {
55
56 using namespace HTMLNames;
57
58 static String& styleSpanClassString()
59 {
60     DEFINE_STATIC_LOCAL(String, styleSpanClassString, ((AppleStyleSpanClass)));
61     return styleSpanClassString;
62 }
63
64 bool isLegacyAppleStyleSpan(const Node *node)
65 {
66     if (!node || !node->isHTMLElement())
67         return false;
68
69     const HTMLElement* elem = static_cast<const HTMLElement*>(node);
70     return elem->hasLocalName(spanAttr) && elem->getAttribute(classAttr) == styleSpanClassString();
71 }
72
73 enum ShouldStyleAttributeBeEmpty { AllowNonEmptyStyleAttribute, StyleAttributeShouldBeEmpty };
74 static bool hasNoAttributeOrOnlyStyleAttribute(const StyledElement* element, ShouldStyleAttributeBeEmpty shouldStyleAttributeBeEmpty)
75 {
76     const bool readonly = true;
77     NamedNodeMap* map = element->attributes(readonly);
78     if (!map || map->isEmpty())
79         return true;
80
81     unsigned matchedAttributes = 0;
82     if (element->getAttribute(classAttr) == styleSpanClassString())
83         matchedAttributes++;
84     if (element->hasAttribute(styleAttr) && (shouldStyleAttributeBeEmpty == AllowNonEmptyStyleAttribute
85         || !element->inlineStyleDecl() || element->inlineStyleDecl()->isEmpty()))
86         matchedAttributes++;
87
88     ASSERT(matchedAttributes <= map->length());
89     return matchedAttributes == map->length();
90 }
91
92 bool isStyleSpanOrSpanWithOnlyStyleAttribute(const Element* element)
93 {
94     if (!element || !element->hasTagName(spanTag))
95         return false;
96     return hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(element), AllowNonEmptyStyleAttribute);
97 }
98
99 static inline bool isSpanWithoutAttributesOrUnstyledStyleSpan(const Node* node)
100 {
101     if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))
102         return false;
103     return hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(node), StyleAttributeShouldBeEmpty);
104 }
105
106 static bool isEmptyFontTag(const Node *node)
107 {
108     if (!node || !node->hasTagName(fontTag))
109         return false;
110
111     const Element *elem = static_cast<const Element *>(node);
112     NamedNodeMap *map = elem->attributes(true); // true for read-only
113     if (!map)
114         return true;
115     return map->isEmpty() || (map->length() == 1 && elem->getAttribute(classAttr) == styleSpanClassString());
116 }
117
118 static PassRefPtr<Element> createFontElement(Document* document)
119 {
120     RefPtr<Element> fontNode = createHTMLElement(document, fontTag);
121     return fontNode.release();
122 }
123
124 PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)
125 {
126     RefPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);
127     return styleElement.release();
128 }
129
130 ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, EditAction editingAction, EPropertyLevel propertyLevel)
131     : CompositeEditCommand(document)
132     , m_style(style->copy())
133     , m_editingAction(editingAction)
134     , m_propertyLevel(propertyLevel)
135     , m_start(endingSelection().start().downstream())
136     , m_end(endingSelection().end().upstream())
137     , m_useEndingSelection(true)
138     , m_styledInlineElement(0)
139     , m_removeOnly(false)
140     , m_isInlineElementToRemoveFunction(0)
141 {
142 }
143
144 ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction, EPropertyLevel propertyLevel)
145     : CompositeEditCommand(document)
146     , m_style(style->copy())
147     , m_editingAction(editingAction)
148     , m_propertyLevel(propertyLevel)
149     , m_start(start)
150     , m_end(end)
151     , m_useEndingSelection(false)
152     , m_styledInlineElement(0)
153     , m_removeOnly(false)
154     , m_isInlineElementToRemoveFunction(0)
155 {
156 }
157
158 ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)
159     : CompositeEditCommand(element->document())
160     , m_style(EditingStyle::create())
161     , m_editingAction(editingAction)
162     , m_propertyLevel(PropertyDefault)
163     , m_start(endingSelection().start().downstream())
164     , m_end(endingSelection().end().upstream())
165     , m_useEndingSelection(true)
166     , m_styledInlineElement(element)
167     , m_removeOnly(removeOnly)
168     , m_isInlineElementToRemoveFunction(0)
169 {
170 }
171
172 ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, IsInlineElementToRemoveFunction isInlineElementToRemoveFunction, EditAction editingAction)
173     : CompositeEditCommand(document)
174     , m_style(style->copy())
175     , m_editingAction(editingAction)
176     , m_propertyLevel(PropertyDefault)
177     , m_start(endingSelection().start().downstream())
178     , m_end(endingSelection().end().upstream())
179     , m_useEndingSelection(true)
180     , m_styledInlineElement(0)
181     , m_removeOnly(true)
182     , m_isInlineElementToRemoveFunction(isInlineElementToRemoveFunction)
183 {
184 }
185
186 void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)
187 {
188     ASSERT(comparePositions(newEnd, newStart) >= 0);
189
190     if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))
191         m_useEndingSelection = true;
192
193     setEndingSelection(VisibleSelection(newStart, newEnd, VP_DEFAULT_AFFINITY, endingSelection().isDirectional()));
194     m_start = newStart;
195     m_end = newEnd;
196 }
197
198 Position ApplyStyleCommand::startPosition()
199 {
200     if (m_useEndingSelection)
201         return endingSelection().start();
202     
203     return m_start;
204 }
205
206 Position ApplyStyleCommand::endPosition()
207 {
208     if (m_useEndingSelection)
209         return endingSelection().end();
210     
211     return m_end;
212 }
213
214 void ApplyStyleCommand::doApply()
215 {
216     switch (m_propertyLevel) {
217     case PropertyDefault: {
218         // Apply the block-centric properties of the style.
219         RefPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
220         if (!blockStyle->isEmpty())
221             applyBlockStyle(blockStyle.get());
222         // Apply any remaining styles to the inline elements.
223         if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
224             applyRelativeFontStyleChange(m_style.get());
225             applyInlineStyle(m_style.get());
226         }
227         break;
228     }
229     case ForceBlockProperties:
230         // Force all properties to be applied as block styles.
231         applyBlockStyle(m_style.get());
232         break;
233     }
234 }
235
236 EditAction ApplyStyleCommand::editingAction() const
237 {
238     return m_editingAction;
239 }
240
241 void ApplyStyleCommand::applyBlockStyle(EditingStyle *style)
242 {
243     // update document layout once before removing styles
244     // so that we avoid the expense of updating before each and every call
245     // to check a computed style
246     document()->updateLayoutIgnorePendingStylesheets();
247
248     // get positions we want to use for applying style
249     Position start = startPosition();
250     Position end = endPosition();
251     if (comparePositions(end, start) < 0) {
252         Position swap = start;
253         start = end;
254         end = swap;
255     }
256
257     VisiblePosition visibleStart(start);
258     VisiblePosition visibleEnd(end);
259
260     if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() || visibleEnd.isOrphan())
261         return;
262
263     // Save and restore the selection endpoints using their indices in the document, since
264     // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
265     // Calculate start and end indices from the start of the tree that they're in.
266     Node* scope = highestAncestor(visibleStart.deepEquivalent().deprecatedNode());
267     RefPtr<Range> startRange = Range::create(document(), firstPositionInNode(scope), visibleStart.deepEquivalent().parentAnchoredEquivalent());
268     RefPtr<Range> endRange = Range::create(document(), firstPositionInNode(scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
269     int startIndex = TextIterator::rangeLength(startRange.get(), true);
270     int endIndex = TextIterator::rangeLength(endRange.get(), true);
271
272     VisiblePosition paragraphStart(startOfParagraph(visibleStart));
273     VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());
274     VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());
275     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
276         StyleChange styleChange(style, paragraphStart.deepEquivalent());
277         if (styleChange.cssStyle().length() || m_removeOnly) {
278             RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
279             if (!m_removeOnly) {
280                 RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
281                 if (newBlock)
282                     block = newBlock;
283             }
284             ASSERT(!block || block->isHTMLElement());
285             if (block && block->isHTMLElement()) {
286                 removeCSSStyle(style, toHTMLElement(block.get()));
287                 if (!m_removeOnly)
288                     addBlockStyle(styleChange, toHTMLElement(block.get()));
289             }
290
291             if (nextParagraphStart.isOrphan())
292                 nextParagraphStart = endOfParagraph(paragraphStart).next();
293         }
294
295         paragraphStart = nextParagraphStart;
296         nextParagraphStart = endOfParagraph(paragraphStart).next();
297     }
298     
299     startRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), startIndex, 0, true);
300     endRange = TextIterator::rangeFromLocationAndLength(static_cast<Element*>(scope), endIndex, 0, true);
301     if (startRange && endRange)
302         updateStartEnd(startRange->startPosition(), endRange->startPosition());
303 }
304
305 void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style)
306 {
307     static const float MinimumFontSize = 0.1f;
308
309     if (!style || !style->hasFontSizeDelta())
310         return;
311
312     Position start = startPosition();
313     Position end = endPosition();
314     if (comparePositions(end, start) < 0) {
315         Position swap = start;
316         start = end;
317         end = swap;
318     }
319
320     // Join up any adjacent text nodes.
321     if (start.deprecatedNode()->isTextNode()) {
322         joinChildTextNodes(start.deprecatedNode()->parentNode(), start, end);
323         start = startPosition();
324         end = endPosition();
325     }
326     if (end.deprecatedNode()->isTextNode() && start.deprecatedNode()->parentNode() != end.deprecatedNode()->parentNode()) {
327         joinChildTextNodes(end.deprecatedNode()->parentNode(), start, end);
328         start = startPosition();
329         end = endPosition();
330     }
331
332     // Split the start text nodes if needed to apply style.
333     if (isValidCaretPositionInTextNode(start)) {
334         splitTextAtStart(start, end);
335         start = startPosition();
336         end = endPosition();
337     }
338
339     if (isValidCaretPositionInTextNode(end)) {
340         splitTextAtEnd(start, end);
341         start = startPosition();
342         end = endPosition();
343     }
344
345     // Calculate loop end point.
346     // If the end node is before the start node (can only happen if the end node is
347     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
348     Node *beyondEnd;
349     if (start.deprecatedNode()->isDescendantOf(end.deprecatedNode()))
350         beyondEnd = end.deprecatedNode()->traverseNextSibling();
351     else
352         beyondEnd = end.deprecatedNode()->traverseNextNode();
353     
354     start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
355     Node* startNode = start.deprecatedNode();
356     if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
357         startNode = startNode->traverseNextNode();
358
359     // Store away font size before making any changes to the document.
360     // This ensures that changes to one node won't effect another.
361     HashMap<Node*, float> startingFontSizes;
362     for (Node *node = startNode; node != beyondEnd; node = node->traverseNextNode())
363         startingFontSizes.set(node, computedFontSize(node));
364
365     // These spans were added by us. If empty after font size changes, they can be removed.
366     Vector<RefPtr<HTMLElement> > unstyledSpans;
367     
368     Node* lastStyledNode = 0;
369     for (Node* node = startNode; node != beyondEnd; node = node->traverseNextNode()) {
370         RefPtr<HTMLElement> element;
371         if (node->isHTMLElement()) {
372             // Only work on fully selected nodes.
373             if (!nodeFullySelected(node, start, end))
374                 continue;
375             element = toHTMLElement(node);
376         } else if (node->isTextNode() && node->renderer() && node->parentNode() != lastStyledNode) {
377             // Last styled node was not parent node of this text node, but we wish to style this
378             // text node. To make this possible, add a style span to surround this text node.
379             RefPtr<HTMLElement> span = createStyleSpanElement(document());
380             surroundNodeRangeWithElement(node, node, span.get());
381             element = span.release();
382         }  else {
383             // Only handle HTML elements and text nodes.
384             continue;
385         }
386         lastStyledNode = node;
387
388         CSSMutableStyleDeclaration* inlineStyleDecl = element->ensureInlineStyleDecl();
389         float currentFontSize = computedFontSize(node);
390         float desiredFontSize = max(MinimumFontSize, startingFontSizes.get(node) + style->fontSizeDelta());
391         RefPtr<CSSValue> value = inlineStyleDecl->getPropertyCSSValue(CSSPropertyFontSize);
392         if (value) {
393             inlineStyleDecl->removeProperty(CSSPropertyFontSize);
394             currentFontSize = computedFontSize(node);
395         }
396         if (currentFontSize != desiredFontSize) {
397             inlineStyleDecl->setProperty(CSSPropertyFontSize, String::number(desiredFontSize) + "px", false);
398             setNodeAttribute(element.get(), styleAttr, inlineStyleDecl->asText());
399         }
400         if (inlineStyleDecl->isEmpty()) {
401             removeNodeAttribute(element.get(), styleAttr);
402             if (isSpanWithoutAttributesOrUnstyledStyleSpan(element.get()))
403                 unstyledSpans.append(element.release());
404         }
405     }
406
407     size_t size = unstyledSpans.size();
408     for (size_t i = 0; i < size; ++i)
409         removeNodePreservingChildren(unstyledSpans[i].get());
410 }
411
412 static Node* dummySpanAncestorForNode(const Node* node)
413 {
414     while (node && (!node->isElementNode() || !isStyleSpanOrSpanWithOnlyStyleAttribute(toElement(node))))
415         node = node->parentNode();
416     
417     return node ? node->parentNode() : 0;
418 }
419
420 void ApplyStyleCommand::cleanupUnstyledAppleStyleSpans(Node* dummySpanAncestor)
421 {
422     if (!dummySpanAncestor)
423         return;
424
425     // Dummy spans are created when text node is split, so that style information
426     // can be propagated, which can result in more splitting. If a dummy span gets
427     // cloned/split, the new node is always a sibling of it. Therefore, we scan
428     // all the children of the dummy's parent
429     Node* next;
430     for (Node* node = dummySpanAncestor->firstChild(); node; node = next) {
431         next = node->nextSibling();
432         if (isSpanWithoutAttributesOrUnstyledStyleSpan(node))
433             removeNodePreservingChildren(node);
434         node = next;
435     }
436 }
437
438 HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool before, WritingDirection allowedDirection)
439 {
440     // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
441     // In that case, we return the unsplit ancestor. Otherwise, we return 0.
442     Node* block = enclosingBlock(node);
443     if (!block)
444         return 0;
445
446     Node* highestAncestorWithUnicodeBidi = 0;
447     Node* nextHighestAncestorWithUnicodeBidi = 0;
448     int highestAncestorUnicodeBidi = 0;
449     for (Node* n = node->parentNode(); n != block; n = n->parentNode()) {
450         int unicodeBidi = getIdentifierValue(computedStyle(n).get(), CSSPropertyUnicodeBidi);
451         if (unicodeBidi && unicodeBidi != CSSValueNormal) {
452             highestAncestorUnicodeBidi = unicodeBidi;
453             nextHighestAncestorWithUnicodeBidi = highestAncestorWithUnicodeBidi;
454             highestAncestorWithUnicodeBidi = n;
455         }
456     }
457
458     if (!highestAncestorWithUnicodeBidi)
459         return 0;
460
461     HTMLElement* unsplitAncestor = 0;
462
463     WritingDirection highestAncestorDirection;
464     if (allowedDirection != NaturalWritingDirection
465         && highestAncestorUnicodeBidi != CSSValueBidiOverride
466         && highestAncestorWithUnicodeBidi->isHTMLElement()
467         && EditingStyle::create(highestAncestorWithUnicodeBidi, EditingStyle::AllProperties)->textDirection(highestAncestorDirection)
468         && highestAncestorDirection == allowedDirection) {
469         if (!nextHighestAncestorWithUnicodeBidi)
470             return toHTMLElement(highestAncestorWithUnicodeBidi);
471
472         unsplitAncestor = toHTMLElement(highestAncestorWithUnicodeBidi);
473         highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;
474     }
475
476     // Split every ancestor through highest ancestor with embedding.
477     Node* n = node;
478     while (true) {
479         Element* parent = static_cast<Element*>(n->parentNode());
480         if (before ? n->previousSibling() : n->nextSibling())
481             splitElement(parent, before ? n : n->nextSibling());
482         if (parent == highestAncestorWithUnicodeBidi)
483             break;
484         n = n->parentNode();
485     }
486     return unsplitAncestor;
487 }
488
489 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, Node* unsplitAncestor)
490 {
491     Node* block = enclosingBlock(node);
492     if (!block)
493         return;
494
495     Node* parent = 0;
496     for (Node* n = node->parentNode(); n != block && n != unsplitAncestor; n = parent) {
497         parent = n->parentNode();
498         if (!n->isStyledElement())
499             continue;
500
501         StyledElement* element = static_cast<StyledElement*>(n);
502         int unicodeBidi = getIdentifierValue(computedStyle(element).get(), CSSPropertyUnicodeBidi);
503         if (!unicodeBidi || unicodeBidi == CSSValueNormal)
504             continue;
505
506         // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,
507         // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
508         // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
509         // otherwise it sets the property in the inline style declaration.
510         if (element->hasAttribute(dirAttr)) {
511             // FIXME: If this is a BDO element, we should probably just remove it if it has no
512             // other attributes, like we (should) do with B and I elements.
513             removeNodeAttribute(element, dirAttr);
514         } else {
515             RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->ensureInlineStyleDecl()->copy();
516             inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
517             inlineStyle->removeProperty(CSSPropertyDirection);
518             setNodeAttribute(element, styleAttr, inlineStyle->asText());
519             if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
520                 removeNodePreservingChildren(element);
521         }
522     }
523 }
524
525 static Node* highestEmbeddingAncestor(Node* startNode, Node* enclosingNode)
526 {
527     for (Node* n = startNode; n && n != enclosingNode; n = n->parentNode()) {
528         if (n->isHTMLElement() && getIdentifierValue(computedStyle(n).get(), CSSPropertyUnicodeBidi) == CSSValueEmbed)
529             return n;
530     }
531
532     return 0;
533 }
534
535 void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
536 {
537     Node* startDummySpanAncestor = 0;
538     Node* endDummySpanAncestor = 0;
539
540     // update document layout once before removing styles
541     // so that we avoid the expense of updating before each and every call
542     // to check a computed style
543     document()->updateLayoutIgnorePendingStylesheets();
544
545     // adjust to the positions we want to use for applying style
546     Position start = startPosition();
547     Position end = endPosition();
548     if (comparePositions(end, start) < 0) {
549         Position swap = start;
550         start = end;
551         end = swap;
552     }
553
554     // split the start node and containing element if the selection starts inside of it
555     bool splitStart = isValidCaretPositionInTextNode(start);
556     if (splitStart) {
557         if (shouldSplitTextElement(start.deprecatedNode()->parentElement(), style))
558             splitTextElementAtStart(start, end);
559         else
560             splitTextAtStart(start, end);
561         start = startPosition();
562         end = endPosition();
563         startDummySpanAncestor = dummySpanAncestorForNode(start.deprecatedNode());
564     }
565
566     // split the end node and containing element if the selection ends inside of it
567     bool splitEnd = isValidCaretPositionInTextNode(end);
568     if (splitEnd) {
569         if (shouldSplitTextElement(end.deprecatedNode()->parentElement(), style))
570             splitTextElementAtEnd(start, end);
571         else
572             splitTextAtEnd(start, end);
573         start = startPosition();
574         end = endPosition();
575         endDummySpanAncestor = dummySpanAncestorForNode(end.deprecatedNode());
576     }
577
578     // Remove style from the selection.
579     // Use the upstream position of the start for removing style.
580     // This will ensure we remove all traces of the relevant styles from the selection
581     // and prevent us from adding redundant ones, as described in:
582     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
583     Position removeStart = start.upstream();
584     WritingDirection textDirection = NaturalWritingDirection;
585     bool hasTextDirection = style->textDirection(textDirection);
586     RefPtr<EditingStyle> styleWithoutEmbedding;
587     RefPtr<EditingStyle> embeddingStyle;
588     if (hasTextDirection) {
589         // Leave alone an ancestor that provides the desired single level embedding, if there is one.
590         HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.deprecatedNode(), true, textDirection);
591         HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.deprecatedNode(), false, textDirection);
592         removeEmbeddingUpToEnclosingBlock(start.deprecatedNode(), startUnsplitAncestor);
593         removeEmbeddingUpToEnclosingBlock(end.deprecatedNode(), endUnsplitAncestor);
594
595         // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
596         Position embeddingRemoveStart = removeStart;
597         if (startUnsplitAncestor && nodeFullySelected(startUnsplitAncestor, removeStart, end))
598             embeddingRemoveStart = positionInParentAfterNode(startUnsplitAncestor);
599
600         Position embeddingRemoveEnd = end;
601         if (endUnsplitAncestor && nodeFullySelected(endUnsplitAncestor, removeStart, end))
602             embeddingRemoveEnd = positionInParentBeforeNode(endUnsplitAncestor).downstream();
603
604         if (embeddingRemoveEnd != removeStart || embeddingRemoveEnd != end) {
605             styleWithoutEmbedding = style->copy();
606             embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
607
608             if (comparePositions(embeddingRemoveStart, embeddingRemoveEnd) <= 0)
609                 removeInlineStyle(embeddingStyle.get(), embeddingRemoveStart, embeddingRemoveEnd);
610         }
611     }
612
613     removeInlineStyle(styleWithoutEmbedding ? styleWithoutEmbedding.get() : style, removeStart, end);
614     start = startPosition();
615     end = endPosition();
616     if (start.isNull() || start.isOrphan() || end.isNull() || end.isOrphan())
617         return;
618
619     if (splitStart && mergeStartWithPreviousIfIdentical(start, end)) {
620         start = startPosition();
621         end = endPosition();
622     }
623
624     if (splitEnd) {
625         mergeEndWithNextIfIdentical(start, end);
626         start = startPosition();
627         end = endPosition();
628     }
629
630     // update document layout once before running the rest of the function
631     // so that we avoid the expense of updating before each and every call
632     // to check a computed style
633     document()->updateLayoutIgnorePendingStylesheets();
634
635     RefPtr<EditingStyle> styleToApply = style;
636     if (hasTextDirection) {
637         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
638         Node* embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode()));
639         Node* embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode()));
640
641         if (embeddingStartNode || embeddingEndNode) {
642             Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(embeddingStartNode) : start;
643             Position embeddingApplyEnd = embeddingEndNode ? positionInParentBeforeNode(embeddingEndNode) : end;
644             ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
645
646             if (!embeddingStyle) {
647                 styleWithoutEmbedding = style->copy();
648                 embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
649             }
650             fixRangeAndApplyInlineStyle(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd);
651
652             styleToApply = styleWithoutEmbedding;
653         }
654     }
655
656     fixRangeAndApplyInlineStyle(styleToApply.get(), start, end);
657
658     // Remove dummy style spans created by splitting text elements.
659     cleanupUnstyledAppleStyleSpans(startDummySpanAncestor);
660     if (endDummySpanAncestor != startDummySpanAncestor)
661         cleanupUnstyledAppleStyleSpans(endDummySpanAncestor);
662 }
663
664 void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const Position& start, const Position& end)
665 {
666     Node* startNode = start.deprecatedNode();
667
668     if (start.deprecatedEditingOffset() >= caretMaxOffset(start.deprecatedNode())) {
669         startNode = startNode->traverseNextNode();
670         if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
671             return;
672     }
673
674     Node* pastEndNode = end.deprecatedNode();
675     if (end.deprecatedEditingOffset() >= caretMaxOffset(end.deprecatedNode()))
676         pastEndNode = end.deprecatedNode()->traverseNextSibling();
677
678     // FIXME: Callers should perform this operation on a Range that includes the br
679     // if they want style applied to the empty line.
680     if (start == end && start.deprecatedNode()->hasTagName(brTag))
681         pastEndNode = start.deprecatedNode()->traverseNextNode();
682
683     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
684     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
685     // to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>
686     RefPtr<Range> range = Range::create(startNode->document(), start, end);
687     Element* editableRoot = startNode->rootEditableElement();
688     if (startNode != editableRoot) {
689         while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(startNode->parentNode(), range.get()))
690             startNode = startNode->parentNode();
691     }
692
693     applyInlineStyleToNodeRange(style, startNode, pastEndNode);
694 }
695
696 static bool containsNonEditableRegion(Node* node)
697 {
698     if (!node->rendererIsEditable())
699         return true;
700
701     Node* sibling = node->traverseNextSibling();
702     for (Node* descendent = node->firstChild(); descendent && descendent != sibling; descendent = descendent->traverseNextNode()) {
703         if (!descendent->rendererIsEditable())
704             return true;
705     }
706
707     return false;
708 }
709
710 void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, Node* node, Node* pastEndNode)
711 {
712     if (m_removeOnly)
713         return;
714
715     for (RefPtr<Node> next; node && node != pastEndNode; node = next.get()) {
716         next = node->traverseNextNode();
717
718         if (!node->renderer() || !node->rendererIsEditable())
719             continue;
720         
721         if (!node->rendererIsRichlyEditable() && node->isHTMLElement()) {
722             // This is a plaintext-only region. Only proceed if it's fully selected.
723             // pastEndNode is the node after the last fully selected node, so if it's inside node then
724             // node isn't fully selected.
725             if (pastEndNode && pastEndNode->isDescendantOf(node))
726                 break;
727             // Add to this element's inline style and skip over its contents.
728             HTMLElement* element = toHTMLElement(node);
729             RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->ensureInlineStyleDecl()->copy();
730             inlineStyle->merge(style->style());
731             setNodeAttribute(element, styleAttr, inlineStyle->asText());
732             next = node->traverseNextSibling();
733             continue;
734         }
735         
736         if (isBlock(node))
737             continue;
738         
739         if (node->childNodeCount()) {
740             if (node->contains(pastEndNode) || containsNonEditableRegion(node) || !node->parentNode()->rendererIsEditable())
741                 continue;
742             if (editingIgnoresContent(node)) {
743                 next = node->traverseNextSibling();
744                 continue;
745             }
746         }
747
748         RefPtr<Node> runStart = node;
749         RefPtr<Node> runEnd = node;
750         Node* sibling = node->nextSibling();
751         while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode)
752                && (!isBlock(sibling) || sibling->hasTagName(brTag))
753                && !containsNonEditableRegion(sibling)) {
754             runEnd = sibling;
755             sibling = runEnd->nextSibling();
756         }
757         next = runEnd->traverseNextSibling();
758
759         if (!removeStyleFromRunBeforeApplyingStyle(style, runStart, runEnd))
760             continue;
761         addInlineStyleIfNeeded(style, runStart.get(), runEnd.get(), AddStyledElement);
762     }
763 }
764
765 bool ApplyStyleCommand::isStyledInlineElementToRemove(Element* element) const
766 {
767     return (m_styledInlineElement && element->hasTagName(m_styledInlineElement->tagQName()))
768         || (m_isInlineElementToRemoveFunction && m_isInlineElementToRemoveFunction(element));
769 }
770
771 bool ApplyStyleCommand::removeStyleFromRunBeforeApplyingStyle(EditingStyle* style, RefPtr<Node>& runStart, RefPtr<Node>& runEnd)
772 {
773     ASSERT(runStart && runEnd && runStart->parentNode() == runEnd->parentNode());
774     RefPtr<Node> pastEndNode = runEnd->traverseNextSibling();
775     bool needToApplyStyle = false;
776     for (Node* node = runStart.get(); node && node != pastEndNode.get(); node = node->traverseNextNode()) {
777         if (node->childNodeCount())
778             continue;
779         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
780         if (!style->styleIsPresentInComputedStyleOfNode(node)
781             || (m_styledInlineElement && !enclosingNodeWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))) {
782             needToApplyStyle = true;
783             break;
784         }
785     }
786     if (!needToApplyStyle)
787         return false;
788
789     RefPtr<Node> next = runStart;
790     for (RefPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
791         next = node->traverseNextNode();
792         if (!node->isHTMLElement())
793             continue;
794
795         RefPtr<Node> previousSibling = node->previousSibling();
796         RefPtr<Node> nextSibling = node->nextSibling();
797         RefPtr<ContainerNode> parent = node->parentNode();
798         removeInlineStyleFromElement(style, toHTMLElement(node.get()), RemoveAlways);
799         if (!node->inDocument()) {
800             // FIXME: We might need to update the start and the end of current selection here but need a test.
801             if (runStart == node)
802                 runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();
803             if (runEnd == node)
804                 runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();
805         }
806     }
807
808     return true;
809 }
810
811 bool ApplyStyleCommand::removeInlineStyleFromElement(EditingStyle* style, PassRefPtr<HTMLElement> element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
812 {
813     ASSERT(element);
814
815     if (!element->parentNode() || !element->parentNode()->rendererIsEditable())
816         return false;
817
818     if (isStyledInlineElementToRemove(element.get())) {
819         if (mode == RemoveNone)
820             return true;
821         ASSERT(extractedStyle);
822         extractedStyle->mergeInlineStyleOfElement(element.get(), EditingStyle::OverrideValues);
823         removeNodePreservingChildren(element);
824         return true;
825     }
826
827     bool removed = false;
828     if (removeImplicitlyStyledElement(style, element.get(), mode, extractedStyle))
829         removed = true;
830
831     if (!element->inDocument())
832         return removed;
833
834     // If the node was converted to a span, the span may still contain relevant
835     // styles which must be removed (e.g. <b style='font-weight: bold'>)
836     if (removeCSSStyle(style, element.get(), mode, extractedStyle))
837         removed = true;
838
839     return removed;
840 }
841     
842 void ApplyStyleCommand::replaceWithSpanOrRemoveIfWithoutAttributes(HTMLElement*& elem)
843 {
844     if (hasNoAttributeOrOnlyStyleAttribute(elem, StyleAttributeShouldBeEmpty))
845         removeNodePreservingChildren(elem);
846     else {
847         HTMLElement* newSpanElement = replaceElementWithSpanPreservingChildrenAndAttributes(elem);
848         ASSERT(newSpanElement && newSpanElement->inDocument());
849         elem = newSpanElement;
850     }
851 }
852     
853 bool ApplyStyleCommand::removeImplicitlyStyledElement(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
854 {
855     ASSERT(style);
856     if (mode == RemoveNone) {
857         ASSERT(!extractedStyle);
858         return style->conflictsWithImplicitStyleOfElement(element) || style->conflictsWithImplicitStyleOfAttributes(element);
859     }
860
861     ASSERT(mode == RemoveIfNeeded || mode == RemoveAlways);
862     if (style->conflictsWithImplicitStyleOfElement(element, extractedStyle, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle)) {
863         replaceWithSpanOrRemoveIfWithoutAttributes(element);
864         return true;
865     }
866
867     // unicode-bidi and direction are pushed down separately so don't push down with other styles
868     Vector<QualifiedName> attributes;
869     if (!style->extractConflictingImplicitStyleOfAttributes(element, extractedStyle ? EditingStyle::PreserveWritingDirection : EditingStyle::DoNotPreserveWritingDirection,
870         extractedStyle, attributes, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle))
871         return false;
872
873     for (size_t i = 0; i < attributes.size(); i++)
874         removeNodeAttribute(element, attributes[i]);
875
876     if (isEmptyFontTag(element) || isSpanWithoutAttributesOrUnstyledStyleSpan(element))
877         removeNodePreservingChildren(element);
878
879     return true;
880 }
881
882 bool ApplyStyleCommand::removeCSSStyle(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
883 {
884     ASSERT(style);
885     ASSERT(element);
886
887     if (mode == RemoveNone)
888         return style->conflictsWithInlineStyleOfElement(element);
889
890     Vector<CSSPropertyID> properties;
891     if (!style->conflictsWithInlineStyleOfElement(element, extractedStyle, properties))
892         return false;
893
894     CSSMutableStyleDeclaration* inlineStyle = element->inlineStyleDecl();
895     ASSERT(inlineStyle);
896     // FIXME: We should use a mass-removal function here but we don't have an undoable one yet.
897     for (size_t i = 0; i < properties.size(); i++)
898         removeCSSProperty(element, properties[i]);
899
900     // No need to serialize <foo style=""> if we just removed the last css property
901     if (inlineStyle->isEmpty())
902         removeNodeAttribute(element, styleAttr);
903
904     if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
905         removeNodePreservingChildren(element);
906
907     return true;
908 }
909
910 HTMLElement* ApplyStyleCommand::highestAncestorWithConflictingInlineStyle(EditingStyle* style, Node* node)
911 {
912     if (!node)
913         return 0;
914
915     HTMLElement* result = 0;
916     Node* unsplittableElement = unsplittableElementForPosition(firstPositionInOrBeforeNode(node));
917
918     for (Node *n = node; n; n = n->parentNode()) {
919         if (n->isHTMLElement() && shouldRemoveInlineStyleFromElement(style, toHTMLElement(n)))
920             result = toHTMLElement(n);
921         // Should stop at the editable root (cannot cross editing boundary) and
922         // also stop at the unsplittable element to be consistent with other UAs
923         if (n == unsplittableElement)
924             break;
925     }
926
927     return result;
928 }
929
930 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style)
931 {
932     ASSERT(node);
933
934     if (!style || style->isEmpty() || !node->renderer())
935         return;
936
937     RefPtr<EditingStyle> newInlineStyle = style;
938     if (node->isHTMLElement() && toHTMLElement(node)->inlineStyleDecl()) {
939         newInlineStyle = style->copy();
940         newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node), EditingStyle::OverrideValues);
941     }
942
943     // Since addInlineStyleIfNeeded can't add styles to block-flow render objects, add style attribute instead.
944     // FIXME: applyInlineStyleToRange should be used here instead.
945     if ((node->renderer()->isBlockFlow() || node->childNodeCount()) && node->isHTMLElement()) {
946         setNodeAttribute(toHTMLElement(node), styleAttr, newInlineStyle->style()->asText());
947         return;
948     }
949
950     if (node->renderer()->isText() && static_cast<RenderText*>(node->renderer())->isAllCollapsibleWhitespace())
951         return;
952
953     // We can't wrap node with the styled element here because new styled element will never be removed if we did.
954     // If we modified the child pointer in pushDownInlineStyleAroundNode to point to new style element
955     // then we fall into an infinite loop where we keep removing and adding styled element wrapping node.
956     addInlineStyleIfNeeded(newInlineStyle.get(), node, node, DoNotAddStyledElement);
957 }
958
959 void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode)
960 {
961     HTMLElement* highestAncestor = highestAncestorWithConflictingInlineStyle(style, targetNode);
962     if (!highestAncestor)
963         return;
964
965     // The outer loop is traversing the tree vertically from highestAncestor to targetNode
966     Node* current = highestAncestor;
967     // Along the way, styled elements that contain targetNode are removed and accumulated into elementsToPushDown.
968     // Each child of the removed element, exclusing ancestors of targetNode, is then wrapped by clones of elements in elementsToPushDown.
969     Vector<RefPtr<Element> > elementsToPushDown;
970     while (current != targetNode) {
971         ASSERT(current);
972         ASSERT(current->contains(targetNode));
973         Node* child = current->firstChild();
974         Node* lastChild = current->lastChild();
975         RefPtr<StyledElement> styledElement;
976         if (current->isStyledElement() && isStyledInlineElementToRemove(static_cast<Element*>(current))) {
977             styledElement = static_cast<StyledElement*>(current);
978             elementsToPushDown.append(styledElement);
979         }
980
981         RefPtr<EditingStyle> styleToPushDown = EditingStyle::create();
982         if (current->isHTMLElement())
983             removeInlineStyleFromElement(style, toHTMLElement(current), RemoveIfNeeded, styleToPushDown.get());
984
985         // The inner loop will go through children on each level
986         // FIXME: we should aggregate inline child elements together so that we don't wrap each child separately.
987         while (child) {
988             Node* nextChild = child->nextSibling();
989
990             if (!child->contains(targetNode) && elementsToPushDown.size()) {
991                 for (size_t i = 0; i < elementsToPushDown.size(); i++) {
992                     RefPtr<Element> wrapper = elementsToPushDown[i]->cloneElementWithoutChildren();
993                     wrapper->removeAttribute(styleAttr);
994                     surroundNodeRangeWithElement(child, child, wrapper);
995                 }
996             }
997
998             // Apply style to all nodes containing targetNode and their siblings but NOT to targetNode
999             // But if we've removed styledElement then go ahead and always apply the style.
1000             if (child != targetNode || styledElement)
1001                 applyInlineStyleToPushDown(child, styleToPushDown.get());
1002
1003             // We found the next node for the outer loop (contains targetNode)
1004             // When reached targetNode, stop the outer loop upon the completion of the current inner loop
1005             if (child == targetNode || child->contains(targetNode))
1006                 current = child;
1007
1008             if (child == lastChild || child->contains(lastChild))
1009                 break;
1010             child = nextChild;
1011         }
1012     }
1013 }
1014
1015 void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end)
1016 {
1017     ASSERT(start.isNotNull());
1018     ASSERT(end.isNotNull());
1019     ASSERT(start.anchorNode()->inDocument());
1020     ASSERT(end.anchorNode()->inDocument());
1021     ASSERT(comparePositions(start, end) <= 0);
1022
1023     Position pushDownStart = start.downstream();
1024     // If the pushDownStart is at the end of a text node, then this node is not fully selected.
1025     // Move it to the next deep quivalent position to avoid removing the style from this node.
1026     // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
1027     Node* pushDownStartContainer = pushDownStart.containerNode();
1028     if (pushDownStartContainer && pushDownStartContainer->isTextNode()
1029         && pushDownStart.computeOffsetInContainerNode() == pushDownStartContainer->maxCharacterOffset())
1030         pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
1031     Position pushDownEnd = end.upstream();
1032
1033     pushDownInlineStyleAroundNode(style, pushDownStart.deprecatedNode());
1034     pushDownInlineStyleAroundNode(style, pushDownEnd.deprecatedNode());
1035
1036     // The s and e variables store the positions used to set the ending selection after style removal
1037     // takes place. This will help callers to recognize when either the start node or the end node
1038     // are removed from the document during the work of this function.
1039     // If pushDownInlineStyleAroundNode has pruned start.deprecatedNode() or end.deprecatedNode(),
1040     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
1041     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
1042     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
1043
1044     Node* node = start.deprecatedNode();
1045     while (node) {
1046         RefPtr<Node> next = node->traverseNextNode();
1047         if (node->isHTMLElement() && nodeFullySelected(node, start, end)) {
1048             RefPtr<HTMLElement> elem = toHTMLElement(node);
1049             RefPtr<Node> prev = elem->traversePreviousNodePostOrder();
1050             RefPtr<Node> next = elem->traverseNextNode();
1051             RefPtr<EditingStyle> styleToPushDown;
1052             RefPtr<Node> childNode;
1053             if (isStyledInlineElementToRemove(elem.get())) {
1054                 styleToPushDown = EditingStyle::create();
1055                 childNode = elem->firstChild();
1056             }
1057
1058             removeInlineStyleFromElement(style, elem.get(), RemoveIfNeeded, styleToPushDown.get());
1059             if (!elem->inDocument()) {
1060                 if (s.deprecatedNode() == elem) {
1061                     // Since elem must have been fully selected, and it is at the start
1062                     // of the selection, it is clear we can set the new s offset to 0.
1063                     ASSERT(s.anchorType() == Position::PositionIsBeforeAnchor || s.offsetInContainerNode() <= 0);
1064                     s = firstPositionInOrBeforeNode(next.get());
1065                 }
1066                 if (e.deprecatedNode() == elem) {
1067                     // Since elem must have been fully selected, and it is at the end
1068                     // of the selection, it is clear we can set the new e offset to
1069                     // the max range offset of prev.
1070                     ASSERT(s.anchorType() == Position::PositionIsAfterAnchor
1071                            || s.offsetInContainerNode() >= lastOffsetInNode(s.containerNode()));
1072                     e = lastPositionInOrAfterNode(prev.get());
1073                 }
1074             }
1075
1076             if (styleToPushDown) {
1077                 for (; childNode; childNode = childNode->nextSibling())
1078                     applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get());
1079             }
1080         }
1081         if (node == end.deprecatedNode())
1082             break;
1083         node = next.get();
1084     }
1085
1086     updateStartEnd(s, e);
1087 }
1088
1089 bool ApplyStyleCommand::nodeFullySelected(Node *node, const Position &start, const Position &end) const
1090 {
1091     ASSERT(node);
1092     ASSERT(node->isElementNode());
1093
1094     return comparePositions(firstPositionInOrBeforeNode(node), start) >= 0
1095         && comparePositions(lastPositionInOrAfterNode(node).upstream(), end) <= 0;
1096 }
1097
1098 bool ApplyStyleCommand::nodeFullyUnselected(Node *node, const Position &start, const Position &end) const
1099 {
1100     ASSERT(node);
1101     ASSERT(node->isElementNode());
1102
1103     bool isFullyBeforeStart = comparePositions(lastPositionInOrAfterNode(node).upstream(), start) < 0;
1104     bool isFullyAfterEnd = comparePositions(firstPositionInOrBeforeNode(node), end) > 0;
1105
1106     return isFullyBeforeStart || isFullyAfterEnd;
1107 }
1108
1109 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
1110 {
1111     ASSERT(start.containerNode()->isTextNode());
1112
1113     Position newEnd;
1114     if (end.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode())
1115         newEnd = Position(end.containerText(), end.offsetInContainerNode() - start.offsetInContainerNode());
1116     else
1117         newEnd = end;
1118
1119     RefPtr<Text> text = start.containerText();
1120     splitTextNode(text, start.offsetInContainerNode());
1121     updateStartEnd(firstPositionInNode(text.get()), newEnd);
1122 }
1123
1124 void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& end)
1125 {
1126     ASSERT(end.containerNode()->isTextNode());
1127
1128     bool shouldUpdateStart = start.anchorType() == Position::PositionIsOffsetInAnchor && start.containerNode() == end.containerNode();
1129     Text* text = static_cast<Text *>(end.deprecatedNode());
1130     splitTextNode(text, end.offsetInContainerNode());
1131
1132     Node* prevNode = text->previousSibling();
1133     if (!prevNode || !prevNode->isTextNode())
1134         return;
1135
1136     Position newStart = shouldUpdateStart ? Position(static_cast<Text*>(prevNode), start.offsetInContainerNode()) : start;
1137     updateStartEnd(newStart, lastPositionInNode(prevNode));
1138 }
1139
1140 void ApplyStyleCommand::splitTextElementAtStart(const Position& start, const Position& end)
1141 {
1142     ASSERT(start.containerNode()->isTextNode());
1143
1144     Position newEnd;
1145     if (start.containerNode() == end.containerNode())
1146         newEnd = Position(end.containerText(), end.offsetInContainerNode() - start.offsetInContainerNode());
1147     else
1148         newEnd = end;
1149
1150     splitTextNodeContainingElement(start.containerText(), start.offsetInContainerNode());
1151     updateStartEnd(positionBeforeNode(start.containerNode()), newEnd);
1152 }
1153
1154 void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Position& end)
1155 {
1156     ASSERT(end.containerNode()->isTextNode());
1157
1158     bool shouldUpdateStart = start.containerNode() == end.containerNode();
1159     splitTextNodeContainingElement(end.containerText(), end.offsetInContainerNode());
1160
1161     Node* parentElement = end.containerNode()->parentNode();
1162     if (!parentElement || !parentElement->previousSibling())
1163         return;
1164     Node* firstTextNode = parentElement->previousSibling()->lastChild();
1165     if (!firstTextNode || !firstTextNode->isTextNode())
1166         return;
1167
1168     Position newStart = shouldUpdateStart ? Position(static_cast<Text*>(firstTextNode), start.offsetInContainerNode()) : start;
1169     updateStartEnd(newStart, positionAfterNode(firstTextNode));
1170 }
1171
1172 bool ApplyStyleCommand::shouldSplitTextElement(Element* element, EditingStyle* style)
1173 {
1174     if (!element || !element->isHTMLElement())
1175         return false;
1176
1177     return shouldRemoveInlineStyleFromElement(style, toHTMLElement(element));
1178 }
1179
1180 bool ApplyStyleCommand::isValidCaretPositionInTextNode(const Position& position)
1181 {
1182     Node* node = position.containerNode();
1183     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node->isTextNode())
1184         return false;
1185     int offsetInText = position.offsetInContainerNode();
1186     return offsetInText > caretMinOffset(node) && offsetInText < caretMaxOffset(node);
1187 }
1188
1189 bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end)
1190 {
1191     Node* startNode = start.containerNode();
1192     int startOffset = start.computeOffsetInContainerNode();
1193     if (startOffset)
1194         return false;
1195
1196     if (isAtomicNode(startNode)) {
1197         // note: prior siblings could be unrendered elements. it's silly to miss the
1198         // merge opportunity just for that.
1199         if (startNode->previousSibling())
1200             return false;
1201
1202         startNode = startNode->parentNode();
1203         startOffset = 0;
1204     }
1205
1206     if (!startNode->isElementNode())
1207         return false;
1208
1209     Node* previousSibling = startNode->previousSibling();
1210
1211     if (previousSibling && areIdenticalElements(startNode, previousSibling)) {
1212         Element* previousElement = static_cast<Element*>(previousSibling);
1213         Element* element = static_cast<Element*>(startNode);
1214         Node* startChild = element->firstChild();
1215         ASSERT(startChild);
1216         mergeIdenticalElements(previousElement, element);
1217
1218         int startOffsetAdjustment = startChild->nodeIndex();
1219         int endOffsetAdjustment = startNode == end.deprecatedNode() ? startOffsetAdjustment : 0;
1220         updateStartEnd(Position(startNode, startOffsetAdjustment, Position::PositionIsOffsetInAnchor),
1221                        Position(end.deprecatedNode(), end.deprecatedEditingOffset() + endOffsetAdjustment, Position::PositionIsOffsetInAnchor)); 
1222         return true;
1223     }
1224
1225     return false;
1226 }
1227
1228 bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position& start, const Position& end)
1229 {
1230     Node* endNode = end.containerNode();
1231     int endOffset = end.computeOffsetInContainerNode();
1232
1233     if (isAtomicNode(endNode)) {
1234         if (endOffset < lastOffsetInNode(endNode))
1235             return false;
1236
1237         unsigned parentLastOffset = end.deprecatedNode()->parentNode()->childNodes()->length() - 1;
1238         if (end.deprecatedNode()->nextSibling())
1239             return false;
1240
1241         endNode = end.deprecatedNode()->parentNode();
1242         endOffset = parentLastOffset;
1243     }
1244
1245     if (!endNode->isElementNode() || endNode->hasTagName(brTag))
1246         return false;
1247
1248     Node* nextSibling = endNode->nextSibling();
1249     if (nextSibling && areIdenticalElements(endNode, nextSibling)) {
1250         Element* nextElement = static_cast<Element *>(nextSibling);
1251         Element* element = static_cast<Element *>(endNode);
1252         Node* nextChild = nextElement->firstChild();
1253
1254         mergeIdenticalElements(element, nextElement);
1255
1256         bool shouldUpdateStart = start.containerNode() == endNode;
1257         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
1258         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode(), Position::PositionIsOffsetInAnchor) : start,
1259                        Position(nextElement, endOffset, Position::PositionIsOffsetInAnchor));
1260         return true;
1261     }
1262
1263     return false;
1264 }
1265
1266 void ApplyStyleCommand::surroundNodeRangeWithElement(PassRefPtr<Node> passedStartNode, PassRefPtr<Node> endNode, PassRefPtr<Element> elementToInsert)
1267 {
1268     ASSERT(passedStartNode);
1269     ASSERT(endNode);
1270     ASSERT(elementToInsert);
1271     RefPtr<Node> startNode = passedStartNode;
1272     RefPtr<Element> element = elementToInsert;
1273
1274     insertNodeBefore(element, startNode);
1275
1276     RefPtr<Node> node = startNode;
1277     while (node) {
1278         RefPtr<Node> next = node->nextSibling();
1279         if (node->isContentEditable()) {
1280             removeNode(node);
1281             appendNode(node, element);
1282         }
1283         if (node == endNode)
1284             break;
1285         node = next;
1286     }
1287
1288     RefPtr<Node> nextSibling = element->nextSibling();
1289     RefPtr<Node> previousSibling = element->previousSibling();
1290     if (nextSibling && nextSibling->isElementNode() && nextSibling->rendererIsEditable()
1291         && areIdenticalElements(element.get(), static_cast<Element*>(nextSibling.get())))
1292         mergeIdenticalElements(element.get(), static_cast<Element*>(nextSibling.get()));
1293
1294     if (previousSibling && previousSibling->isElementNode() && previousSibling->rendererIsEditable()) {
1295         Node* mergedElement = previousSibling->nextSibling();
1296         if (mergedElement->isElementNode() && mergedElement->rendererIsEditable()
1297             && areIdenticalElements(static_cast<Element*>(previousSibling.get()), static_cast<Element*>(mergedElement)))
1298             mergeIdenticalElements(static_cast<Element*>(previousSibling.get()), static_cast<Element*>(mergedElement));
1299     }
1300
1301     // FIXME: We should probably call updateStartEnd if the start or end was in the node
1302     // range so that the endingSelection() is canonicalized.  See the comments at the end of
1303     // VisibleSelection::validate().
1304 }
1305
1306 void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange, HTMLElement* block)
1307 {
1308     // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
1309     // inline content.
1310     if (!block)
1311         return;
1312         
1313     String cssText = styleChange.cssStyle();
1314     if (CSSMutableStyleDeclaration* decl = block->inlineStyleDecl())
1315         cssText += decl->asText();
1316     setNodeAttribute(block, styleAttr, cssText);
1317 }
1318
1319 void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, EAddStyledElement addStyledElement)
1320 {
1321     if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
1322         return;
1323     RefPtr<Node> startNode = passedStart;
1324     RefPtr<Node> endNode = passedEnd;
1325
1326     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
1327     RefPtr<HTMLElement> dummyElement;
1328     Position positionForStyleComparison;
1329     if (!startNode->isElementNode()) {
1330         dummyElement = createStyleSpanElement(document());
1331         insertNodeAt(dummyElement, positionBeforeNode(startNode.get()));
1332         positionForStyleComparison = positionBeforeNode(dummyElement.get());
1333     } else
1334         positionForStyleComparison = firstPositionInOrBeforeNode(startNode.get());
1335
1336     StyleChange styleChange(style, positionForStyleComparison);
1337
1338     if (dummyElement)
1339         removeNode(dummyElement);
1340
1341     // Find appropriate font and span elements top-down.
1342     HTMLElement* fontContainer = 0;
1343     HTMLElement* styleContainer = 0;
1344     for (Node* container = startNode.get(); container && startNode == endNode; container = container->firstChild()) {
1345         if (container->isHTMLElement() && container->hasTagName(fontTag))
1346             fontContainer = toHTMLElement(container);
1347         bool styleContainerIsNotSpan = !styleContainer || !styleContainer->hasTagName(spanTag);
1348         if (container->isHTMLElement() && (container->hasTagName(spanTag) || (styleContainerIsNotSpan && container->childNodeCount())))
1349             styleContainer = toHTMLElement(container);
1350         if (!container->firstChild())
1351             break;
1352         startNode = container->firstChild();
1353         endNode = container->lastChild();
1354     }
1355
1356     // Font tags need to go outside of CSS so that CSS font sizes override leagcy font sizes.
1357     if (styleChange.applyFontColor() || styleChange.applyFontFace() || styleChange.applyFontSize()) {
1358         if (fontContainer) {
1359             if (styleChange.applyFontColor())
1360                 setNodeAttribute(fontContainer, colorAttr, styleChange.fontColor());
1361             if (styleChange.applyFontFace())
1362                 setNodeAttribute(fontContainer, faceAttr, styleChange.fontFace());
1363             if (styleChange.applyFontSize())
1364                 setNodeAttribute(fontContainer, sizeAttr, styleChange.fontSize());
1365         } else {
1366             RefPtr<Element> fontElement = createFontElement(document());
1367             if (styleChange.applyFontColor())
1368                 fontElement->setAttribute(colorAttr, styleChange.fontColor());
1369             if (styleChange.applyFontFace())
1370                 fontElement->setAttribute(faceAttr, styleChange.fontFace());
1371             if (styleChange.applyFontSize())
1372                 fontElement->setAttribute(sizeAttr, styleChange.fontSize());
1373             surroundNodeRangeWithElement(startNode, endNode, fontElement.get());
1374         }
1375     }
1376
1377     if (styleChange.cssStyle().length()) {
1378         if (styleContainer) {
1379             if (CSSMutableStyleDeclaration* existingStyle = styleContainer->inlineStyleDecl())
1380                 setNodeAttribute(styleContainer, styleAttr, existingStyle->asText() + styleChange.cssStyle());
1381             else
1382                 setNodeAttribute(styleContainer, styleAttr, styleChange.cssStyle());
1383         } else {
1384             RefPtr<Element> styleElement = createStyleSpanElement(document());
1385             styleElement->setAttribute(styleAttr, styleChange.cssStyle());
1386             surroundNodeRangeWithElement(startNode, endNode, styleElement.release());
1387         }
1388     }
1389
1390     if (styleChange.applyBold())
1391         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), bTag));
1392
1393     if (styleChange.applyItalic())
1394         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), iTag));
1395
1396     if (styleChange.applyUnderline())
1397         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), uTag));
1398
1399     if (styleChange.applyLineThrough())
1400         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), strikeTag));
1401
1402     if (styleChange.applySubscript())
1403         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), subTag));
1404     else if (styleChange.applySuperscript())
1405         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), supTag));
1406
1407     if (m_styledInlineElement && addStyledElement == AddStyledElement)
1408         surroundNodeRangeWithElement(startNode, endNode, m_styledInlineElement->cloneElementWithoutChildren());
1409 }
1410
1411 float ApplyStyleCommand::computedFontSize(Node* node)
1412 {
1413     if (!node)
1414         return 0;
1415
1416     RefPtr<CSSComputedStyleDeclaration> style = computedStyle(node);
1417     if (!style)
1418         return 0;
1419
1420     RefPtr<CSSPrimitiveValue> value = static_pointer_cast<CSSPrimitiveValue>(style->getPropertyCSSValue(CSSPropertyFontSize));
1421     if (!value)
1422         return 0;
1423
1424     return value->getFloatValue(CSSPrimitiveValue::CSS_PX);
1425 }
1426
1427 void ApplyStyleCommand::joinChildTextNodes(Node* node, const Position& start, const Position& end)
1428 {
1429     if (!node)
1430         return;
1431
1432     Position newStart = start;
1433     Position newEnd = end;
1434
1435     Node* child = node->firstChild();
1436     while (child) {
1437         Node* next = child->nextSibling();
1438         if (child->isTextNode() && next && next->isTextNode()) {
1439             Text* childText = static_cast<Text *>(child);
1440             Text* nextText = static_cast<Text *>(next);
1441             if (start.anchorType() == Position::PositionIsOffsetInAnchor && next == start.containerNode())
1442                 newStart = Position(childText, childText->length() + start.offsetInContainerNode());
1443             if (end.anchorType() == Position::PositionIsOffsetInAnchor && next == end.containerNode())
1444                 newEnd = Position(childText, childText->length() + end.offsetInContainerNode());
1445             String textToMove = nextText->data();
1446             insertTextIntoNode(childText, childText->length(), textToMove);
1447             removeNode(next);
1448             // don't move child node pointer. it may want to merge with more text nodes.
1449         }
1450         else {
1451             child = child->nextSibling();
1452         }
1453     }
1454
1455     updateStartEnd(newStart, newEnd);
1456 }
1457
1458 }