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