75d567e42069c578019aff469d863cdaff0ce221
[WebKit-https.git] / WebCore / editing / markup.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2006, 2007, 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 "markup.h"
28
29 #include "ApplyStyleCommand.h"
30 #include "CDATASection.h"
31 #include "CharacterNames.h"
32 #include "Comment.h"
33 #include "CSSComputedStyleDeclaration.h"
34 #include "CSSMutableStyleDeclaration.h"
35 #include "CSSPrimitiveValue.h"
36 #include "CSSProperty.h"
37 #include "CSSPropertyNames.h"
38 #include "CSSRule.h"
39 #include "CSSRuleList.h"
40 #include "CSSStyleRule.h"
41 #include "CSSStyleSelector.h"
42 #include "CSSValue.h"
43 #include "CSSValueKeywords.h"
44 #include "DeleteButtonController.h"
45 #include "DocumentFragment.h"
46 #include "DocumentType.h"
47 #include "Editor.h"
48 #include "Frame.h"
49 #include "HTMLBodyElement.h"
50 #include "HTMLElement.h"
51 #include "HTMLNames.h"
52 #include "InlineTextBox.h"
53 #include "KURL.h"
54 #include "Logging.h"
55 #include "MarkupAccumulator.h"
56 #include "ProcessingInstruction.h"
57 #include "Range.h"
58 #include "TextIterator.h"
59 #include "VisibleSelection.h"
60 #include "XMLNSNames.h"
61 #include "htmlediting.h"
62 #include "visible_units.h"
63 #include <wtf/StdLibExtras.h>
64
65 using namespace std;
66
67 namespace WebCore {
68
69 using namespace HTMLNames;
70
71 static bool propertyMissingOrEqualToNone(CSSStyleDeclaration*, int propertyID);
72
73 class AttributeChange {
74 public:
75     AttributeChange()
76         : m_name(nullAtom, nullAtom, nullAtom)
77     {
78     }
79
80     AttributeChange(PassRefPtr<Element> element, const QualifiedName& name, const String& value)
81         : m_element(element), m_name(name), m_value(value)
82     {
83     }
84
85     void apply()
86     {
87         m_element->setAttribute(m_name, m_value);
88     }
89
90 private:
91     RefPtr<Element> m_element;
92     QualifiedName m_name;
93     String m_value;
94 };
95
96 static void completeURLs(Node* node, const String& baseURL)
97 {
98     Vector<AttributeChange> changes;
99
100     KURL parsedBaseURL(ParsedURLString, baseURL);
101
102     Node* end = node->traverseNextSibling();
103     for (Node* n = node; n != end; n = n->traverseNextNode()) {
104         if (n->isElementNode()) {
105             Element* e = static_cast<Element*>(n);
106             NamedNodeMap* attributes = e->attributes();
107             unsigned length = attributes->length();
108             for (unsigned i = 0; i < length; i++) {
109                 Attribute* attribute = attributes->attributeItem(i);
110                 if (e->isURLAttribute(attribute))
111                     changes.append(AttributeChange(e, attribute->name(), KURL(parsedBaseURL, attribute->value()).string()));
112             }
113         }
114     }
115
116     size_t numChanges = changes.size();
117     for (size_t i = 0; i < numChanges; ++i)
118         changes[i].apply();
119 }
120     
121 class StyledMarkupAccumulator : public MarkupAccumulator {
122 public:
123     enum RangeFullySelectsNode { DoesFullySelectNode, DoesNotFullySelectNode };
124
125     StyledMarkupAccumulator(Vector<Node*>* nodes, EAbsoluteURLs shouldResolveURLs, EAnnotateForInterchange shouldAnnotate, const Range* range)
126     : MarkupAccumulator(nodes, shouldResolveURLs, range)
127     , m_shouldAnnotate(shouldAnnotate)
128     {
129     }
130
131     Node* serializeNodes(Node* startNode, Node* pastEnd);
132     void appendString(const String& s) { return MarkupAccumulator::appendString(s); }
133     void wrapWithNode(Node*, bool convertBlocksToInlines = false, RangeFullySelectsNode = DoesFullySelectNode);
134     void wrapWithStyleNode(CSSStyleDeclaration*, Document*, bool isBlock = false);
135     String takeResults();
136
137 private:
138     virtual void appendText(Vector<UChar>& out, Text*);
139     String renderedText(const Node*, const Range*);
140     String stringValueForRange(const Node*, const Range*);
141     void removeExteriorStyles(CSSMutableStyleDeclaration*);
142     void appendElement(Vector<UChar>& out, Element* element, bool addDisplayInline, RangeFullySelectsNode);
143     void appendElement(Vector<UChar>& out, Element* element, Namespaces*) { appendElement(out, element, false, DoesFullySelectNode); }
144
145     bool shouldAnnotate() { return m_shouldAnnotate == AnnotateForInterchange; }
146
147     Vector<String> m_reversedPrecedingMarkup;
148     const EAnnotateForInterchange m_shouldAnnotate;
149 };
150
151 void StyledMarkupAccumulator::wrapWithNode(Node* node, bool convertBlocksToInlines, RangeFullySelectsNode rangeFullySelectsNode)
152 {
153     Vector<UChar> markup;
154     if (node->isElementNode())
155         appendElement(markup, static_cast<Element*>(node), convertBlocksToInlines && isBlock(const_cast<Node*>(node)), rangeFullySelectsNode);
156     else
157         appendStartMarkup(markup, node, 0);
158     m_reversedPrecedingMarkup.append(String::adopt(markup));
159     appendEndTag(node);
160     if (m_nodes)
161         m_nodes->append(node);
162 }
163
164 void StyledMarkupAccumulator::wrapWithStyleNode(CSSStyleDeclaration* style, Document* document, bool isBlock)
165 {
166     // All text-decoration-related elements should have been treated as special ancestors
167     // If we ever hit this ASSERT, we should export StyleChange in ApplyStyleCommand and use it here
168     ASSERT(propertyMissingOrEqualToNone(style, CSSPropertyTextDecoration) && propertyMissingOrEqualToNone(style, CSSPropertyWebkitTextDecorationsInEffect));
169     DEFINE_STATIC_LOCAL(const String, divStyle, ("<div style=\""));
170     DEFINE_STATIC_LOCAL(const String, divClose, ("</div>"));
171     DEFINE_STATIC_LOCAL(const String, styleSpanOpen, ("<span class=\"" AppleStyleSpanClass "\" style=\""));
172     DEFINE_STATIC_LOCAL(const String, styleSpanClose, ("</span>"));
173     Vector<UChar> openTag;
174     append(openTag, isBlock ? divStyle : styleSpanOpen);
175     appendAttributeValue(openTag, style->cssText(), document->isHTMLDocument());
176     openTag.append('\"');
177     openTag.append('>');
178     m_reversedPrecedingMarkup.append(String::adopt(openTag));
179     appendString(isBlock ? divClose : styleSpanClose);
180 }
181
182 String StyledMarkupAccumulator::takeResults()
183 {
184     Vector<UChar> result;
185     result.reserveInitialCapacity(totalLength(m_reversedPrecedingMarkup) + length());
186
187     for (size_t i = m_reversedPrecedingMarkup.size(); i > 0; --i)
188         append(result, m_reversedPrecedingMarkup[i - 1]);
189
190     concatenateMarkup(result);
191
192     return String::adopt(result);
193 }
194
195 void StyledMarkupAccumulator::appendText(Vector<UChar>& out, Text* text)
196 {
197     if (!shouldAnnotate() || (text->parentElement() && text->parentElement()->tagQName() == textareaTag)) {
198         MarkupAccumulator::appendText(out, text);
199         return;
200     }
201
202     bool useRenderedText = !enclosingNodeWithTag(Position(text, 0), selectTag);
203     String content = useRenderedText ? renderedText(text, m_range) : stringValueForRange(text, m_range);
204     Vector<UChar> buffer;
205     appendCharactersReplacingEntities(buffer, content.characters(), content.length(), EntityMaskInPCDATA);
206     append(out, convertHTMLTextToInterchangeFormat(String::adopt(buffer), text));
207 }
208     
209 String StyledMarkupAccumulator::renderedText(const Node* node, const Range* range)
210 {
211     if (!node->isTextNode())
212         return String();
213
214     ExceptionCode ec;
215     const Text* textNode = static_cast<const Text*>(node);
216     unsigned startOffset = 0;
217     unsigned endOffset = textNode->length();
218
219     if (range && node == range->startContainer(ec))
220         startOffset = range->startOffset(ec);
221     if (range && node == range->endContainer(ec))
222         endOffset = range->endOffset(ec);
223
224     Position start(const_cast<Node*>(node), startOffset);
225     Position end(const_cast<Node*>(node), endOffset);
226     return plainText(Range::create(node->document(), start, end).get());
227 }
228
229 String StyledMarkupAccumulator::stringValueForRange(const Node* node, const Range* range)
230 {
231     if (!range)
232         return node->nodeValue();
233
234     String str = node->nodeValue();
235     ExceptionCode ec;
236     if (node == range->endContainer(ec))
237         str.truncate(range->endOffset(ec));
238     if (node == range->startContainer(ec))
239         str.remove(0, range->startOffset(ec));
240     return str;
241 }
242
243 static PassRefPtr<CSSMutableStyleDeclaration> styleFromMatchedRulesForElement(Element* element, bool authorOnly = true)
244 {
245     RefPtr<CSSMutableStyleDeclaration> style = CSSMutableStyleDeclaration::create();
246     RefPtr<CSSRuleList> matchedRules = element->document()->styleSelector()->styleRulesForElement(element, authorOnly);
247     if (matchedRules) {
248         for (unsigned i = 0; i < matchedRules->length(); i++) {
249             if (matchedRules->item(i)->type() == CSSRule::STYLE_RULE) {
250                 RefPtr<CSSMutableStyleDeclaration> s = static_cast<CSSStyleRule*>(matchedRules->item(i))->style();
251                 style->merge(s.get(), true);
252             }
253         }
254     }
255
256     return style.release();
257 }
258
259 void StyledMarkupAccumulator::appendElement(Vector<UChar>& out, Element* element, bool addDisplayInline, RangeFullySelectsNode rangeFullySelectsNode)
260 {
261     bool documentIsHTML = element->document()->isHTMLDocument();
262     appendOpenTag(out, element, 0);
263
264     NamedNodeMap* attributes = element->attributes();
265     unsigned length = attributes->length();
266     for (unsigned int i = 0; i < length; i++) {
267         Attribute* attribute = attributes->attributeItem(i);
268         // We'll handle the style attribute separately, below.
269         if (attribute->name() == styleAttr && element->isHTMLElement() && (shouldAnnotate() || addDisplayInline))
270             continue;
271         appendAttribute(out, element, *attribute, 0);
272     }
273
274     if (element->isHTMLElement() && (shouldAnnotate() || addDisplayInline)) {
275         RefPtr<CSSMutableStyleDeclaration> style = static_cast<HTMLElement*>(element)->getInlineStyleDecl()->copy();
276         if (shouldAnnotate()) {
277             RefPtr<CSSMutableStyleDeclaration> styleFromMatchedRules = styleFromMatchedRulesForElement(const_cast<Element*>(element));
278             // Styles from the inline style declaration, held in the variable "style", take precedence 
279             // over those from matched rules.
280             styleFromMatchedRules->merge(style.get());
281             style = styleFromMatchedRules;
282
283             RefPtr<CSSComputedStyleDeclaration> computedStyleForElement = computedStyle(element);
284             RefPtr<CSSMutableStyleDeclaration> fromComputedStyle = CSSMutableStyleDeclaration::create();
285
286             {
287                 CSSMutableStyleDeclaration::const_iterator end = style->end();
288                 for (CSSMutableStyleDeclaration::const_iterator it = style->begin(); it != end; ++it) {
289                     const CSSProperty& property = *it;
290                     CSSValue* value = property.value();
291                     // The property value, if it's a percentage, may not reflect the actual computed value.  
292                     // For example: style="height: 1%; overflow: visible;" in quirksmode
293                     // FIXME: There are others like this, see <rdar://problem/5195123> Slashdot copy/paste fidelity problem
294                     if (value->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE)
295                         if (static_cast<CSSPrimitiveValue*>(value)->primitiveType() == CSSPrimitiveValue::CSS_PERCENTAGE)
296                             if (RefPtr<CSSValue> computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))
297                                 fromComputedStyle->addParsedProperty(CSSProperty(property.id(), computedPropertyValue));
298                 }
299             }
300             style->merge(fromComputedStyle.get());
301         }
302         if (addDisplayInline)
303             style->setProperty(CSSPropertyDisplay, CSSValueInline, true);
304         // If the node is not fully selected by the range, then we don't want to keep styles that affect its relationship to the nodes around it
305         // only the ones that affect it and the nodes within it.
306         if (rangeFullySelectsNode == DoesNotFullySelectNode)
307             removeExteriorStyles(style.get());
308         if (style->length() > 0) {
309             DEFINE_STATIC_LOCAL(const String, stylePrefix, (" style=\""));
310             append(out, stylePrefix);
311             appendAttributeValue(out, style->cssText(), documentIsHTML);
312             out.append('\"');
313         }
314     }
315
316     appendCloseTag(out, element);
317 }
318
319 void StyledMarkupAccumulator::removeExteriorStyles(CSSMutableStyleDeclaration* style)
320 {
321     style->removeProperty(CSSPropertyFloat);
322 }
323
324 Node* StyledMarkupAccumulator::serializeNodes(Node* startNode, Node* pastEnd)
325 {
326     Vector<Node*> ancestorsToClose;
327     Node* next;
328     Node* lastClosed = 0;
329     for (Node* n = startNode; n != pastEnd; n = next) {
330         // According to <rdar://problem/5730668>, it is possible for n to blow
331         // past pastEnd and become null here. This shouldn't be possible.
332         // This null check will prevent crashes (but create too much markup)
333         // and the ASSERT will hopefully lead us to understanding the problem.
334         ASSERT(n);
335         if (!n)
336             break;
337         
338         next = n->traverseNextNode();
339         bool openedTag = false;
340
341         if (isBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd)
342             // Don't write out empty block containers that aren't fully selected.
343             continue;
344
345         if (!n->renderer() && !enclosingNodeWithTag(Position(n, 0), selectTag)) {
346             next = n->traverseNextSibling();
347             // Don't skip over pastEnd.
348             if (pastEnd && pastEnd->isDescendantOf(n))
349                 next = pastEnd;
350         } else {
351             // Add the node to the markup if we're not skipping the descendants
352             appendStartTag(n);
353
354             // If node has no children, close the tag now.
355             if (!n->childNodeCount()) {
356                 appendEndTag(n);
357                 lastClosed = n;
358             } else {
359                 openedTag = true;
360                 ancestorsToClose.append(n);
361             }
362         }
363
364         // If we didn't insert open tag and there's no more siblings or we're at the end of the traversal, take care of ancestors.
365         // FIXME: What happens if we just inserted open tag and reached the end?
366         if (!openedTag && (!n->nextSibling() || next == pastEnd)) {
367             // Close up the ancestors.
368             while (!ancestorsToClose.isEmpty()) {
369                 Node* ancestor = ancestorsToClose.last();
370                 if (next != pastEnd && next->isDescendantOf(ancestor))
371                     break;
372                 // Not at the end of the range, close ancestors up to sibling of next node.
373                 appendEndTag(ancestor);
374                 lastClosed = ancestor;
375                 ancestorsToClose.removeLast();
376             }
377
378             // Surround the currently accumulated markup with markup for ancestors we never opened as we leave the subtree(s) rooted at those ancestors.
379             ContainerNode* nextParent = next ? next->parentNode() : 0;
380             if (next != pastEnd && n != nextParent) {
381                 Node* lastAncestorClosedOrSelf = n->isDescendantOf(lastClosed) ? lastClosed : n;
382                 for (ContainerNode* parent = lastAncestorClosedOrSelf->parent(); parent && parent != nextParent; parent = parent->parentNode()) {
383                     // All ancestors that aren't in the ancestorsToClose list should either be a) unrendered:
384                     if (!parent->renderer())
385                         continue;
386                     // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
387                     ASSERT(startNode->isDescendantOf(parent));
388                     wrapWithNode(parent);
389                     lastClosed = parent;
390                 }
391             }
392         }
393     }
394
395     return lastClosed;
396 }
397
398 static Node* ancestorToRetainStructureAndAppearance(Node* commonAncestor)
399 {
400     Node* commonAncestorBlock = enclosingBlock(commonAncestor);
401
402     if (!commonAncestorBlock)
403         return 0;
404
405     if (commonAncestorBlock->hasTagName(tbodyTag) || commonAncestorBlock->hasTagName(trTag)) {
406         ContainerNode* table = commonAncestorBlock->parentNode();
407         while (table && !table->hasTagName(tableTag))
408             table = table->parentNode();
409
410         return table;
411     }
412
413     if (commonAncestorBlock->hasTagName(listingTag)
414         || commonAncestorBlock->hasTagName(olTag)
415         || commonAncestorBlock->hasTagName(preTag)
416         || commonAncestorBlock->hasTagName(tableTag)
417         || commonAncestorBlock->hasTagName(ulTag)
418         || commonAncestorBlock->hasTagName(xmpTag)
419         || commonAncestorBlock->hasTagName(h1Tag)
420         || commonAncestorBlock->hasTagName(h2Tag)
421         || commonAncestorBlock->hasTagName(h3Tag)
422         || commonAncestorBlock->hasTagName(h4Tag)
423         || commonAncestorBlock->hasTagName(h5Tag))
424         return commonAncestorBlock;
425
426     return 0;
427 }
428
429 static bool propertyMissingOrEqualToNone(CSSStyleDeclaration* style, int propertyID)
430 {
431     if (!style)
432         return false;
433     RefPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);
434     if (!value)
435         return true;
436     if (!value->isPrimitiveValue())
437         return false;
438     return static_cast<CSSPrimitiveValue*>(value.get())->getIdent() == CSSValueNone;
439 }
440
441 static bool needInterchangeNewlineAfter(const VisiblePosition& v)
442 {
443     VisiblePosition next = v.next();
444     Node* upstreamNode = next.deepEquivalent().upstream().node();
445     Node* downstreamNode = v.deepEquivalent().downstream().node();
446     // Add an interchange newline if a paragraph break is selected and a br won't already be added to the markup to represent it.
447     return isEndOfParagraph(v) && isStartOfParagraph(next) && !(upstreamNode->hasTagName(brTag) && upstreamNode == downstreamNode);
448 }
449
450 static PassRefPtr<CSSMutableStyleDeclaration> styleFromMatchedRulesAndInlineDecl(const Node* node)
451 {
452     if (!node->isHTMLElement())
453         return 0;
454
455     // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to untangle
456     // the non-const-ness of styleFromMatchedRulesForElement.
457     HTMLElement* element = const_cast<HTMLElement*>(static_cast<const HTMLElement*>(node));
458     RefPtr<CSSMutableStyleDeclaration> style = styleFromMatchedRulesForElement(element);
459     RefPtr<CSSMutableStyleDeclaration> inlineStyleDecl = element->getInlineStyleDecl();
460     style->merge(inlineStyleDecl.get());
461     return style.release();
462 }
463
464 static bool isElementPresentational(const Node* node)
465 {
466     if (node->hasTagName(uTag) || node->hasTagName(sTag) || node->hasTagName(strikeTag)
467         || node->hasTagName(iTag) || node->hasTagName(emTag) || node->hasTagName(bTag) || node->hasTagName(strongTag))
468         return true;
469     RefPtr<CSSMutableStyleDeclaration> style = styleFromMatchedRulesAndInlineDecl(node);
470     if (!style)
471         return false;
472     return !propertyMissingOrEqualToNone(style.get(), CSSPropertyTextDecoration);
473 }
474
475 static bool shouldIncludeWrapperForFullySelectedRoot(Node* fullySelectedRoot, CSSMutableStyleDeclaration* style)
476 {
477     if (fullySelectedRoot->isElementNode() && static_cast<Element*>(fullySelectedRoot)->hasAttribute(backgroundAttr))
478         return true;
479     
480     return style->getPropertyCSSValue(CSSPropertyBackgroundImage) || style->getPropertyCSSValue(CSSPropertyBackgroundColor);
481 }
482
483 static Node* highestAncestorToWrapMarkup(const Range* range, Node* fullySelectedRoot, EAnnotateForInterchange shouldAnnotate)
484 {
485     ExceptionCode ec;
486     Node* commonAncestor = range->commonAncestorContainer(ec);
487     ASSERT(commonAncestor);
488     Node* specialCommonAncestor = 0;
489     if (shouldAnnotate == AnnotateForInterchange) {
490         // Include ancestors that aren't completely inside the range but are required to retain 
491         // the structure and appearance of the copied markup.
492         specialCommonAncestor = ancestorToRetainStructureAndAppearance(commonAncestor);
493
494         // Retain the Mail quote level by including all ancestor mail block quotes.
495         for (Node* ancestor = range->firstNode(); ancestor; ancestor = ancestor->parentNode()) {
496             if (isMailBlockquote(ancestor))
497                 specialCommonAncestor = ancestor;
498         }
499     }
500
501     Node* checkAncestor = specialCommonAncestor ? specialCommonAncestor : commonAncestor;
502     if (checkAncestor->renderer()) {
503         Node* newSpecialCommonAncestor = highestEnclosingNodeOfType(Position(checkAncestor, 0), &isElementPresentational);
504         if (newSpecialCommonAncestor)
505             specialCommonAncestor = newSpecialCommonAncestor;
506     }
507
508     // If a single tab is selected, commonAncestor will be a text node inside a tab span.
509     // If two or more tabs are selected, commonAncestor will be the tab span.
510     // In either case, if there is a specialCommonAncestor already, it will necessarily be above 
511     // any tab span that needs to be included.
512     if (!specialCommonAncestor && isTabSpanTextNode(commonAncestor))
513         specialCommonAncestor = commonAncestor->parentNode();
514     if (!specialCommonAncestor && isTabSpanNode(commonAncestor))
515         specialCommonAncestor = commonAncestor;
516
517     if (Node *enclosingAnchor = enclosingNodeWithTag(Position(specialCommonAncestor ? specialCommonAncestor : commonAncestor, 0), aTag))
518         specialCommonAncestor = enclosingAnchor;
519
520     if (shouldAnnotate == AnnotateForInterchange && fullySelectedRoot) {
521         RefPtr<CSSMutableStyleDeclaration> fullySelectedRootStyle = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
522         if (shouldIncludeWrapperForFullySelectedRoot(fullySelectedRoot, fullySelectedRootStyle.get()))
523             specialCommonAncestor = fullySelectedRoot;
524     }
525     return specialCommonAncestor;
526 }
527
528 static void removeEnclosingMailBlockquoteStyle(CSSMutableStyleDeclaration* style, Node* node)
529 {
530     Node* blockquote = nearestMailBlockquote(node);
531     if (!blockquote || !blockquote->parentNode())
532         return;
533
534     removeStylesAddedByNode(style, blockquote);
535 }
536
537 static void removeDefaultStyles(CSSMutableStyleDeclaration* style, Document* document)
538 {
539     if (!document || !document->documentElement())
540         return;
541
542     prepareEditingStyleToApplyAt(style, Position(document->documentElement(), 0));
543 }
544
545 // FIXME: Shouldn't we omit style info when annotate == DoNotAnnotateForInterchange? 
546 // FIXME: At least, annotation and style info should probably not be included in range.markupString()
547 String createMarkup(const Range* range, Vector<Node*>* nodes, EAnnotateForInterchange shouldAnnotate, bool convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs)
548 {
549     DEFINE_STATIC_LOCAL(const String, interchangeNewlineString, ("<br class=\"" AppleInterchangeNewline "\">"));
550
551     if (!range)
552         return "";
553
554     Document* document = range->ownerDocument();
555     if (!document)
556         return "";
557
558     // Disable the delete button so it's elements are not serialized into the markup,
559     // but make sure neither endpoint is inside the delete user interface.
560     Frame* frame = document->frame();
561     DeleteButtonController* deleteButton = frame ? frame->editor()->deleteButtonController() : 0;
562     RefPtr<Range> updatedRange = avoidIntersectionWithNode(range, deleteButton ? deleteButton->containerElement() : 0);
563     if (!updatedRange)
564         return "";
565
566     if (deleteButton)
567         deleteButton->disable();
568
569     ExceptionCode ec = 0;
570     bool collapsed = updatedRange->collapsed(ec);
571     ASSERT(!ec);
572     if (collapsed)
573         return "";
574     Node* commonAncestor = updatedRange->commonAncestorContainer(ec);
575     ASSERT(!ec);
576     if (!commonAncestor)
577         return "";
578
579     document->updateLayoutIgnorePendingStylesheets();
580
581     StyledMarkupAccumulator accumulator(nodes, shouldResolveURLs, shouldAnnotate, updatedRange.get());
582     Node* pastEnd = updatedRange->pastLastNode();
583
584     Node* startNode = updatedRange->firstNode();
585     VisiblePosition visibleStart(updatedRange->startPosition(), VP_DEFAULT_AFFINITY);
586     VisiblePosition visibleEnd(updatedRange->endPosition(), VP_DEFAULT_AFFINITY);
587     if (shouldAnnotate == AnnotateForInterchange && needInterchangeNewlineAfter(visibleStart)) {
588         if (visibleStart == visibleEnd.previous()) {
589             if (deleteButton)
590                 deleteButton->enable();
591             return interchangeNewlineString;
592         }
593
594         accumulator.appendString(interchangeNewlineString);
595         startNode = visibleStart.next().deepEquivalent().node();
596
597         if (pastEnd && Range::compareBoundaryPoints(startNode, 0, pastEnd, 0) >= 0) {
598             if (deleteButton)
599                 deleteButton->enable();
600             return interchangeNewlineString;
601         }
602     }
603
604     Node* body = enclosingNodeWithTag(Position(commonAncestor, 0), bodyTag);
605     Node* fullySelectedRoot = 0;
606     // FIXME: Do this for all fully selected blocks, not just the body.
607     if (body && areRangesEqual(VisibleSelection::selectionFromContentsOfNode(body).toNormalizedRange().get(), range))
608         fullySelectedRoot = body;
609
610     Node* specialCommonAncestor = highestAncestorToWrapMarkup(updatedRange.get(), fullySelectedRoot, shouldAnnotate);
611
612     Node* lastClosed = accumulator.serializeNodes(startNode, pastEnd);
613
614     if (specialCommonAncestor && lastClosed) {
615         // Also include all of the ancestors of lastClosed up to this special ancestor.
616         for (ContainerNode* ancestor = lastClosed->parentNode(); ancestor; ancestor = ancestor->parentNode()) {
617             if (ancestor == fullySelectedRoot && !convertBlocksToInlines) {
618                 RefPtr<CSSMutableStyleDeclaration> fullySelectedRootStyle = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
619
620                 // Bring the background attribute over, but not as an attribute because a background attribute on a div
621                 // appears to have no effect.
622                 if (!fullySelectedRootStyle->getPropertyCSSValue(CSSPropertyBackgroundImage) && static_cast<Element*>(fullySelectedRoot)->hasAttribute(backgroundAttr))
623                     fullySelectedRootStyle->setProperty(CSSPropertyBackgroundImage, "url('" + static_cast<Element*>(fullySelectedRoot)->getAttribute(backgroundAttr) + "')");
624                 
625                 if (fullySelectedRootStyle->length()) {
626                     // Reset the CSS properties to avoid an assertion error in addStyleMarkup().
627                     // This assertion is caused at least when we select all text of a <body> element whose
628                     // 'text-decoration' property is "inherit", and copy it.
629                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle.get(), CSSPropertyTextDecoration))
630                         fullySelectedRootStyle->setProperty(CSSPropertyTextDecoration, CSSValueNone);
631                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle.get(), CSSPropertyWebkitTextDecorationsInEffect))
632                         fullySelectedRootStyle->setProperty(CSSPropertyWebkitTextDecorationsInEffect, CSSValueNone);
633                     accumulator.wrapWithStyleNode(fullySelectedRootStyle.get(), document, true);
634                 }
635             } else {
636                 // Since this node and all the other ancestors are not in the selection we want to set RangeFullySelectsNode to DoesNotFullySelectNode
637                 // so that styles that affect the exterior of the node are not included.
638                 accumulator.wrapWithNode(ancestor, convertBlocksToInlines, StyledMarkupAccumulator::DoesNotFullySelectNode);
639             }
640             if (nodes)
641                 nodes->append(ancestor);
642             
643             lastClosed = ancestor;
644             
645             if (ancestor == specialCommonAncestor)
646                 break;
647         }
648     }
649
650     // Add a wrapper span with the styles that all of the nodes in the markup inherit.
651     ContainerNode* parentOfLastClosed = lastClosed ? lastClosed->parentNode() : 0;
652     if (parentOfLastClosed && parentOfLastClosed->renderer()) {
653         RefPtr<CSSMutableStyleDeclaration> style = ApplyStyleCommand::editingStyleAtPosition(Position(parentOfLastClosed, 0));
654
655         // Styles that Mail blockquotes contribute should only be placed on the Mail blockquote, to help
656         // us differentiate those styles from ones that the user has applied.  This helps us
657         // get the color of content pasted into blockquotes right.
658         removeEnclosingMailBlockquoteStyle(style.get(), parentOfLastClosed);
659         
660         // Document default styles will be added on another wrapper span.
661         removeDefaultStyles(style.get(), document);
662         
663         // Since we are converting blocks to inlines, remove any inherited block properties that are in the style.
664         // This cuts out meaningless properties and prevents properties from magically affecting blocks later
665         // if the style is cloned for a new block element during a future editing operation.
666         if (convertBlocksToInlines)
667             style->removeBlockProperties();
668
669         if (style->length() > 0)
670             accumulator.wrapWithStyleNode(style.get(), document);
671     }
672     
673     if (lastClosed && lastClosed != document->documentElement()) {
674         // Add a style span with the document's default styles.  We add these in a separate
675         // span so that at paste time we can differentiate between document defaults and user
676         // applied styles.
677         RefPtr<CSSMutableStyleDeclaration> defaultStyle = ApplyStyleCommand::editingStyleAtPosition(Position(document->documentElement(), 0));
678
679         if (defaultStyle->length() > 0)
680             accumulator.wrapWithStyleNode(defaultStyle.get(), document);
681     }
682
683     // FIXME: The interchange newline should be placed in the block that it's in, not after all of the content, unconditionally.
684     if (shouldAnnotate == AnnotateForInterchange && needInterchangeNewlineAfter(visibleEnd.previous()))
685         accumulator.appendString(interchangeNewlineString);
686
687     if (deleteButton)
688         deleteButton->enable();
689
690     return accumulator.takeResults();
691 }
692
693 PassRefPtr<DocumentFragment> createFragmentFromMarkup(Document* document, const String& markup, const String& baseURL, FragmentScriptingPermission scriptingPermission)
694 {
695     // We use a fake body element here to trick the HTML parser to using the
696     // InBody insertion mode.  Really, all this code is wrong and need to be
697     // changed not to use deprecatedCreateContextualFragment.
698     RefPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(document);
699     // FIXME: This should not use deprecatedCreateContextualFragment
700     RefPtr<DocumentFragment> fragment = fakeBody->deprecatedCreateContextualFragment(markup, scriptingPermission);
701
702     if (fragment && !baseURL.isEmpty() && baseURL != blankURL() && baseURL != document->baseURL())
703         completeURLs(fragment.get(), baseURL);
704
705     return fragment.release();
706 }
707
708 String createMarkup(const Node* node, EChildrenOnly childrenOnly, Vector<Node*>* nodes, EAbsoluteURLs shouldResolveURLs)
709 {
710     if (!node)
711         return "";
712
713     HTMLElement* deleteButtonContainerElement = 0;
714     if (Frame* frame = node->document()->frame()) {
715         deleteButtonContainerElement = frame->editor()->deleteButtonController()->containerElement();
716         if (node->isDescendantOf(deleteButtonContainerElement))
717             return "";
718     }
719
720     MarkupAccumulator accumulator(nodes, shouldResolveURLs);
721     return accumulator.serializeNodes(const_cast<Node*>(node), deleteButtonContainerElement, childrenOnly);
722 }
723
724 static void fillContainerFromString(ContainerNode* paragraph, const String& string)
725 {
726     Document* document = paragraph->document();
727
728     ExceptionCode ec = 0;
729     if (string.isEmpty()) {
730         paragraph->appendChild(createBlockPlaceholderElement(document), ec);
731         ASSERT(!ec);
732         return;
733     }
734
735     ASSERT(string.find('\n') == notFound);
736
737     Vector<String> tabList;
738     string.split('\t', true, tabList);
739     String tabText = "";
740     bool first = true;
741     size_t numEntries = tabList.size();
742     for (size_t i = 0; i < numEntries; ++i) {
743         const String& s = tabList[i];
744
745         // append the non-tab textual part
746         if (!s.isEmpty()) {
747             if (!tabText.isEmpty()) {
748                 paragraph->appendChild(createTabSpanElement(document, tabText), ec);
749                 ASSERT(!ec);
750                 tabText = "";
751             }
752             RefPtr<Node> textNode = document->createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
753             paragraph->appendChild(textNode.release(), ec);
754             ASSERT(!ec);
755         }
756
757         // there is a tab after every entry, except the last entry
758         // (if the last character is a tab, the list gets an extra empty entry)
759         if (i + 1 != numEntries)
760             tabText.append('\t');
761         else if (!tabText.isEmpty()) {
762             paragraph->appendChild(createTabSpanElement(document, tabText), ec);
763             ASSERT(!ec);
764         }
765         
766         first = false;
767     }
768 }
769
770 bool isPlainTextMarkup(Node *node)
771 {
772     if (!node->isElementNode() || !node->hasTagName(divTag) || static_cast<Element*>(node)->attributes()->length())
773         return false;
774     
775     if (node->childNodeCount() == 1 && (node->firstChild()->isTextNode() || (node->firstChild()->firstChild())))
776         return true;
777     
778     return (node->childNodeCount() == 2 && isTabSpanTextNode(node->firstChild()->firstChild()) && node->firstChild()->nextSibling()->isTextNode());
779 }
780
781 PassRefPtr<DocumentFragment> createFragmentFromText(Range* context, const String& text)
782 {
783     if (!context)
784         return 0;
785
786     Node* styleNode = context->firstNode();
787     if (!styleNode) {
788         styleNode = context->startPosition().node();
789         if (!styleNode)
790             return 0;
791     }
792
793     Document* document = styleNode->document();
794     RefPtr<DocumentFragment> fragment = document->createDocumentFragment();
795     
796     if (text.isEmpty())
797         return fragment.release();
798
799     String string = text;
800     string.replace("\r\n", "\n");
801     string.replace('\r', '\n');
802
803     ExceptionCode ec = 0;
804     RenderObject* renderer = styleNode->renderer();
805     if (renderer && renderer->style()->preserveNewline()) {
806         fragment->appendChild(document->createTextNode(string), ec);
807         ASSERT(!ec);
808         if (string.endsWith("\n")) {
809             RefPtr<Element> element = createBreakElement(document);
810             element->setAttribute(classAttr, AppleInterchangeNewline);            
811             fragment->appendChild(element.release(), ec);
812             ASSERT(!ec);
813         }
814         return fragment.release();
815     }
816
817     // A string with no newlines gets added inline, rather than being put into a paragraph.
818     if (string.find('\n') == notFound) {
819         fillContainerFromString(fragment.get(), string);
820         return fragment.release();
821     }
822
823     // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
824     Node* blockNode = enclosingBlock(context->firstNode());
825     Element* block = static_cast<Element*>(blockNode);
826     bool useClonesOfEnclosingBlock = blockNode
827         && blockNode->isElementNode()
828         && !block->hasTagName(bodyTag)
829         && !block->hasTagName(htmlTag)
830         && block != editableRootForPosition(context->startPosition());
831     
832     Vector<String> list;
833     string.split('\n', true, list); // true gets us empty strings in the list
834     size_t numLines = list.size();
835     for (size_t i = 0; i < numLines; ++i) {
836         const String& s = list[i];
837
838         RefPtr<Element> element;
839         if (s.isEmpty() && i + 1 == numLines) {
840             // For last line, use the "magic BR" rather than a P.
841             element = createBreakElement(document);
842             element->setAttribute(classAttr, AppleInterchangeNewline);            
843         } else {
844             if (useClonesOfEnclosingBlock)
845                 element = block->cloneElementWithoutChildren();
846             else
847                 element = createDefaultParagraphElement(document);
848             fillContainerFromString(element.get(), s);
849         }
850         fragment->appendChild(element.release(), ec);
851         ASSERT(!ec);
852     }
853     return fragment.release();
854 }
855
856 PassRefPtr<DocumentFragment> createFragmentFromNodes(Document *document, const Vector<Node*>& nodes)
857 {
858     if (!document)
859         return 0;
860
861     // disable the delete button so it's elements are not serialized into the markup
862     if (document->frame())
863         document->frame()->editor()->deleteButtonController()->disable();
864
865     RefPtr<DocumentFragment> fragment = document->createDocumentFragment();
866
867     ExceptionCode ec = 0;
868     size_t size = nodes.size();
869     for (size_t i = 0; i < size; ++i) {
870         RefPtr<Element> element = createDefaultParagraphElement(document);
871         element->appendChild(nodes[i], ec);
872         ASSERT(!ec);
873         fragment->appendChild(element.release(), ec);
874         ASSERT(!ec);
875     }
876
877     if (document->frame())
878         document->frame()->editor()->deleteButtonController()->enable();
879
880     return fragment.release();
881 }
882
883 String createFullMarkup(const Node* node)
884 {
885     if (!node)
886         return String();
887         
888     Document* document = node->document();
889     if (!document)
890         return String();
891         
892     Frame* frame = document->frame();
893     if (!frame)
894         return String();
895
896     // FIXME: This is never "for interchange". Is that right?    
897     String markupString = createMarkup(node, IncludeNode, 0);
898     Node::NodeType nodeType = node->nodeType();
899     if (nodeType != Node::DOCUMENT_NODE && nodeType != Node::DOCUMENT_TYPE_NODE)
900         markupString = frame->documentTypeString() + markupString;
901
902     return markupString;
903 }
904
905 String createFullMarkup(const Range* range)
906 {
907     if (!range)
908         return String();
909
910     Node* node = range->startContainer();
911     if (!node)
912         return String();
913         
914     Document* document = node->document();
915     if (!document)
916         return String();
917         
918     Frame* frame = document->frame();
919     if (!frame)
920         return String();
921
922     // FIXME: This is always "for interchange". Is that right? See the previous method.
923     return frame->documentTypeString() + createMarkup(range, 0, AnnotateForInterchange);        
924 }
925
926 String urlToMarkup(const KURL& url, const String& title)
927 {
928     Vector<UChar> markup;
929     append(markup, "<a href=\"");
930     append(markup, url.string());
931     append(markup, "\">");
932     appendCharactersReplacingEntities(markup, title.characters(), title.length(), EntityMaskInPCDATA);
933     append(markup, "</a>");
934     return String::adopt(markup);
935 }
936
937 }