Provide more attribute methods in Element
[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         if (curBlock->parentElement()->hasAttributes())
55             break;
56         curBlock = curBlock->parentElement();
57     }
58     return curBlock;
59 }
60
61 InsertParagraphSeparatorCommand::InsertParagraphSeparatorCommand(Document *document, bool mustUseDefaultParagraphElement) 
62     : CompositeEditCommand(document)
63     , m_mustUseDefaultParagraphElement(mustUseDefaultParagraphElement)
64 {
65 }
66
67 bool InsertParagraphSeparatorCommand::preservesTypingStyle() const
68 {
69     return true;
70 }
71
72 void InsertParagraphSeparatorCommand::calculateStyleBeforeInsertion(const Position &pos)
73 {
74     // It is only important to set a style to apply later if we're at the boundaries of
75     // a paragraph. Otherwise, content that is moved as part of the work of the command
76     // will lend their styles to the new paragraph without any extra work needed.
77     VisiblePosition visiblePos(pos, VP_DEFAULT_AFFINITY);
78     if (!isStartOfParagraph(visiblePos) && !isEndOfParagraph(visiblePos))
79         return;
80
81     ASSERT(pos.isNotNull());
82     m_style = EditingStyle::create(pos);
83     m_style->mergeTypingStyle(pos.anchorNode()->document());
84 }
85
86 void InsertParagraphSeparatorCommand::applyStyleAfterInsertion(Node* originalEnclosingBlock)
87 {
88     // Not only do we break out of header tags, but we also do not preserve the typing style,
89     // in order to match other browsers.
90     if (originalEnclosingBlock->hasTagName(h1Tag) ||
91         originalEnclosingBlock->hasTagName(h2Tag) ||
92         originalEnclosingBlock->hasTagName(h3Tag) ||
93         originalEnclosingBlock->hasTagName(h4Tag) ||
94         originalEnclosingBlock->hasTagName(h5Tag))
95         return;
96
97     if (!m_style)
98         return;
99
100     m_style->prepareToApplyAt(endingSelection().start());
101     if (!m_style->isEmpty())
102         applyStyle(m_style.get());
103 }
104
105 bool InsertParagraphSeparatorCommand::shouldUseDefaultParagraphElement(Node* enclosingBlock) const
106 {
107     if (m_mustUseDefaultParagraphElement)
108         return true;
109     
110     // Assumes that if there was a range selection, it was already deleted.
111     if (!isEndOfBlock(endingSelection().visibleStart()))
112         return false;
113
114     return enclosingBlock->hasTagName(h1Tag) ||
115            enclosingBlock->hasTagName(h2Tag) ||
116            enclosingBlock->hasTagName(h3Tag) ||
117            enclosingBlock->hasTagName(h4Tag) ||
118            enclosingBlock->hasTagName(h5Tag);
119 }
120
121 void InsertParagraphSeparatorCommand::getAncestorsInsideBlock(const Node* insertionNode, Element* outerBlock, Vector<Element*>& ancestors)
122 {
123     ancestors.clear();
124     
125     // Build up list of ancestors elements between the insertion node and the outer block.
126     if (insertionNode != outerBlock) {
127         for (Element* n = insertionNode->parentElement(); n && n != outerBlock; n = n->parentElement())
128             ancestors.append(n);
129     }
130 }
131
132 PassRefPtr<Element> InsertParagraphSeparatorCommand::cloneHierarchyUnderNewBlock(const Vector<Element*>& ancestors, PassRefPtr<Element> blockToInsert)
133 {
134     // Make clones of ancestors in between the start node and the start block.
135     RefPtr<Element> parent = blockToInsert;
136     for (size_t i = ancestors.size(); i != 0; --i) {
137         RefPtr<Element> child = ancestors[i - 1]->cloneElementWithoutChildren();
138         // It should always be okay to remove id from the cloned elements, since the originals are not deleted.
139         child->removeAttribute(idAttr);
140         appendNode(child, parent);
141         parent = child.release();
142     }
143     
144     return parent.release();
145 }
146
147 void InsertParagraphSeparatorCommand::doApply()
148 {
149     bool splitText = false;
150     if (!endingSelection().isNonOrphanedCaretOrRange())
151         return;
152     
153     Position insertionPosition = endingSelection().start();
154         
155     EAffinity affinity = endingSelection().affinity();
156         
157     // Delete the current selection.
158     if (endingSelection().isRange()) {
159         calculateStyleBeforeInsertion(insertionPosition);
160         deleteSelection(false, true);
161         insertionPosition = endingSelection().start();
162         affinity = endingSelection().affinity();
163     }
164     
165     // FIXME: The parentAnchoredEquivalent conversion needs to be moved into enclosingBlock.
166     Node* startBlockNode = enclosingBlock(insertionPosition.parentAnchoredEquivalent().containerNode());
167     Position canonicalPos = VisiblePosition(insertionPosition).deepEquivalent();
168     Element* startBlock = static_cast<Element*>(startBlockNode);
169     if (!startBlockNode
170             || !startBlockNode->isElementNode()
171             || !startBlock->nonShadowBoundaryParentNode()
172             || isTableCell(startBlock)
173             || startBlock->hasTagName(formTag)
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 == startBlock->rootEditableElement()) {
206         blockToInsert = createDefaultParagraphElement(document());
207         nestNewBlock = true;
208     } else if (shouldUseDefaultParagraphElement(startBlock)) 
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 (Node* highestBlockquote = highestEnclosingNodeOfType(canonicalPos, &isMailBlockquote))
230                 startBlock = static_cast<Element*>(highestBlockquote);
231
232             // Most of the time we want to stay at the nesting level of the startBlock (e.g., when nesting within lists).  However,
233             // for div nodes, this can result in nested div tags that are hard to break out of.
234             Element* siblingNode = startBlock;
235             if (blockToInsert->hasTagName(divTag))
236                 siblingNode = highestVisuallyEquivalentDivBelowRoot(startBlock);
237             insertNodeAfter(blockToInsert, siblingNode);
238         }
239
240         // Recreate the same structure in the new paragraph.
241         
242         Vector<Element*> ancestors;
243         getAncestorsInsideBlock(positionOutsideTabSpan(insertionPosition).deprecatedNode(), startBlock, ancestors);      
244         RefPtr<Element> parent = cloneHierarchyUnderNewBlock(ancestors, blockToInsert);
245         
246         appendBlockPlaceholder(parent);
247
248         setEndingSelection(VisibleSelection(firstPositionInNode(parent.get()), DOWNSTREAM, endingSelection().isDirectional()));
249         return;
250     }
251     
252
253     //---------------------------------------------------------------------
254     // Handle case when position is in the first visible position in its block, and
255     // similar case where previous position is in another, presumeably nested, block.
256     if (isFirstInBlock || !inSameBlock(visiblePos, visiblePos.previous())) {
257         Node *refNode;
258         
259         insertionPosition = positionOutsideTabSpan(insertionPosition);
260
261         if (isFirstInBlock && !nestNewBlock)
262             refNode = startBlock;
263         else if (isFirstInBlock && nestNewBlock) {
264             // startBlock should always have children, otherwise isLastInBlock would be true and it's handled above.
265             ASSERT(startBlock->firstChild());
266             refNode = startBlock->firstChild();
267         }
268         else if (insertionPosition.deprecatedNode() == startBlock && nestNewBlock) {
269             refNode = startBlock->childNode(insertionPosition.deprecatedEditingOffset());
270             ASSERT(refNode); // must be true or we'd be in the end of block case
271         } else
272             refNode = insertionPosition.deprecatedNode();
273
274         // find ending selection position easily before inserting the paragraph
275         insertionPosition = insertionPosition.downstream();
276         
277         insertNodeBefore(blockToInsert, refNode);
278
279         // Recreate the same structure in the new paragraph.
280
281         Vector<Element*> ancestors;
282         getAncestorsInsideBlock(positionAvoidingSpecialElementBoundary(positionOutsideTabSpan(insertionPosition)).deprecatedNode(), startBlock, ancestors);
283         
284         appendBlockPlaceholder(cloneHierarchyUnderNewBlock(ancestors, blockToInsert));
285         
286         // In this case, we need to set the new ending selection.
287         setEndingSelection(VisibleSelection(insertionPosition, DOWNSTREAM, endingSelection().isDirectional()));
288         return;
289     }
290
291     //---------------------------------------------------------------------
292     // Handle the (more complicated) general case,
293
294     // All of the content in the current block after visiblePos is
295     // about to be wrapped in a new paragraph element.  Add a br before 
296     // it if visiblePos is at the start of a paragraph so that the 
297     // content will move down a line.
298     if (isStartOfParagraph(visiblePos)) {
299         RefPtr<Element> br = createBreakElement(document());
300         insertNodeAt(br.get(), insertionPosition);
301         insertionPosition = positionInParentAfterNode(br.get());
302         // If the insertion point is a break element, there is nothing else
303         // we need to do.
304         if (visiblePos.deepEquivalent().anchorNode()->renderer()->isBR()) {
305             setEndingSelection(VisibleSelection(insertionPosition, DOWNSTREAM, endingSelection().isDirectional()));
306             return;
307         }
308     }
309     
310     // Move downstream. Typing style code will take care of carrying along the 
311     // style of the upstream position.
312     insertionPosition = insertionPosition.downstream();
313
314     // At this point, the insertionPosition's node could be a container, and we want to make sure we include
315     // all of the correct nodes when building the ancestor list.  So this needs to be the deepest representation of the position
316     // before we walk the DOM tree.
317     insertionPosition = positionOutsideTabSpan(VisiblePosition(insertionPosition).deepEquivalent());
318
319     // Make sure we do not cause a rendered space to become unrendered.
320     // FIXME: We need the affinity for pos, but pos.downstream() does not give it
321     Position leadingWhitespace = insertionPosition.leadingWhitespacePosition(VP_DEFAULT_AFFINITY);
322     // FIXME: leadingWhitespacePosition is returning the position before preserved newlines for positions
323     // after the preserved newline, causing the newline to be turned into a nbsp.
324     if (leadingWhitespace.isNotNull() && leadingWhitespace.deprecatedNode()->isTextNode()) {
325         Text* textNode = static_cast<Text*>(leadingWhitespace.deprecatedNode());
326         ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace());
327         replaceTextInNodePreservingMarkers(textNode, leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString());
328     }
329     
330     // Split at pos if in the middle of a text node.
331     if (insertionPosition.deprecatedNode()->isTextNode()) {
332         Text* textNode = static_cast<Text*>(insertionPosition.deprecatedNode());
333         bool atEnd = (unsigned)insertionPosition.deprecatedEditingOffset() >= textNode->length();
334         if (insertionPosition.deprecatedEditingOffset() > 0 && !atEnd) {
335             splitTextNode(textNode, insertionPosition.deprecatedEditingOffset());
336             insertionPosition.moveToOffset(0);
337             visiblePos = VisiblePosition(insertionPosition);
338             splitText = true;
339         }
340     }
341
342     // Put the added block in the tree.
343     if (nestNewBlock)
344         appendNode(blockToInsert.get(), startBlock);
345     else
346         insertNodeAfter(blockToInsert.get(), startBlock);
347
348     document()->updateLayoutIgnorePendingStylesheets();
349
350     // If the paragraph separator was inserted at the end of a paragraph, an empty line must be
351     // created.  All of the nodes, starting at visiblePos, are about to be added to the new paragraph 
352     // element.  If the first node to be inserted won't be one that will hold an empty line open, add a br.
353     if (isEndOfParagraph(visiblePos) && !lineBreakExistsAtVisiblePosition(visiblePos))
354         appendNode(createBreakElement(document()).get(), blockToInsert.get());
355
356     // Move the start node and the siblings of the start node.
357     if (VisiblePosition(insertionPosition) != VisiblePosition(positionBeforeNode(blockToInsert.get()))) {
358         Node* n;
359         if (insertionPosition.containerNode() == startBlock)
360             n = insertionPosition.computeNodeAfterPosition();
361         else {
362             Node* splitTo = insertionPosition.containerNode();
363             if (splitTo->isTextNode() && insertionPosition.offsetInContainerNode() >= caretMaxOffset(splitTo))
364               splitTo = splitTo->traverseNextNode(startBlock);
365             ASSERT(splitTo);
366             splitTreeToNode(splitTo, startBlock);
367
368             for (n = startBlock->firstChild(); n; n = n->nextSibling()) {
369                 if (comparePositions(VisiblePosition(insertionPosition), positionBeforeNode(n)) <= 0)
370                     break;
371             }
372         }
373
374         while (n && n != blockToInsert) {
375             Node *next = n->nextSibling();
376             removeNode(n);
377             appendNode(n, blockToInsert);
378             n = next;
379         }
380     }            
381
382     // Handle whitespace that occurs after the split
383     if (splitText) {
384         document()->updateLayoutIgnorePendingStylesheets();
385         if (insertionPosition.anchorType() == Position::PositionIsOffsetInAnchor)
386             insertionPosition.moveToOffset(0);
387         if (!insertionPosition.isRenderedCharacter()) {
388             // Clear out all whitespace and insert one non-breaking space
389             ASSERT(!insertionPosition.deprecatedNode()->renderer() || insertionPosition.deprecatedNode()->renderer()->style()->collapseWhiteSpace());
390             deleteInsignificantTextDownstream(insertionPosition);
391             if (insertionPosition.deprecatedNode()->isTextNode())
392                 insertTextIntoNode(static_cast<Text*>(insertionPosition.deprecatedNode()), 0, nonBreakingSpaceString());
393         }
394     }
395
396     setEndingSelection(VisibleSelection(firstPositionInNode(blockToInsert.get()), DOWNSTREAM, endingSelection().isDirectional()));
397     applyStyleAfterInsertion(startBlock);
398 }
399
400 } // namespace WebCore