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