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