2011-01-19 Levi Weintraub <leviw@google.com>
[WebKit-https.git] / Source / WebCore / editing / InsertParagraphSeparatorCommand.cpp
1 /*
2  * Copyright (C) 2005, 2006 Apple Computer, 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 "InsertParagraphSeparatorCommand.h"
28
29 #include "CSSPropertyNames.h"
30 #include "Document.h"
31 #include "EditingStyle.h"
32 #include "HTMLElement.h"
33 #include "HTMLNames.h"
34 #include "InsertLineBreakCommand.h"
35 #include "RenderObject.h"
36 #include "Text.h"
37 #include "htmlediting.h"
38 #include "visible_units.h"
39
40 namespace WebCore {
41
42 using namespace HTMLNames;
43
44 // When inserting a new line, we want to avoid nesting empty divs if we can.  Otherwise, when
45 // pasting, it's easy to have each new line be a div deeper than the previous.  E.g., in the case
46 // below, we want to insert at ^ instead of |.
47 // <div>foo<div>bar</div>|</div>^
48 static Element* highestVisuallyEquivalentDivBelowRoot(Element* startBlock)
49 {
50     Element* curBlock = startBlock;
51     // We don't want to return a root node (if it happens to be a div, e.g., in a document fragment) because there are no
52     // siblings for us to append to.
53     while (!curBlock->nextSibling() && curBlock->parentElement()->hasTagName(divTag) && curBlock->parentElement()->parentElement()) {
54         NamedNodeMap* attributes = curBlock->parentElement()->attributes(true);
55         if (attributes && !attributes->isEmpty())
56             break;
57         curBlock = curBlock->parentElement();
58     }
59     return curBlock;
60 }
61
62 InsertParagraphSeparatorCommand::InsertParagraphSeparatorCommand(Document *document, bool mustUseDefaultParagraphElement) 
63     : CompositeEditCommand(document)
64     , m_mustUseDefaultParagraphElement(mustUseDefaultParagraphElement)
65 {
66 }
67
68 bool InsertParagraphSeparatorCommand::preservesTypingStyle() const
69 {
70     return true;
71 }
72
73 void InsertParagraphSeparatorCommand::calculateStyleBeforeInsertion(const Position &pos)
74 {
75     // It is only important to set a style to apply later if we're at the boundaries of
76     // a paragraph. Otherwise, content that is moved as part of the work of the command
77     // will lend their styles to the new paragraph without any extra work needed.
78     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
79     if (!isStartOfParagraph(visiblePos) && !isEndOfParagraph(visiblePos))
80         return;
81     
82     m_style = editingStyleIncludingTypingStyle(pos);
83 }
84
85 void InsertParagraphSeparatorCommand::applyStyleAfterInsertion(Node* originalEnclosingBlock)
86 {
87     // Not only do we break out of header tags, but we also do not preserve the typing style,
88     // in order to match other browsers.
89     if (originalEnclosingBlock->hasTagName(h1Tag) ||
90         originalEnclosingBlock->hasTagName(h2Tag) ||
91         originalEnclosingBlock->hasTagName(h3Tag) ||
92         originalEnclosingBlock->hasTagName(h4Tag) ||
93         originalEnclosingBlock->hasTagName(h5Tag))
94         return;
95
96     if (!m_style)
97         return;
98
99     m_style->prepareToApplyAt(endingSelection().start());
100     if (!m_style->isEmpty())
101         applyStyle(m_style.get());
102 }
103
104 bool InsertParagraphSeparatorCommand::shouldUseDefaultParagraphElement(Node* enclosingBlock) const
105 {
106     if (m_mustUseDefaultParagraphElement)
107         return true;
108     
109     // Assumes that if there was a range selection, it was already deleted.
110     if (!isEndOfBlock(endingSelection().visibleStart()))
111         return false;
112
113     return enclosingBlock->hasTagName(h1Tag) ||
114            enclosingBlock->hasTagName(h2Tag) ||
115            enclosingBlock->hasTagName(h3Tag) ||
116            enclosingBlock->hasTagName(h4Tag) ||
117            enclosingBlock->hasTagName(h5Tag);
118 }
119
120 void InsertParagraphSeparatorCommand::getAncestorsInsideBlock(const Node* insertionNode, Element* outerBlock, Vector<Element*>& ancestors)
121 {
122     ancestors.clear();
123     
124     // Build up list of ancestors elements between the insertion node and the outer block.
125     if (insertionNode != outerBlock) {
126         for (Element* n = insertionNode->parentElement(); n && n != outerBlock; n = n->parentElement())
127             ancestors.append(n);
128     }
129 }
130
131 PassRefPtr<Element> InsertParagraphSeparatorCommand::cloneHierarchyUnderNewBlock(const Vector<Element*>& ancestors, PassRefPtr<Element> blockToInsert)
132 {
133     // Make clones of ancestors in between the start node and the start block.
134     RefPtr<Element> parent = blockToInsert;
135     for (size_t i = ancestors.size(); i != 0; --i) {
136         RefPtr<Element> child = ancestors[i - 1]->cloneElementWithoutChildren();
137         appendNode(child, parent);
138         parent = child.release();
139     }
140     
141     return parent.release();
142 }
143
144 void InsertParagraphSeparatorCommand::doApply()
145 {
146     bool splitText = false;
147     if (!endingSelection().isNonOrphanedCaretOrRange())
148         return;
149     
150     Position insertionPosition = endingSelection().start();
151         
152     EAffinity affinity = endingSelection().affinity();
153         
154     // Delete the current selection.
155     if (endingSelection().isRange()) {
156         calculateStyleBeforeInsertion(insertionPosition);
157         deleteSelection(false, true);
158         insertionPosition = endingSelection().start();
159         affinity = endingSelection().affinity();
160     }
161     
162     // FIXME: The parentAnchoredEquivalent conversion needs to be moved into enclosingBlock.
163     Node* startBlockNode = enclosingBlock(insertionPosition.parentAnchoredEquivalent().containerNode());
164     Position canonicalPos = VisiblePosition(insertionPosition).deepEquivalent();
165     Element* startBlock = static_cast<Element*>(startBlockNode);
166     if (!startBlockNode
167             || !startBlockNode->isElementNode()
168             || !startBlock->parentNode()
169             || isTableCell(startBlock)
170             || startBlock->hasTagName(formTag)
171             // FIXME: If the node is hidden, we don't have a canonical position so we will do the wrong thing for tables and <hr>. https://bugs.webkit.org/show_bug.cgi?id=40342
172             || (!canonicalPos.isNull() && canonicalPos.node()->renderer() && canonicalPos.node()->renderer()->isTable())
173             || (!canonicalPos.isNull() && canonicalPos.node()->hasTagName(hrTag))) {
174         applyCommandToComposite(InsertLineBreakCommand::create(document()));
175         return;
176     }
177     
178     // Use the leftmost candidate.
179     insertionPosition = insertionPosition.upstream();
180     if (!insertionPosition.isCandidate())
181         insertionPosition = insertionPosition.downstream();
182
183     // Adjust the insertion position after the delete
184     insertionPosition = positionAvoidingSpecialElementBoundary(insertionPosition);
185     VisiblePosition visiblePos(insertionPosition, affinity);
186     calculateStyleBeforeInsertion(insertionPosition);
187
188     //---------------------------------------------------------------------
189     // Handle special case of typing return on an empty list item
190     if (breakOutOfEmptyListItem())
191         return;
192
193     //---------------------------------------------------------------------
194     // Prepare for more general cases.
195
196     bool isFirstInBlock = isStartOfBlock(visiblePos);
197     bool isLastInBlock = isEndOfBlock(visiblePos);
198     bool nestNewBlock = false;
199
200     // Create block to be inserted.
201     RefPtr<Element> blockToInsert;
202     if (startBlock == startBlock->rootEditableElement()) {
203         blockToInsert = createDefaultParagraphElement(document());
204         nestNewBlock = true;
205     } else if (shouldUseDefaultParagraphElement(startBlock)) 
206         blockToInsert = createDefaultParagraphElement(document());
207     else
208         blockToInsert = startBlock->cloneElementWithoutChildren();
209
210     //---------------------------------------------------------------------
211     // Handle case when position is in the last visible position in its block,
212     // including when the block is empty. 
213     if (isLastInBlock) {
214         if (nestNewBlock) {
215             if (isFirstInBlock && !lineBreakExistsAtVisiblePosition(visiblePos)) {
216                 // The block is empty.  Create an empty block to
217                 // represent the paragraph that we're leaving.
218                 RefPtr<Element> extraBlock = createDefaultParagraphElement(document());
219                 appendNode(extraBlock, startBlock);
220                 appendBlockPlaceholder(extraBlock);
221             }
222             appendNode(blockToInsert, startBlock);
223         } else {
224             // We can get here if we pasted a copied portion of a blockquote with a newline at the end and are trying to paste it
225             // into an unquoted area. We then don't want the newline within the blockquote or else it will also be quoted.
226             if (Node* highestBlockquote = highestEnclosingNodeOfType(canonicalPos, &isMailBlockquote))
227                 startBlock = static_cast<Element*>(highestBlockquote);
228
229             // Most of the time we want to stay at the nesting level of the startBlock (e.g., when nesting within lists).  However,
230             // for div nodes, this can result in nested div tags that are hard to break out of.
231             Element* siblingNode = startBlock;
232             if (blockToInsert->hasTagName(divTag))
233                 siblingNode = highestVisuallyEquivalentDivBelowRoot(startBlock);
234             insertNodeAfter(blockToInsert, siblingNode);
235         }
236
237         // Recreate the same structure in the new paragraph.
238         
239         Vector<Element*> ancestors;
240         getAncestorsInsideBlock(insertionPosition.node(), startBlock, ancestors);      
241         RefPtr<Element> parent = cloneHierarchyUnderNewBlock(ancestors, blockToInsert);
242         
243         appendBlockPlaceholder(parent);
244
245         setEndingSelection(VisibleSelection(firstPositionInNode(parent.get()), DOWNSTREAM));
246         return;
247     }
248     
249
250     //---------------------------------------------------------------------
251     // Handle case when position is in the first visible position in its block, and
252     // similar case where previous position is in another, presumeably nested, block.
253     if (isFirstInBlock || !inSameBlock(visiblePos, visiblePos.previous())) {
254         Node *refNode;
255         if (isFirstInBlock && !nestNewBlock)
256             refNode = startBlock;
257         else if (insertionPosition.node() == startBlock && nestNewBlock) {
258             refNode = startBlock->childNode(insertionPosition.deprecatedEditingOffset());
259             ASSERT(refNode); // must be true or we'd be in the end of block case
260         } else
261             refNode = insertionPosition.node();
262
263         // find ending selection position easily before inserting the paragraph
264         insertionPosition = insertionPosition.downstream();
265         
266         insertNodeBefore(blockToInsert, refNode);
267
268         // Recreate the same structure in the new paragraph.
269
270         Vector<Element*> ancestors;
271         getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(insertionPosition).node(), startBlock, ancestors);
272         
273         appendBlockPlaceholder(cloneHierarchyUnderNewBlock(ancestors, blockToInsert));
274         
275         // In this case, we need to set the new ending selection.
276         setEndingSelection(VisibleSelection(insertionPosition, DOWNSTREAM));
277         return;
278     }
279
280     //---------------------------------------------------------------------
281     // Handle the (more complicated) general case,
282
283     // All of the content in the current block after visiblePos is
284     // about to be wrapped in a new paragraph element.  Add a br before 
285     // it if visiblePos is at the start of a paragraph so that the 
286     // content will move down a line.
287     if (isStartOfParagraph(visiblePos)) {
288         RefPtr<Element> br = createBreakElement(document());
289         insertNodeAt(br.get(), insertionPosition);
290         insertionPosition = positionInParentAfterNode(br.get());
291     }
292     
293     // Move downstream. Typing style code will take care of carrying along the 
294     // style of the upstream position.
295     insertionPosition = insertionPosition.downstream();
296
297     // At this point, the insertionPosition's node could be a container, and we want to make sure we include
298     // all of the correct nodes when building the ancestor list.  So this needs to be the deepest representation of the position
299     // before we walk the DOM tree.
300     insertionPosition = VisiblePosition(insertionPosition).deepEquivalent();
301
302     // Build up list of ancestors in between the start node and the start block.
303     Vector<Element*> ancestors;
304     getAncestorsInsideBlock(insertionPosition.node(), startBlock, ancestors);
305
306     // Make sure we do not cause a rendered space to become unrendered.
307     // FIXME: We need the affinity for pos, but pos.downstream() does not give it
308     Position leadingWhitespace = insertionPosition.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
309     // FIXME: leadingWhitespacePosition is returning the position before preserved newlines for positions
310     // after the preserved newline, causing the newline to be turned into a nbsp.
311     if (leadingWhitespace.isNotNull() && leadingWhitespace.node()->isTextNode()) {
312         Text* textNode = static_cast<Text*>(leadingWhitespace.node());
313         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
314         replaceTextInNode(textNode, leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
315     }
316     
317     // Split at pos if in the middle of a text node.
318     if (insertionPosition.node()->isTextNode()) {
319         Text* textNode = static_cast<Text*>(insertionPosition.node());
320         bool atEnd = (unsigned)insertionPosition.deprecatedEditingOffset() >= textNode->length();
321         if (insertionPosition.deprecatedEditingOffset() > 0 && !atEnd) {
322             splitTextNode(textNode, insertionPosition.deprecatedEditingOffset());
323             insertionPosition.moveToOffset(0);
324             visiblePos = VisiblePosition(insertionPosition);
325             splitText = true;
326         }
327     }
328
329     // Put the added block in the tree.
330     if (nestNewBlock)
331         appendNode(blockToInsert.get(), startBlock);
332     else
333         insertNodeAfter(blockToInsert.get(), startBlock);
334
335     updateLayout();
336     
337     // Make clones of ancestors in between the start node and the outer block.
338     RefPtr<Element> parent = cloneHierarchyUnderNewBlock(ancestors, blockToInsert);
339
340     // If the paragraph separator was inserted at the end of a paragraph, an empty line must be
341     // created.  All of the nodes, starting at visiblePos, are about to be added to the new paragraph 
342     // element.  If the first node to be inserted won't be one that will hold an empty line open, add a br.
343     if (isEndOfParagraph(visiblePos) && !lineBreakExistsAtVisiblePosition(visiblePos))
344         appendNode(createBreakElement(document()).get(), blockToInsert.get());
345         
346     // Move the start node and the siblings of the start node.
347     if (insertionPosition.node() != startBlock) {
348         Node* n = insertionPosition.node();
349         if (insertionPosition.deprecatedEditingOffset() >= caretMaxOffset(n))
350             n = n->nextSibling();
351
352         while (n && n != blockToInsert) {
353             Node *next = n->nextSibling();
354             removeNode(n);
355             appendNode(n, parent.get());
356             n = next;
357         }
358     }            
359
360     // Move everything after the start node.
361     if (!ancestors.isEmpty()) {
362         Element* leftParent = ancestors.first();
363         while (leftParent && leftParent != startBlock) {
364             parent = parent->parentElement();
365             if (!parent)
366                 break;
367             Node* n = leftParent->nextSibling();
368             while (n && n != blockToInsert) {
369                 Node* next = n->nextSibling();
370                 removeNode(n);
371                 appendNode(n, parent.get());
372                 n = next;
373             }
374             leftParent = leftParent->parentElement();
375         }
376     }
377
378     // Handle whitespace that occurs after the split
379     if (splitText) {
380         updateLayout();
381         if (insertionPosition.anchorType() == Position::PositionIsOffsetInAnchor)
382             insertionPosition.moveToOffset(0);
383         if (!insertionPosition.isRenderedCharacter()) {
384             // Clear out all whitespace and insert one non-breaking space
385             ASSERT(!insertionPosition.node()->renderer() || insertionPosition.node()->renderer()->style()->collapseWhiteSpace());
386             deleteInsignificantTextDownstream(insertionPosition);
387             if (insertionPosition.node()->isTextNode())
388                 insertTextIntoNode(static_cast<Text*>(insertionPosition.node()), 0, nonBreakingSpaceString());
389         }
390     }
391
392     setEndingSelection(VisibleSelection(firstPositionInNode(blockToInsert.get()), DOWNSTREAM));
393     applyStyleAfterInsertion(startBlock);
394 }
395
396 } // namespace WebCore