bcac20ef40eece244e76fdfb878b0935b06331ef
[WebKit-https.git] / Source / WebCore / editing / CompositeEditCommand.cpp
1 /*
2  * Copyright (C) 2005, 2006, 2007, 2008 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 "CompositeEditCommand.h"
28
29 #include "AppendNodeCommand.h"
30 #include "ApplyStyleCommand.h"
31 #include "CharacterNames.h"
32 #include "DeleteFromTextNodeCommand.h"
33 #include "DeleteSelectionCommand.h"
34 #include "Document.h"
35 #include "DocumentFragment.h"
36 #include "EditorInsertAction.h"
37 #include "Frame.h"
38 #include "HTMLElement.h"
39 #include "HTMLNames.h"
40 #include "InlineTextBox.h"
41 #include "InsertIntoTextNodeCommand.h"
42 #include "InsertLineBreakCommand.h"
43 #include "InsertNodeBeforeCommand.h"
44 #include "InsertParagraphSeparatorCommand.h"
45 #include "InsertTextCommand.h"
46 #include "JoinTextNodesCommand.h"
47 #include "MergeIdenticalElementsCommand.h"
48 #include "Range.h"
49 #include "RemoveCSSPropertyCommand.h"
50 #include "RemoveNodeCommand.h"
51 #include "RemoveNodePreservingChildrenCommand.h"
52 #include "ReplaceNodeWithSpanCommand.h"
53 #include "ReplaceSelectionCommand.h"
54 #include "RenderBlock.h"
55 #include "RenderText.h"
56 #include "SetNodeAttributeCommand.h"
57 #include "SplitElementCommand.h"
58 #include "SplitTextNodeCommand.h"
59 #include "SplitTextNodeContainingElementCommand.h"
60 #include "Text.h"
61 #include "TextIterator.h"
62 #include "WrapContentsInDummySpanCommand.h"
63 #include "htmlediting.h"
64 #include "markup.h"
65 #include "visible_units.h"
66
67 using namespace std;
68
69 namespace WebCore {
70
71 using namespace HTMLNames;
72
73 CompositeEditCommand::CompositeEditCommand(Document *document)
74     : EditCommand(document)
75 {
76 }
77
78 CompositeEditCommand::~CompositeEditCommand()
79 {
80 }
81
82 void CompositeEditCommand::doUnapply()
83 {
84     size_t size = m_commands.size();
85     for (size_t i = size; i != 0; --i)
86         m_commands[i - 1]->unapply();
87 }
88
89 void CompositeEditCommand::doReapply()
90 {
91     size_t size = m_commands.size();
92     for (size_t i = 0; i != size; ++i)
93         m_commands[i]->reapply();
94 }
95
96 //
97 // sugary-sweet convenience functions to help create and apply edit commands in composite commands
98 //
99 void CompositeEditCommand::applyCommandToComposite(PassRefPtr<EditCommand> cmd)
100 {
101     cmd->setParent(this);
102     cmd->apply();
103     m_commands.append(cmd);
104 }
105
106 void CompositeEditCommand::applyStyle(const EditingStyle* style, EditAction editingAction)
107 {
108     applyCommandToComposite(ApplyStyleCommand::create(document(), style, editingAction));
109 }
110
111 void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditAction editingAction)
112 {
113     applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end, editingAction));
114 }
115
116 void CompositeEditCommand::applyStyledElement(PassRefPtr<Element> element)
117 {
118     applyCommandToComposite(ApplyStyleCommand::create(element, false));
119 }
120
121 void CompositeEditCommand::removeStyledElement(PassRefPtr<Element> element)
122 {
123     applyCommandToComposite(ApplyStyleCommand::create(element, true));
124 }
125
126 void CompositeEditCommand::insertParagraphSeparator(bool useDefaultParagraphElement)
127 {
128     applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement));
129 }
130
131 void CompositeEditCommand::insertLineBreak()
132 {
133     applyCommandToComposite(InsertLineBreakCommand::create(document()));
134 }
135
136 void CompositeEditCommand::insertNodeBefore(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
137 {
138     ASSERT(!refChild->hasTagName(bodyTag));
139     applyCommandToComposite(InsertNodeBeforeCommand::create(insertChild, refChild));
140 }
141
142 void CompositeEditCommand::insertNodeAfter(PassRefPtr<Node> insertChild, PassRefPtr<Node> refChild)
143 {
144     ASSERT(insertChild);
145     ASSERT(refChild);
146     ASSERT(!refChild->hasTagName(bodyTag));
147     Element* parent = refChild->parentElement();
148     ASSERT(parent);
149     if (parent->lastChild() == refChild)
150         appendNode(insertChild, parent);
151     else {
152         ASSERT(refChild->nextSibling());
153         insertNodeBefore(insertChild, refChild->nextSibling());
154     }
155 }
156
157 void CompositeEditCommand::insertNodeAt(PassRefPtr<Node> insertChild, const Position& editingPosition)
158 {
159     ASSERT(isEditablePosition(editingPosition));
160     // For editing positions like [table, 0], insert before the table,
161     // likewise for replaced elements, brs, etc.
162     Position p = editingPosition.parentAnchoredEquivalent();
163     Node* refChild = p.node();
164     int offset = p.deprecatedEditingOffset();
165     
166     if (canHaveChildrenForEditing(refChild)) {
167         Node* child = refChild->firstChild();
168         for (int i = 0; child && i < offset; i++)
169             child = child->nextSibling();
170         if (child)
171             insertNodeBefore(insertChild, child);
172         else
173             appendNode(insertChild, static_cast<Element*>(refChild));
174     } else if (caretMinOffset(refChild) >= offset)
175         insertNodeBefore(insertChild, refChild);
176     else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
177         splitTextNode(static_cast<Text *>(refChild), offset);
178
179         // Mutation events (bug 22634) from the text node insertion may have removed the refChild
180         if (!refChild->inDocument())
181             return;
182         insertNodeBefore(insertChild, refChild);
183     } else
184         insertNodeAfter(insertChild, refChild);
185 }
186
187 void CompositeEditCommand::appendNode(PassRefPtr<Node> node, PassRefPtr<Element> parent)
188 {
189     ASSERT(canHaveChildrenForEditing(parent.get()));
190     applyCommandToComposite(AppendNodeCommand::create(parent, node));
191 }
192
193 void CompositeEditCommand::removeChildrenInRange(PassRefPtr<Node> node, unsigned from, unsigned to)
194 {
195     Vector<RefPtr<Node> > children;
196     Node* child = node->childNode(from);
197     for (unsigned i = from; child && i < to; i++, child = child->nextSibling())
198         children.append(child);
199
200     size_t size = children.size();
201     for (size_t i = 0; i < size; ++i)
202         removeNode(children[i].release());
203 }
204
205 void CompositeEditCommand::removeNode(PassRefPtr<Node> node)
206 {
207     if (!node || !node->parentNode())
208         return;
209     applyCommandToComposite(RemoveNodeCommand::create(node));
210 }
211
212 void CompositeEditCommand::removeNodePreservingChildren(PassRefPtr<Node> node)
213 {
214     applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(node));
215 }
216
217 void CompositeEditCommand::removeNodeAndPruneAncestors(PassRefPtr<Node> node)
218 {
219     RefPtr<ContainerNode> parent = node->parentNode();
220     removeNode(node);
221     prune(parent.release());
222 }
223
224 HTMLElement* CompositeEditCommand::replaceElementWithSpanPreservingChildrenAndAttributes(PassRefPtr<HTMLElement> node)
225 {
226     // It would also be possible to implement all of ReplaceNodeWithSpanCommand
227     // as a series of existing smaller edit commands.  Someone who wanted to
228     // reduce the number of edit commands could do so here.
229     RefPtr<ReplaceNodeWithSpanCommand> command = ReplaceNodeWithSpanCommand::create(node);
230     applyCommandToComposite(command);
231     // Returning a raw pointer here is OK because the command is retained by
232     // applyCommandToComposite (thus retaining the span), and the span is also
233     // in the DOM tree, and thus alive whie it has a parent.
234     ASSERT(command->spanElement()->inDocument());
235     return command->spanElement();
236 }
237
238 static bool hasARenderedDescendant(Node* node)
239 {
240     Node* n = node->firstChild();
241     while (n) {
242         if (n->renderer())
243             return true;
244         n = n->traverseNextNode(node);
245     }
246     return false;
247 }
248
249 void CompositeEditCommand::prune(PassRefPtr<Node> node)
250 {
251     while (node) {
252         // If you change this rule you may have to add an updateLayout() here.
253         RenderObject* renderer = node->renderer();
254         if (renderer && (!renderer->canHaveChildren() || hasARenderedDescendant(node.get()) || node->rootEditableElement() == node))
255             return;
256             
257         RefPtr<ContainerNode> next = node->parentNode();
258         removeNode(node);
259         node = next;
260     }
261 }
262
263 void CompositeEditCommand::splitTextNode(PassRefPtr<Text> node, unsigned offset)
264 {
265     applyCommandToComposite(SplitTextNodeCommand::create(node, offset));
266 }
267
268 void CompositeEditCommand::splitElement(PassRefPtr<Element> element, PassRefPtr<Node> atChild)
269 {
270     applyCommandToComposite(SplitElementCommand::create(element, atChild));
271 }
272
273 void CompositeEditCommand::mergeIdenticalElements(PassRefPtr<Element> prpFirst, PassRefPtr<Element> prpSecond)
274 {
275     RefPtr<Element> first = prpFirst;
276     RefPtr<Element> second = prpSecond;
277     ASSERT(!first->isDescendantOf(second.get()) && second != first);
278     if (first->nextSibling() != second) {
279         removeNode(second);
280         insertNodeAfter(second, first);
281     }
282     applyCommandToComposite(MergeIdenticalElementsCommand::create(first, second));
283 }
284
285 void CompositeEditCommand::wrapContentsInDummySpan(PassRefPtr<Element> element)
286 {
287     applyCommandToComposite(WrapContentsInDummySpanCommand::create(element));
288 }
289
290 void CompositeEditCommand::splitTextNodeContainingElement(PassRefPtr<Text> text, unsigned offset)
291 {
292     applyCommandToComposite(SplitTextNodeContainingElementCommand::create(text, offset));
293 }
294
295 void CompositeEditCommand::joinTextNodes(PassRefPtr<Text> text1, PassRefPtr<Text> text2)
296 {
297     applyCommandToComposite(JoinTextNodesCommand::create(text1, text2));
298 }
299
300 void CompositeEditCommand::inputText(const String& text, bool selectInsertedText)
301 {
302     unsigned offset = 0;
303     unsigned length = text.length();
304     RefPtr<Range> startRange = Range::create(document(), firstPositionInNode(document()->documentElement()), endingSelection().start());
305     unsigned startIndex = TextIterator::rangeLength(startRange.get());
306     size_t newline;
307     do {
308         newline = text.find('\n', offset);
309         if (newline != offset) {
310             RefPtr<InsertTextCommand> command = InsertTextCommand::create(document());
311             applyCommandToComposite(command);
312             int substringLength = newline == notFound ? length - offset : newline - offset;
313             command->input(text.substring(offset, substringLength), false);
314         }
315         if (newline != notFound)
316             insertLineBreak();
317             
318         offset = newline + 1;
319     } while (newline != notFound && offset != length);
320     
321     if (selectInsertedText) {
322         RefPtr<Range> selectedRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, length);
323         setEndingSelection(VisibleSelection(selectedRange.get()));
324     }
325 }
326
327 void CompositeEditCommand::insertTextIntoNode(PassRefPtr<Text> node, unsigned offset, const String& text)
328 {
329     applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, text));
330 }
331
332 void CompositeEditCommand::deleteTextFromNode(PassRefPtr<Text> node, unsigned offset, unsigned count)
333 {
334     applyCommandToComposite(DeleteFromTextNodeCommand::create(node, offset, count));
335 }
336
337 void CompositeEditCommand::replaceTextInNode(PassRefPtr<Text> node, unsigned offset, unsigned count, const String& replacementText)
338 {
339     applyCommandToComposite(DeleteFromTextNodeCommand::create(node.get(), offset, count));
340     applyCommandToComposite(InsertIntoTextNodeCommand::create(node, offset, replacementText));
341 }
342
343 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
344 {
345     if (!isTabSpanTextNode(pos.node()))
346         return pos;
347     
348     Node* tabSpan = tabSpanNode(pos.node());
349     
350     if (pos.deprecatedEditingOffset() <= caretMinOffset(pos.node()))
351         return positionInParentBeforeNode(tabSpan);
352         
353     if (pos.deprecatedEditingOffset() >= caretMaxOffset(pos.node()))
354         return positionInParentAfterNode(tabSpan);
355
356     splitTextNodeContainingElement(static_cast<Text *>(pos.node()), pos.deprecatedEditingOffset());
357     return positionInParentBeforeNode(tabSpan);
358 }
359
360 void CompositeEditCommand::insertNodeAtTabSpanPosition(PassRefPtr<Node> node, const Position& pos)
361 {
362     // insert node before, after, or at split of tab span
363     insertNodeAt(node, positionOutsideTabSpan(pos));
364 }
365
366 void CompositeEditCommand::deleteSelection(bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
367 {
368     if (endingSelection().isRange())
369         applyCommandToComposite(DeleteSelectionCommand::create(document(), smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
370 }
371
372 void CompositeEditCommand::deleteSelection(const VisibleSelection &selection, bool smartDelete, bool mergeBlocksAfterDelete, bool replace, bool expandForSpecialElements)
373 {
374     if (selection.isRange())
375         applyCommandToComposite(DeleteSelectionCommand::create(selection, smartDelete, mergeBlocksAfterDelete, replace, expandForSpecialElements));
376 }
377
378 void CompositeEditCommand::removeCSSProperty(PassRefPtr<StyledElement> element, CSSPropertyID property)
379 {
380     applyCommandToComposite(RemoveCSSPropertyCommand::create(document(), element, property));
381 }
382
383 void CompositeEditCommand::removeNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute)
384 {
385     setNodeAttribute(element, attribute, AtomicString());
386 }
387
388 void CompositeEditCommand::setNodeAttribute(PassRefPtr<Element> element, const QualifiedName& attribute, const AtomicString& value)
389 {
390     applyCommandToComposite(SetNodeAttributeCommand::create(element, attribute, value));
391 }
392
393 static inline bool containsOnlyWhitespace(const String& text)
394 {
395     for (unsigned i = 0; i < text.length(); ++i) {
396         if (!isWhitespace(text.characters()[i]))
397             return false;
398     }
399     
400     return true;
401 }
402
403 bool CompositeEditCommand::shouldRebalanceLeadingWhitespaceFor(const String& text) const
404 {
405     return containsOnlyWhitespace(text);
406 }
407
408 bool CompositeEditCommand::canRebalance(const Position& position) const
409 {
410     Node* node = position.containerNode();
411     if (position.anchorType() != Position::PositionIsOffsetInAnchor || !node || !node->isTextNode())
412         return false;
413
414     Text* textNode = static_cast<Text*>(node);
415     if (textNode->length() == 0)
416         return false;
417
418     RenderObject* renderer = textNode->renderer();
419     if (renderer && !renderer->style()->collapseWhiteSpace())
420         return false;
421
422     return true;
423 }
424
425 // FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
426 void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position)
427 {
428     Node* node = position.containerNode();
429     if (!canRebalance(position))
430         return;
431
432     // If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
433     int offset = position.deprecatedEditingOffset();
434     String text = static_cast<Text*>(node)->data();
435     if (!isWhitespace(text[offset])) {
436         offset--;
437         if (offset < 0 || !isWhitespace(text[offset]))
438             return;
439     }
440
441     rebalanceWhitespaceOnTextSubstring(static_cast<Text*>(node), position.offsetInContainerNode(), position.offsetInContainerNode());
442 }
443
444 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(RefPtr<Text> textNode, int startOffset, int endOffset)
445 {
446     String text = textNode->data();
447     ASSERT(!text.isEmpty());
448
449     // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
450     int upstream = startOffset;
451     while (upstream > 0 && isWhitespace(text[upstream - 1]))
452         upstream--;
453     
454     int downstream = endOffset;
455     while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
456         downstream++;
457     
458     int length = downstream - upstream;
459     if (!length)
460         return;
461
462     VisiblePosition visibleUpstreamPos(Position(textNode, upstream, Position::PositionIsOffsetInAnchor));
463     VisiblePosition visibleDownstreamPos(Position(textNode, downstream, Position::PositionIsOffsetInAnchor));
464     
465     String string = text.substring(upstream, length);
466     String rebalancedString = stringWithRebalancedWhitespace(string,
467     // FIXME: Because of the problem mentioned at the top of this function, we must also use nbsps at the start/end of the string because
468     // this function doesn't get all surrounding whitespace, just the whitespace in the current text node.
469                                                              isStartOfParagraph(visibleUpstreamPos) || upstream == 0, 
470                                                              isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length());
471     
472     if (string != rebalancedString)
473         replaceTextInNode(textNode, upstream, length, rebalancedString);
474 }
475
476 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
477 {
478     Node* node = position.node();
479     if (!node || !node->isTextNode())
480         return;
481     Text* textNode = static_cast<Text*>(node);    
482     
483     if (textNode->length() == 0)
484         return;
485     RenderObject* renderer = textNode->renderer();
486     if (renderer && !renderer->style()->collapseWhiteSpace())
487         return;
488
489     // Delete collapsed whitespace so that inserting nbsps doesn't uncollapse it.
490     Position upstreamPos = position.upstream();
491     deleteInsignificantText(position.upstream(), position.downstream());
492     position = upstreamPos.downstream();
493
494     VisiblePosition visiblePos(position);
495     VisiblePosition previousVisiblePos(visiblePos.previous());
496     Position previous(previousVisiblePos.deepEquivalent());
497     
498     if (isCollapsibleWhitespace(previousVisiblePos.characterAfter()) && previous.node()->isTextNode() && !previous.node()->hasTagName(brTag))
499         replaceTextInNode(static_cast<Text*>(previous.node()), previous.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
500     if (isCollapsibleWhitespace(visiblePos.characterAfter()) && position.node()->isTextNode() && !position.node()->hasTagName(brTag))
501         replaceTextInNode(static_cast<Text*>(position.node()), position.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
502 }
503
504 void CompositeEditCommand::rebalanceWhitespace()
505 {
506     VisibleSelection selection = endingSelection();
507     if (selection.isNone())
508         return;
509         
510     rebalanceWhitespaceAt(selection.start());
511     if (selection.isRange())
512         rebalanceWhitespaceAt(selection.end());
513 }
514
515 void CompositeEditCommand::deleteInsignificantText(PassRefPtr<Text> textNode, unsigned start, unsigned end)
516 {
517     if (!textNode || start >= end)
518         return;
519
520     RenderText* textRenderer = toRenderText(textNode->renderer());
521     if (!textRenderer)
522         return;
523
524     Vector<InlineTextBox*> sortedTextBoxes;
525     size_t sortedTextBoxesPosition = 0;
526    
527     for (InlineTextBox* textBox = textRenderer->firstTextBox(); textBox; textBox = textBox->nextTextBox())
528         sortedTextBoxes.append(textBox);
529     
530     // If there is mixed directionality text, the boxes can be out of order,
531     // (like Arabic with embedded LTR), so sort them first. 
532     if (textRenderer->containsReversedText())    
533         std::sort(sortedTextBoxes.begin(), sortedTextBoxes.end(), InlineTextBox::compareByStart);
534     InlineTextBox* box = sortedTextBoxes.isEmpty() ? 0 : sortedTextBoxes[sortedTextBoxesPosition];
535
536     if (!box) {
537         // whole text node is empty
538         removeNode(textNode);
539         return;    
540     }
541     
542     unsigned length = textNode->length();
543     if (start >= length || end > length)
544         return;
545
546     unsigned removed = 0;
547     InlineTextBox* prevBox = 0;
548     String str;
549
550     // This loop structure works to process all gaps preceding a box,
551     // and also will look at the gap after the last box.
552     while (prevBox || box) {
553         unsigned gapStart = prevBox ? prevBox->start() + prevBox->len() : 0;
554         if (end < gapStart)
555             // No more chance for any intersections
556             break;
557
558         unsigned gapEnd = box ? box->start() : length;
559         bool indicesIntersect = start <= gapEnd && end >= gapStart;
560         int gapLen = gapEnd - gapStart;
561         if (indicesIntersect && gapLen > 0) {
562             gapStart = max(gapStart, start);
563             gapEnd = min(gapEnd, end);
564             if (str.isNull())
565                 str = textNode->data().substring(start, end - start);
566             // remove text in the gap
567             str.remove(gapStart - start - removed, gapLen);
568             removed += gapLen;
569         }
570         
571         prevBox = box;
572         if (box) {
573             if (++sortedTextBoxesPosition < sortedTextBoxes.size())
574                 box = sortedTextBoxes[sortedTextBoxesPosition];
575             else
576                 box = 0;
577         }
578     }
579
580     if (!str.isNull()) {
581         // Replace the text between start and end with our pruned version.
582         if (!str.isEmpty())
583             replaceTextInNode(textNode, start, end - start, str);
584         else {
585             // Assert that we are not going to delete all of the text in the node.
586             // If we were, that should have been done above with the call to 
587             // removeNode and return.
588             ASSERT(start > 0 || end - start < textNode->length());
589             deleteTextFromNode(textNode, start, end - start);
590         }
591     }
592 }
593
594 void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
595 {
596     if (start.isNull() || end.isNull())
597         return;
598
599     if (comparePositions(start, end) >= 0)
600         return;
601
602     Node* next;
603     for (Node* node = start.node(); node; node = next) {
604         next = node->traverseNextNode();
605         if (node->isTextNode()) {
606             Text* textNode = static_cast<Text*>(node);
607             int startOffset = node == start.node() ? start.deprecatedEditingOffset() : 0;
608             int endOffset = node == end.node() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
609             deleteInsignificantText(textNode, startOffset, endOffset);
610         }
611         if (node == end.node())
612             break;
613     }
614 }
615
616 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
617 {
618     Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
619     deleteInsignificantText(pos, end);
620 }
621
622 PassRefPtr<Node> CompositeEditCommand::appendBlockPlaceholder(PassRefPtr<Element> container)
623 {
624     if (!container)
625         return 0;
626     
627     // Should assert isBlockFlow || isInlineFlow when deletion improves. See 4244964.
628     ASSERT(container->renderer());
629
630     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
631     appendNode(placeholder, container);
632     return placeholder.release();
633 }
634
635 PassRefPtr<Node> CompositeEditCommand::insertBlockPlaceholder(const Position& pos)
636 {
637     if (pos.isNull())
638         return 0;
639
640     // Should assert isBlockFlow || isInlineFlow when deletion improves.  See 4244964.
641     ASSERT(pos.node()->renderer());
642
643     RefPtr<Node> placeholder = createBlockPlaceholderElement(document());
644     insertNodeAt(placeholder, pos);
645     return placeholder.release();
646 }
647
648 PassRefPtr<Node> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* container)
649 {
650     if (!container)
651         return 0;
652
653     updateLayout();
654
655     RenderObject* renderer = container->renderer();
656     if (!renderer || !renderer->isBlockFlow())
657         return 0;
658     
659     // append the placeholder to make sure it follows
660     // any unrendered blocks
661     RenderBlock* block = toRenderBlock(renderer);
662     if (block->height() == 0 || (block->isListItem() && block->isEmpty()))
663         return appendBlockPlaceholder(container);
664
665     return 0;
666 }
667
668 // Assumes that the position is at a placeholder and does the removal without much checking.
669 void CompositeEditCommand::removePlaceholderAt(const Position& p)
670 {
671     ASSERT(lineBreakExistsAtPosition(p));
672     
673     // We are certain that the position is at a line break, but it may be a br or a preserved newline.
674     if (p.anchorNode()->hasTagName(brTag)) {
675         removeNode(p.anchorNode());
676         return;
677     }
678     
679     deleteTextFromNode(static_cast<Text*>(p.anchorNode()), p.offsetInContainerNode(), 1);
680 }
681
682 PassRefPtr<Node> CompositeEditCommand::insertNewDefaultParagraphElementAt(const Position& position)
683 {
684     RefPtr<Element> paragraphElement = createDefaultParagraphElement(document());
685     ExceptionCode ec;
686     paragraphElement->appendChild(createBreakElement(document()), ec);
687     insertNodeAt(paragraphElement, position);
688     return paragraphElement.release();
689 }
690
691 // If the paragraph is not entirely within it's own block, create one and move the paragraph into 
692 // it, and return that block.  Otherwise return 0.
693 PassRefPtr<Node> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos)
694 {
695     if (pos.isNull())
696         return 0;
697     
698     updateLayout();
699     
700     // It's strange that this function is responsible for verifying that pos has not been invalidated
701     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
702     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
703     VisiblePosition visibleParagraphStart(startOfParagraph(visiblePos));
704     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
705     VisiblePosition next = visibleParagraphEnd.next();
706     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
707     
708     Position upstreamStart = visibleParagraphStart.deepEquivalent().upstream();
709     Position upstreamEnd = visibleEnd.deepEquivalent().upstream();
710
711     // If there are no VisiblePositions in the same block as pos then 
712     // upstreamStart will be outside the paragraph
713     if (comparePositions(pos, upstreamStart) < 0)
714         return 0;
715
716     // Perform some checks to see if we need to perform work in this function.
717     if (isBlock(upstreamStart.node())) {
718         // If the block is the root editable element, always move content to a new block,
719         // since it is illegal to modify attributes on the root editable element for editing.
720         if (upstreamStart.node() == editableRootForPosition(upstreamStart)) {
721             // If the block is the root editable element and it contains no visible content, create a new
722             // block but don't try and move content into it, since there's nothing for moveParagraphs to move.
723             if (!Position::hasRenderedNonAnonymousDescendantsWithHeight(upstreamStart.node()->renderer()))
724                 return insertNewDefaultParagraphElementAt(upstreamStart);
725         } else if (isBlock(upstreamEnd.node())) {
726             if (!upstreamEnd.node()->isDescendantOf(upstreamStart.node())) {
727                 // If the paragraph end is a descendant of paragraph start, then we need to run
728                 // the rest of this function. If not, we can bail here.
729                 return 0;
730             }
731         }
732         else if (enclosingBlock(upstreamEnd.node()) != upstreamStart.node()) {
733             // The visibleEnd.  It must be an ancestor of the paragraph start.
734             // We can bail as we have a full block to work with.
735             ASSERT(upstreamStart.node()->isDescendantOf(enclosingBlock(upstreamEnd.node())));
736             return 0;
737         }
738         else if (isEndOfDocument(visibleEnd)) {
739             // At the end of the document. We can bail here as well.
740             return 0;
741         }
742     }
743
744     RefPtr<Node> newBlock = insertNewDefaultParagraphElementAt(upstreamStart);
745
746     bool endWasBr = visibleParagraphEnd.deepEquivalent().node()->hasTagName(brTag);
747
748     moveParagraphs(visibleParagraphStart, visibleParagraphEnd, VisiblePosition(firstPositionInNode(newBlock.get())));
749
750     if (newBlock->lastChild() && newBlock->lastChild()->hasTagName(brTag) && !endWasBr)
751         removeNode(newBlock->lastChild());
752
753     return newBlock.release();
754 }
755
756 void CompositeEditCommand::pushAnchorElementDown(Node* anchorNode)
757 {
758     if (!anchorNode)
759         return;
760     
761     ASSERT(anchorNode->isLink());
762     
763     setEndingSelection(VisibleSelection::selectionFromContentsOfNode(anchorNode));
764     applyStyledElement(static_cast<Element*>(anchorNode));
765     // Clones of anchorNode have been pushed down, now remove it.
766     if (anchorNode->inDocument())
767         removeNodePreservingChildren(anchorNode);
768 }
769
770 // Clone the paragraph between start and end under blockElement,
771 // preserving the hierarchy up to outerNode. 
772
773 void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Position& end, Node* outerNode, Element* blockElement)
774 {
775     // First we clone the outerNode
776     
777     RefPtr<Node> topNode = outerNode->cloneNode(isTableElement(outerNode));
778     appendNode(topNode, blockElement);
779     RefPtr<Node> lastNode = topNode;
780
781     if (start.node() != outerNode) {
782         Vector<RefPtr<Node> > ancestors;
783         
784         // Insert each node from innerNode to outerNode (excluded) in a list.
785         for (Node* n = start.node(); n && n != outerNode; n = n->parentNode())
786             ancestors.append(n);
787
788         // Clone every node between start.node() and outerBlock.
789
790         for (size_t i = ancestors.size(); i != 0; --i) {
791             Node* item = ancestors[i - 1].get();
792             RefPtr<Node> child = item->cloneNode(isTableElement(item));
793             appendNode(child, static_cast<Element *>(lastNode.get()));
794             lastNode = child.release();
795         }
796     }
797
798     // Handle the case of paragraphs with more than one node,
799     // cloning all the siblings until end.node() is reached.
800     
801     if (start.node() != end.node() && !start.node()->isDescendantOf(end.node())) {
802         // If end is not a descendant of outerNode we need to
803         // find the first common ancestor and adjust the insertion
804         // point accordingly.
805         while (!end.node()->isDescendantOf(outerNode)) {
806             outerNode = outerNode->parentNode();
807             topNode = topNode->parentNode();
808         }
809
810         for (Node* n = start.node()->traverseNextSibling(outerNode); n; n = n->traverseNextSibling(outerNode)) {
811             if (n->parentNode() != start.node()->parentNode())
812                 lastNode = topNode->lastChild();
813
814             RefPtr<Node> clonedNode = n->cloneNode(true);
815             insertNodeAfter(clonedNode, lastNode);
816             lastNode = clonedNode.release();
817             if (n == end.node() || end.node()->isDescendantOf(n))
818                 break;
819         }
820     }
821 }
822
823     
824 // There are bugs in deletion when it removes a fully selected table/list.
825 // It expands and removes the entire table/list, but will let content
826 // before and after the table/list collapse onto one line.   
827 // Deleting a paragraph will leave a placeholder. Remove it (and prune
828 // empty or unrendered parents).
829
830 void CompositeEditCommand::cleanupAfterDeletion()
831 {
832     VisiblePosition caretAfterDelete = endingSelection().visibleStart();
833     if (isStartOfParagraph(caretAfterDelete) && isEndOfParagraph(caretAfterDelete)) {
834         // Note: We want the rightmost candidate.
835         Position position = caretAfterDelete.deepEquivalent().downstream();
836         Node* node = position.node();
837         // Normally deletion will leave a br as a placeholder.
838         if (node->hasTagName(brTag))
839             removeNodeAndPruneAncestors(node);
840         // If the selection to move was empty and in an empty block that 
841         // doesn't require a placeholder to prop itself open (like a bordered
842         // div or an li), remove it during the move (the list removal code
843         // expects this behavior).
844         else if (isBlock(node))
845             removeNodeAndPruneAncestors(node);
846         else if (lineBreakExistsAtPosition(position)) {
847             // There is a preserved '\n' at caretAfterDelete.
848             // We can safely assume this is a text node.
849             Text* textNode = static_cast<Text*>(node);
850             if (textNode->length() == 1)
851                 removeNodeAndPruneAncestors(node);
852             else
853                 deleteTextFromNode(textNode, position.deprecatedEditingOffset(), 1);
854         }
855     }
856 }
857     
858 // This is a version of moveParagraph that preserves style by keeping the original markup
859 // It is currently used only by IndentOutdentCommand but it is meant to be used in the
860 // future by several other commands such as InsertList and the align commands.
861 // The blockElement parameter is the element to move the paragraph to,
862 // outerNode is the top element of the paragraph hierarchy. 
863
864 void CompositeEditCommand::moveParagraphWithClones(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, Element* blockElement, Node* outerNode)
865 {
866     ASSERT(outerNode);
867     ASSERT(blockElement);
868
869     VisiblePosition beforeParagraph = startOfParagraphToMove.previous();
870     VisiblePosition afterParagraph(endOfParagraphToMove.next());
871     
872     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
873     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
874     Position start = startOfParagraphToMove.deepEquivalent().downstream();
875     Position end = endOfParagraphToMove.deepEquivalent().upstream();
876
877     cloneParagraphUnderNewElement(start, end, outerNode, blockElement);
878       
879     setEndingSelection(VisibleSelection(start, end, DOWNSTREAM));
880     deleteSelection(false, false, false, false);
881     
882     // There are bugs in deletion when it removes a fully selected table/list.
883     // It expands and removes the entire table/list, but will let content
884     // before and after the table/list collapse onto one line.
885        
886     cleanupAfterDeletion();
887     
888     // Add a br if pruning an empty block level element caused a collapse.  For example:
889     // foo^
890     // <div>bar</div>
891     // baz
892     // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That would
893     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
894     // Must recononicalize these two VisiblePositions after the pruning above.
895     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
896     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
897
898     if (beforeParagraph.isNotNull() && !isTableElement(beforeParagraph.deepEquivalent().node())
899         && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph == afterParagraph)) {
900         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
901         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
902     }
903 }
904     
905     
906 // This moves a paragraph preserving its style.
907 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
908 {
909     ASSERT(isStartOfParagraph(startOfParagraphToMove));
910     ASSERT(isEndOfParagraph(endOfParagraphToMove));
911     moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination, preserveSelection, preserveStyle);
912 }
913
914 void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, bool preserveSelection, bool preserveStyle)
915 {
916     if (startOfParagraphToMove == destination)
917         return;
918     
919     int startIndex = -1;
920     int endIndex = -1;
921     int destinationIndex = -1;
922     if (preserveSelection && !endingSelection().isNone()) {
923         VisiblePosition visibleStart = endingSelection().visibleStart();
924         VisiblePosition visibleEnd = endingSelection().visibleEnd();
925         
926         bool startAfterParagraph = comparePositions(visibleStart, endOfParagraphToMove) > 0;
927         bool endBeforeParagraph = comparePositions(visibleEnd, startOfParagraphToMove) < 0;
928         
929         if (!startAfterParagraph && !endBeforeParagraph) {
930             bool startInParagraph = comparePositions(visibleStart, startOfParagraphToMove) >= 0;
931             bool endInParagraph = comparePositions(visibleEnd, endOfParagraphToMove) <= 0;
932             
933             startIndex = 0;
934             if (startInParagraph) {
935                 RefPtr<Range> startRange = Range::create(document(), startOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent(), visibleStart.deepEquivalent().parentAnchoredEquivalent());
936                 startIndex = TextIterator::rangeLength(startRange.get(), true);
937             }
938
939             endIndex = 0;
940             if (endInParagraph) {
941                 RefPtr<Range> endRange = Range::create(document(), startOfParagraphToMove.deepEquivalent().parentAnchoredEquivalent(), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
942                 endIndex = TextIterator::rangeLength(endRange.get(), true);
943             }
944         }
945     }
946     
947     VisiblePosition beforeParagraph = startOfParagraphToMove.previous();
948     VisiblePosition afterParagraph(endOfParagraphToMove.next());
949
950     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
951     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
952     Position start = startOfParagraphToMove.deepEquivalent().downstream();
953     Position end = endOfParagraphToMove.deepEquivalent().upstream();
954     
955     // start and end can't be used directly to create a Range; they are "editing positions"
956     Position startRangeCompliant = start.parentAnchoredEquivalent();
957     Position endRangeCompliant = end.parentAnchoredEquivalent();
958     RefPtr<Range> range = Range::create(document(), startRangeCompliant.node(), startRangeCompliant.deprecatedEditingOffset(), endRangeCompliant.node(), endRangeCompliant.deprecatedEditingOffset());
959
960     // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move. It
961     // shouldn't matter though, since moved paragraphs will usually be quite small.
962     RefPtr<DocumentFragment> fragment;
963     // This used to use a ternary for initialization, but that confused some versions of GCC, see bug 37912
964     if (startOfParagraphToMove != endOfParagraphToMove)
965         fragment = createFragmentFromMarkup(document(), createMarkup(range.get(), 0, DoNotAnnotateForInterchange, true), "");
966
967     // A non-empty paragraph's style is moved when we copy and move it.  We don't move 
968     // anything if we're given an empty paragraph, but an empty paragraph can have style
969     // too, <div><b><br></b></div> for example.  Save it so that we can preserve it later.
970     RefPtr<EditingStyle> styleInEmptyParagraph;
971     if (startOfParagraphToMove == endOfParagraphToMove && preserveStyle) {
972         styleInEmptyParagraph = editingStyleIncludingTypingStyle(startOfParagraphToMove.deepEquivalent());
973         // The moved paragraph should assume the block style of the destination.
974         styleInEmptyParagraph->removeBlockProperties();
975     }
976     
977     // FIXME (5098931): We should add a new insert action "WebViewInsertActionMoved" and call shouldInsertFragment here.
978     
979     setEndingSelection(VisibleSelection(start, end, DOWNSTREAM));
980     document()->frame()->editor()->clearMisspellingsAndBadGrammar(endingSelection());
981     deleteSelection(false, false, false, false);
982
983     ASSERT(destination.deepEquivalent().node()->inDocument());
984
985     cleanupAfterDeletion();
986     ASSERT(destination.deepEquivalent().node()->inDocument());
987
988     // Add a br if pruning an empty block level element caused a collapse. For example:
989     // foo^
990     // <div>bar</div>
991     // baz
992     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
993     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
994     // Must recononicalize these two VisiblePositions after the pruning above.
995     beforeParagraph = VisiblePosition(beforeParagraph.deepEquivalent());
996     afterParagraph = VisiblePosition(afterParagraph.deepEquivalent());
997     if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph == afterParagraph)) {
998         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
999         insertNodeAt(createBreakElement(document()), beforeParagraph.deepEquivalent());
1000         // Need an updateLayout here in case inserting the br has split a text node.
1001         updateLayout();
1002     }
1003
1004     RefPtr<Range> startToDestinationRange(Range::create(document(), firstPositionInNode(document()->documentElement()), destination.deepEquivalent().parentAnchoredEquivalent()));
1005     destinationIndex = TextIterator::rangeLength(startToDestinationRange.get(), true);
1006
1007     setEndingSelection(destination);
1008     ASSERT(endingSelection().isCaretOrRange());
1009     applyCommandToComposite(ReplaceSelectionCommand::create(document(), fragment, true, false, !preserveStyle, false, true));
1010
1011     document()->frame()->editor()->markMisspellingsAndBadGrammar(endingSelection());
1012
1013     // If the selection is in an empty paragraph, restore styles from the old empty paragraph to the new empty paragraph.
1014     bool selectionIsEmptyParagraph = endingSelection().isCaret() && isStartOfParagraph(endingSelection().visibleStart()) && isEndOfParagraph(endingSelection().visibleStart());
1015     if (styleInEmptyParagraph && selectionIsEmptyParagraph)
1016         applyStyle(styleInEmptyParagraph.get());
1017
1018     if (preserveSelection && startIndex != -1) {
1019         // Fragment creation (using createMarkup) incorrectly uses regular
1020         // spaces instead of nbsps for some spaces that were rendered (11475), which
1021         // causes spaces to be collapsed during the move operation.  This results
1022         // in a call to rangeFromLocationAndLength with a location past the end
1023         // of the document (which will return null).
1024         RefPtr<Range> start = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + startIndex, 0, true);
1025         RefPtr<Range> end = TextIterator::rangeFromLocationAndLength(document()->documentElement(), destinationIndex + endIndex, 0, true);
1026         if (start && end)
1027             setEndingSelection(VisibleSelection(start->startPosition(), end->startPosition(), DOWNSTREAM));
1028     }
1029 }
1030
1031 // FIXME: Send an appropriate shouldDeleteRange call.
1032 bool CompositeEditCommand::breakOutOfEmptyListItem()
1033 {
1034     Node* emptyListItem = enclosingEmptyListItem(endingSelection().visibleStart());
1035     if (!emptyListItem)
1036         return false;
1037
1038     RefPtr<EditingStyle> style = editingStyleIncludingTypingStyle(endingSelection().start());
1039
1040     ContainerNode* listNode = emptyListItem->parentNode();
1041     // FIXME: Can't we do something better when the immediate parent wasn't a list node?
1042     if (!listNode
1043         || (!listNode->hasTagName(ulTag) && !listNode->hasTagName(olTag))
1044         || !listNode->isContentEditable()
1045         || listNode == emptyListItem->rootEditableElement())
1046         return false;
1047
1048     RefPtr<Element> newBlock = 0;
1049     if (ContainerNode* blockEnclosingList = listNode->parentNode()) {
1050         if (blockEnclosingList->hasTagName(liTag)) { // listNode is inside another list item
1051             if (visiblePositionAfterNode(blockEnclosingList) == visiblePositionAfterNode(listNode)) {
1052                 // If listNode appears at the end of the outer list item, then move listNode outside of this list item
1053                 // e.g. <ul><li>hello <ul><li><br></li></ul> </li></ul> should become <ul><li>hello</li> <ul><li><br></li></ul> </ul> after this section
1054                 // If listNode does NOT appear at the end, then we should consider it as a regular paragraph.
1055                 // e.g. <ul><li> <ul><li><br></li></ul> hello</li></ul> should become <ul><li> <div><br></div> hello</li></ul> at the end
1056                 splitElement(static_cast<Element*>(blockEnclosingList), listNode);
1057                 removeNodePreservingChildren(listNode->parentNode());
1058                 newBlock = createListItemElement(document());
1059             }
1060             // If listNode does NOT appear at the end of the outer list item, then behave as if in a regular paragraph.
1061         } else if (blockEnclosingList->hasTagName(olTag) || blockEnclosingList->hasTagName(ulTag))
1062             newBlock = createListItemElement(document());
1063     }
1064     if (!newBlock)
1065         newBlock = createDefaultParagraphElement(document());
1066
1067     if (emptyListItem->renderer()->nextSibling()) {
1068         // If emptyListItem follows another list item, split the list node.
1069         if (emptyListItem->renderer()->previousSibling())
1070             splitElement(static_cast<Element*>(listNode), emptyListItem);
1071
1072         // If emptyListItem is followed by other list item, then insert newBlock before the list node.
1073         // Because we have splitted the element, emptyListItem is the first element in the list node.
1074         // i.e. insert newBlock before ul or ol whose first element is emptyListItem
1075         insertNodeBefore(newBlock, listNode);
1076         removeNode(emptyListItem);
1077     } else {
1078         // When emptyListItem does not follow any list item, insert newBlock after the enclosing list node.
1079         // Remove the enclosing node if emptyListItem is the only child; otherwise just remove emptyListItem.
1080         insertNodeAfter(newBlock, listNode);
1081         removeNode(emptyListItem->renderer()->previousSibling() ? emptyListItem : listNode);
1082     }
1083
1084     appendBlockPlaceholder(newBlock);
1085     setEndingSelection(VisibleSelection(firstPositionInNode(newBlock.get()), DOWNSTREAM));
1086
1087     style->prepareToApplyAt(endingSelection().start());
1088     if (!style->isEmpty())
1089         applyStyle(style.get());
1090
1091     return true;
1092 }
1093
1094 // If the caret is in an empty quoted paragraph, and either there is nothing before that
1095 // paragraph, or what is before is unquoted, and the user presses delete, unquote that paragraph.
1096 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph()
1097 {
1098     if (!endingSelection().isCaret())
1099         return false;
1100         
1101     VisiblePosition caret(endingSelection().visibleStart());
1102     Node* highestBlockquote = highestEnclosingNodeOfType(caret.deepEquivalent(), &isMailBlockquote);
1103     if (!highestBlockquote)
1104         return false;
1105         
1106     if (!isStartOfParagraph(caret) || !isEndOfParagraph(caret))
1107         return false;
1108     
1109     VisiblePosition previous(caret.previous(true));
1110     // Only move forward if there's nothing before the caret, or if there's unquoted content before it.
1111     if (enclosingNodeOfType(previous.deepEquivalent(), &isMailBlockquote))
1112         return false;
1113     
1114     RefPtr<Node> br = createBreakElement(document());
1115     // We want to replace this quoted paragraph with an unquoted one, so insert a br
1116     // to hold the caret before the highest blockquote.
1117     insertNodeBefore(br, highestBlockquote);
1118     VisiblePosition atBR(positionBeforeNode(br.get()));
1119     // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
1120     // a second one.
1121     if (!isStartOfParagraph(atBR))
1122         insertNodeBefore(createBreakElement(document()), br);
1123     setEndingSelection(VisibleSelection(atBR));
1124     
1125     // If this is an empty paragraph there must be a line break here.
1126     if (!lineBreakExistsAtVisiblePosition(caret))
1127         return false;
1128     
1129     Position caretPos(caret.deepEquivalent());
1130     // A line break is either a br or a preserved newline.
1131     ASSERT(caretPos.node()->hasTagName(brTag) || (caretPos.node()->isTextNode() && caretPos.node()->renderer()->style()->preserveNewline()));
1132     
1133     if (caretPos.node()->hasTagName(brTag)) {
1134         Position beforeBR(positionInParentBeforeNode(caretPos.node()));
1135         removeNode(caretPos.node());
1136         prune(beforeBR.node());
1137     } else {
1138         ASSERT(caretPos.deprecatedEditingOffset() == 0);
1139         Text* textNode = static_cast<Text*>(caretPos.node());
1140         ContainerNode* parentNode = textNode->parentNode();
1141         // The preserved newline must be the first thing in the node, since otherwise the previous
1142         // paragraph would be quoted, and we verified that it wasn't above.
1143         deleteTextFromNode(textNode, 0, 1);
1144         prune(parentNode);
1145     }
1146     
1147     return true;
1148 }
1149
1150 // Operations use this function to avoid inserting content into an anchor when at the start or the end of
1151 // that anchor, as in NSTextView.
1152 // FIXME: This is only an approximation of NSTextViews insertion behavior, which varies depending on how
1153 // the caret was made. 
1154 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(const Position& original)
1155 {
1156     if (original.isNull())
1157         return original;
1158         
1159     VisiblePosition visiblePos(original);
1160     Node* enclosingAnchor = enclosingAnchorElement(original);
1161     Position result = original;
1162
1163     if (!enclosingAnchor)
1164         return result;
1165
1166     // Don't avoid block level anchors, because that would insert content into the wrong paragraph.
1167     if (enclosingAnchor && !isBlock(enclosingAnchor)) {
1168         VisiblePosition firstInAnchor(firstDeepEditingPositionForNode(enclosingAnchor));
1169         VisiblePosition lastInAnchor(lastDeepEditingPositionForNode(enclosingAnchor));
1170         // If visually just after the anchor, insert *inside* the anchor unless it's the last
1171         // VisiblePosition in the document, to match NSTextView.
1172         if (visiblePos == lastInAnchor) {
1173             // Make sure anchors are pushed down before avoiding them so that we don't
1174             // also avoid structural elements like lists and blocks (5142012).
1175             if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
1176                 pushAnchorElementDown(enclosingAnchor);
1177                 enclosingAnchor = enclosingAnchorElement(original);
1178                 if (!enclosingAnchor)
1179                     return original;
1180             }
1181             // Don't insert outside an anchor if doing so would skip over a line break.  It would
1182             // probably be safe to move the line break so that we could still avoid the anchor here.
1183             Position downstream(visiblePos.deepEquivalent().downstream());
1184             if (lineBreakExistsAtVisiblePosition(visiblePos) && downstream.node()->isDescendantOf(enclosingAnchor))
1185                 return original;
1186             
1187             result = positionInParentAfterNode(enclosingAnchor);
1188         }
1189         // If visually just before an anchor, insert *outside* the anchor unless it's the first
1190         // VisiblePosition in a paragraph, to match NSTextView.
1191         if (visiblePos == firstInAnchor) {
1192             // Make sure anchors are pushed down before avoiding them so that we don't
1193             // also avoid structural elements like lists and blocks (5142012).
1194             if (original.node() != enclosingAnchor && original.node()->parentNode() != enclosingAnchor) {
1195                 pushAnchorElementDown(enclosingAnchor);
1196                 enclosingAnchor = enclosingAnchorElement(original);
1197             }
1198             if (!enclosingAnchor)
1199                 return original;
1200
1201             result = positionInParentBeforeNode(enclosingAnchor);
1202         }
1203     }
1204         
1205     if (result.isNull() || !editableRootForPosition(result))
1206         result = original;
1207     
1208     return result;
1209 }
1210
1211 // Splits the tree parent by parent until we reach the specified ancestor. We use VisiblePositions
1212 // to determine if the split is necessary. Returns the last split node.
1213 PassRefPtr<Node> CompositeEditCommand::splitTreeToNode(Node* start, Node* end, bool splitAncestor)
1214 {
1215     ASSERT(start != end);
1216
1217     RefPtr<Node> node;
1218     for (node = start; node && node->parentNode() != end; node = node->parentNode()) {
1219         if (!node->parentNode()->isElementNode())
1220             break;
1221         VisiblePosition positionInParent(firstPositionInNode(node->parentNode()), DOWNSTREAM);
1222         VisiblePosition positionInNode(firstPositionInOrBeforeNode(node.get()), DOWNSTREAM);
1223         if (positionInParent != positionInNode)
1224             applyCommandToComposite(SplitElementCommand::create(static_cast<Element*>(node->parentNode()), node));
1225     }
1226     if (splitAncestor) {
1227         splitElement(static_cast<Element*>(end), node);
1228         return node->parentNode();
1229     }
1230     return node.release();
1231 }
1232
1233 PassRefPtr<Element> createBlockPlaceholderElement(Document* document)
1234 {
1235     RefPtr<Element> breakNode = document->createElement(brTag, false);
1236     return breakNode.release();
1237 }
1238
1239 } // namespace WebCore