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