1 /* 2 * Copyright (C) 2005 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 "core/editing/DeleteSelectionCommand.h" 28 29 #include "core/HTMLNames.h" 30 #include "core/dom/Document.h" 31 #include "core/dom/Element.h" 32 #include "core/dom/NodeTraversal.h" 33 #include "core/dom/Text.h" 34 #include "core/editing/EditingBoundary.h" 35 #include "core/editing/Editor.h" 36 #include "core/editing/VisibleUnits.h" 37 #include "core/editing/htmlediting.h" 38 #include "core/frame/LocalFrame.h" 39 #include "core/html/HTMLBRElement.h" 40 #include "core/html/HTMLInputElement.h" 41 #include "core/html/HTMLStyleElement.h" 42 #include "core/html/HTMLTableRowElement.h" 43 #include "core/rendering/RenderTableCell.h" 44 #include "core/rendering/RenderText.h" 45 46 namespace blink { 47 48 using namespace HTMLNames; 49 50 static bool isTableCellEmpty(Node* cell) 51 { 52 ASSERT(isTableCell(cell)); 53 return VisiblePosition(firstPositionInNode(cell)) == VisiblePosition(lastPositionInNode(cell)); 54 } 55 56 static bool isTableRowEmpty(Node* row) 57 { 58 if (!isHTMLTableRowElement(row)) 59 return false; 60 61 for (Node* child = row->firstChild(); child; child = child->nextSibling()) 62 if (isTableCell(child) && !isTableCellEmpty(child)) 63 return false; 64 65 return true; 66 } 67 68 DeleteSelectionCommand::DeleteSelectionCommand(Document& document, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup) 69 : CompositeEditCommand(document) 70 , m_hasSelectionToDelete(false) 71 , m_smartDelete(smartDelete) 72 , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete) 73 , m_needPlaceholder(false) 74 , m_expandForSpecialElements(expandForSpecialElements) 75 , m_pruneStartBlockIfNecessary(false) 76 , m_startsAtEmptyLine(false) 77 , m_sanitizeMarkup(sanitizeMarkup) 78 , m_startBlock(nullptr) 79 , m_endBlock(nullptr) 80 , m_typingStyle(nullptr) 81 , m_deleteIntoBlockquoteStyle(nullptr) 82 { 83 } 84 85 DeleteSelectionCommand::DeleteSelectionCommand(const VisibleSelection& selection, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup) 86 : CompositeEditCommand(*selection.start().document()) 87 , m_hasSelectionToDelete(true) 88 , m_smartDelete(smartDelete) 89 , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete) 90 , m_needPlaceholder(false) 91 , m_expandForSpecialElements(expandForSpecialElements) 92 , m_pruneStartBlockIfNecessary(false) 93 , m_startsAtEmptyLine(false) 94 , m_sanitizeMarkup(sanitizeMarkup) 95 , m_selectionToDelete(selection) 96 , m_startBlock(nullptr) 97 , m_endBlock(nullptr) 98 , m_typingStyle(nullptr) 99 , m_deleteIntoBlockquoteStyle(nullptr) 100 { 101 } 102 103 void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end) 104 { 105 HTMLElement* startSpecialContainer = 0; 106 HTMLElement* endSpecialContainer = 0; 107 108 start = m_selectionToDelete.start(); 109 end = m_selectionToDelete.end(); 110 111 // For HRs, we'll get a position at (HR,1) when hitting delete from the beginning of the previous line, or (HR,0) when forward deleting, 112 // but in these cases, we want to delete it, so manually expand the selection 113 if (isHTMLHRElement(*start.deprecatedNode())) 114 start = positionBeforeNode(start.deprecatedNode()); 115 else if (isHTMLHRElement(*end.deprecatedNode())) 116 end = positionAfterNode(end.deprecatedNode()); 117 118 // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion. 119 if (!m_expandForSpecialElements) 120 return; 121 122 while (1) { 123 startSpecialContainer = 0; 124 endSpecialContainer = 0; 125 126 Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer); 127 Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer); 128 129 if (!startSpecialContainer && !endSpecialContainer) 130 break; 131 132 if (VisiblePosition(start) != m_selectionToDelete.visibleStart() || VisiblePosition(end) != m_selectionToDelete.visibleEnd()) 133 break; 134 135 // If we're going to expand to include the startSpecialContainer, it must be fully selected. 136 if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(*startSpecialContainer), end) > -1) 137 break; 138 139 // If we're going to expand to include the endSpecialContainer, it must be fully selected. 140 if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(*endSpecialContainer)) > -1) 141 break; 142 143 if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer)) 144 // Don't adjust the end yet, it is the end of a special element that contains the start 145 // special element (which may or may not be fully selected). 146 start = s; 147 else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer)) 148 // Don't adjust the start yet, it is the start of a special element that contains the end 149 // special element (which may or may not be fully selected). 150 end = e; 151 else { 152 start = s; 153 end = e; 154 } 155 } 156 } 157 158 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end) 159 { 160 bool isBaseFirst = startingSelection().isBaseFirst(); 161 VisiblePosition newBase(isBaseFirst ? start : end); 162 VisiblePosition newExtent(isBaseFirst ? end : start); 163 setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional())); 164 } 165 166 void DeleteSelectionCommand::initializePositionData() 167 { 168 Position start, end; 169 initializeStartEnd(start, end); 170 171 ASSERT(isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle)); 172 if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle)) 173 end = lastEditablePositionBeforePositionInRoot(end, highestEditableRoot(start)); 174 175 m_upstreamStart = start.upstream(); 176 m_downstreamStart = start.downstream(); 177 m_upstreamEnd = end.upstream(); 178 m_downstreamEnd = end.downstream(); 179 180 m_startRoot = editableRootForPosition(start); 181 m_endRoot = editableRootForPosition(end); 182 183 m_startTableRow = toHTMLTableRowElement(enclosingNodeOfType(start, &isHTMLTableRowElement)); 184 m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableRowElement)); 185 186 // Don't move content out of a table cell. 187 // If the cell is non-editable, enclosingNodeOfType won't return it by default, so 188 // tell that function that we don't care if it returns non-editable nodes. 189 Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCrossEditingBoundary); 190 Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossEditingBoundary); 191 // FIXME: This isn't right. A borderless table with two rows and a single column would appear as two paragraphs. 192 if (endCell && endCell != startCell) 193 m_mergeBlocksAfterDelete = false; 194 195 // Usually the start and the end of the selection to delete are pulled together as a result of the deletion. 196 // Sometimes they aren't (like when no merge is requested), so we must choose one position to hold the caret 197 // and receive the placeholder after deletion. 198 VisiblePosition visibleEnd(m_downstreamEnd); 199 if (m_mergeBlocksAfterDelete && !isEndOfParagraph(visibleEnd)) 200 m_endingPosition = m_downstreamEnd; 201 else 202 m_endingPosition = m_downstreamStart; 203 204 // We don't want to merge into a block if it will mean changing the quote level of content after deleting 205 // selections that contain a whole number paragraphs plus a line break, since it is unclear to most users 206 // that such a selection actually ends at the start of the next paragraph. This matches TextEdit behavior 207 // for indented paragraphs. 208 // Only apply this rule if the endingSelection is a range selection. If it is a caret, then other operations have created 209 // the selection we're deleting (like the process of creating a selection to delete during a backspace), and the user isn't in the situation described above. 210 if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end) 211 && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start)) 212 && endingSelection().isRange()) { 213 m_mergeBlocksAfterDelete = false; 214 m_pruneStartBlockIfNecessary = true; 215 } 216 217 // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection 218 m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity()); 219 m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY); 220 221 if (m_smartDelete) { 222 223 // skip smart delete if the selection to delete already starts or ends with whitespace 224 Position pos = VisiblePosition(m_upstreamStart, m_selectionToDelete.affinity()).deepEquivalent(); 225 bool skipSmartDelete = trailingWhitespacePosition(pos, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull(); 226 if (!skipSmartDelete) 227 skipSmartDelete = leadingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull(); 228 229 // extend selection upstream if there is whitespace there 230 bool hasLeadingWhitespaceBeforeAdjustment = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity(), ConsiderNonCollapsibleWhitespace).isNotNull(); 231 if (!skipSmartDelete && hasLeadingWhitespaceBeforeAdjustment) { 232 VisiblePosition visiblePos = VisiblePosition(m_upstreamStart, VP_DEFAULT_AFFINITY).previous(); 233 pos = visiblePos.deepEquivalent(); 234 // Expand out one character upstream for smart delete and recalculate 235 // positions based on this change. 236 m_upstreamStart = pos.upstream(); 237 m_downstreamStart = pos.downstream(); 238 m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, visiblePos.affinity()); 239 240 setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd); 241 } 242 243 // trailing whitespace is only considered for smart delete if there is no leading 244 // whitespace, as in the case where you double-click the first word of a paragraph. 245 if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment && trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsibleWhitespace).isNotNull()) { 246 // Expand out one character downstream for smart delete and recalculate 247 // positions based on this change. 248 pos = VisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY).next().deepEquivalent(); 249 m_upstreamEnd = pos.upstream(); 250 m_downstreamEnd = pos.downstream(); 251 m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY); 252 253 setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd); 254 } 255 } 256 257 // We must pass call parentAnchoredEquivalent on the positions since some editing positions 258 // that appear inside their nodes aren't really inside them. [hr, 0] is one example. 259 // FIXME: parentAnchoredEquivalent should eventually be moved into enclosing element getters 260 // like the one below, since editing functions should obviously accept editing positions. 261 // FIXME: Passing false to enclosingNodeOfType tells it that it's OK to return a non-editable 262 // node. This was done to match existing behavior, but it seems wrong. 263 m_startBlock = enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary); 264 m_endBlock = enclosingNodeOfType(m_upstreamEnd.parentAnchoredEquivalent(), &isBlock, CanCrossEditingBoundary); 265 } 266 267 // We don't want to inherit style from an element which can't have contents. 268 static bool shouldNotInheritStyleFrom(const Node& node) 269 { 270 return !node.canContainRangeEndPoint(); 271 } 272 273 void DeleteSelectionCommand::saveTypingStyleState() 274 { 275 // A common case is deleting characters that are all from the same text node. In 276 // that case, the style at the start of the selection before deletion will be the 277 // same as the style at the start of the selection after deletion (since those 278 // two positions will be identical). Therefore there is no need to save the 279 // typing style at the start of the selection, nor is there a reason to 280 // compute the style at the start of the selection after deletion (see the 281 // early return in calculateTypingStyleAfterDelete). 282 if (m_upstreamStart.deprecatedNode() == m_downstreamEnd.deprecatedNode() && m_upstreamStart.deprecatedNode()->isTextNode()) 283 return; 284 285 if (shouldNotInheritStyleFrom(*m_selectionToDelete.start().anchorNode())) 286 return; 287 288 // Figure out the typing style in effect before the delete is done. 289 m_typingStyle = EditingStyle::create(m_selectionToDelete.start(), EditingStyle::EditingPropertiesInEffect); 290 m_typingStyle->removeStyleAddedByElement(enclosingAnchorElement(m_selectionToDelete.start())); 291 292 // If we're deleting into a Mail blockquote, save the style at end() instead of start() 293 // We'll use this later in computeTypingStyleAfterDelete if we end up outside of a Mail blockquote 294 if (enclosingNodeOfType(m_selectionToDelete.start(), isMailHTMLBlockquoteElement)) 295 m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.end()); 296 else 297 m_deleteIntoBlockquoteStyle = nullptr; 298 } 299 300 bool DeleteSelectionCommand::handleSpecialCaseBRDelete() 301 { 302 Node* nodeAfterUpstreamStart = m_upstreamStart.computeNodeAfterPosition(); 303 Node* nodeAfterDownstreamStart = m_downstreamStart.computeNodeAfterPosition(); 304 // Upstream end will appear before BR due to canonicalization 305 Node* nodeAfterUpstreamEnd = m_upstreamEnd.computeNodeAfterPosition(); 306 307 if (!nodeAfterUpstreamStart || !nodeAfterDownstreamStart) 308 return false; 309 310 // Check for special-case where the selection contains only a BR on a line by itself after another BR. 311 bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart); 312 bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart); 313 bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAfterDownstreamStart == nodeAfterUpstreamEnd; 314 if (isBROnLineByItself) { 315 removeNode(nodeAfterDownstreamStart); 316 return true; 317 } 318 319 // FIXME: This code doesn't belong in here. 320 // We detect the case where the start is an empty line consisting of BR not wrapped in a block element. 321 if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(VisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(VisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) { 322 m_startsAtEmptyLine = true; 323 m_endingPosition = m_downstreamEnd; 324 } 325 326 return false; 327 } 328 329 static Position firstEditablePositionInNode(Node* node) 330 { 331 ASSERT(node); 332 Node* next = node; 333 while (next && !next->hasEditableStyle()) 334 next = NodeTraversal::next(*next, node); 335 return next ? firstPositionInOrBeforeNode(next) : Position(); 336 } 337 338 void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable) 339 { 340 if (!node) 341 return; 342 343 if (m_startRoot != m_endRoot && !(node->isDescendantOf(m_startRoot.get()) && node->isDescendantOf(m_endRoot.get()))) { 344 // If a node is not in both the start and end editable roots, remove it only if its inside an editable region. 345 if (!node->parentNode()->hasEditableStyle()) { 346 // Don't remove non-editable atomic nodes. 347 if (!node->hasChildren()) 348 return; 349 // Search this non-editable region for editable regions to empty. 350 RefPtrWillBeRawPtr<Node> child = node->firstChild(); 351 while (child) { 352 RefPtrWillBeRawPtr<Node> nextChild = child->nextSibling(); 353 removeNode(child.get(), shouldAssumeContentIsAlwaysEditable); 354 // Bail if nextChild is no longer node's child. 355 if (nextChild && nextChild->parentNode() != node) 356 return; 357 child = nextChild; 358 } 359 360 // Don't remove editable regions that are inside non-editable ones, just clear them. 361 return; 362 } 363 } 364 365 if (isTableStructureNode(node.get()) || node->isRootEditableElement()) { 366 // Do not remove an element of table structure; remove its contents. 367 // Likewise for the root editable element. 368 Node* child = node->firstChild(); 369 while (child) { 370 Node* remove = child; 371 child = child->nextSibling(); 372 removeNode(remove, shouldAssumeContentIsAlwaysEditable); 373 } 374 375 // Make sure empty cell has some height, if a placeholder can be inserted. 376 document().updateLayoutIgnorePendingStylesheets(); 377 RenderObject *r = node->renderer(); 378 if (r && r->isTableCell() && toRenderTableCell(r)->contentHeight() <= 0) { 379 Position firstEditablePosition = firstEditablePositionInNode(node.get()); 380 if (firstEditablePosition.isNotNull()) 381 insertBlockPlaceholder(firstEditablePosition); 382 } 383 return; 384 } 385 386 if (node == m_startBlock) { 387 VisiblePosition previous = VisiblePosition(firstPositionInNode(m_startBlock.get())).previous(); 388 if (previous.isNotNull() && !isEndOfBlock(previous)) 389 m_needPlaceholder = true; 390 } 391 if (node == m_endBlock) { 392 VisiblePosition next = VisiblePosition(lastPositionInNode(m_endBlock.get())).next(); 393 if (next.isNotNull() && !isStartOfBlock(next)) 394 m_needPlaceholder = true; 395 } 396 397 // FIXME: Update the endpoints of the range being deleted. 398 updatePositionForNodeRemoval(m_endingPosition, *node); 399 updatePositionForNodeRemoval(m_leadingWhitespace, *node); 400 updatePositionForNodeRemoval(m_trailingWhitespace, *node); 401 402 CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable); 403 } 404 405 static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position) 406 { 407 if (position.anchorType() != Position::PositionIsOffsetInAnchor || position.containerNode() != node) 408 return; 409 410 if (position.offsetInContainerNode() > offset + count) 411 position.moveToOffset(position.offsetInContainerNode() - count); 412 else if (position.offsetInContainerNode() > offset) 413 position.moveToOffset(offset); 414 } 415 416 void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> node, unsigned offset, unsigned count) 417 { 418 // FIXME: Update the endpoints of the range being deleted. 419 updatePositionForTextRemoval(node.get(), offset, count, m_endingPosition); 420 updatePositionForTextRemoval(node.get(), offset, count, m_leadingWhitespace); 421 updatePositionForTextRemoval(node.get(), offset, count, m_trailingWhitespace); 422 updatePositionForTextRemoval(node.get(), offset, count, m_downstreamEnd); 423 424 CompositeEditCommand::deleteTextFromNode(node, offset, count); 425 } 426 427 void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss() 428 { 429 RefPtrWillBeRawPtr<Range> range = m_selectionToDelete.toNormalizedRange(); 430 RefPtrWillBeRawPtr<Node> node = range->firstNode(); 431 while (node && node != range->pastLastNode()) { 432 RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::next(*node); 433 if (isHTMLStyleElement(*node) || isHTMLLinkElement(*node)) { 434 nextNode = NodeTraversal::nextSkippingChildren(*node); 435 RefPtrWillBeRawPtr<Element> rootEditableElement = node->rootEditableElement(); 436 if (rootEditableElement.get()) { 437 removeNode(node); 438 appendNode(node, rootEditableElement); 439 } 440 } 441 node = nextNode; 442 } 443 } 444 445 void DeleteSelectionCommand::handleGeneralDelete() 446 { 447 if (m_upstreamStart.isNull()) 448 return; 449 450 int startOffset = m_upstreamStart.deprecatedEditingOffset(); 451 Node* startNode = m_upstreamStart.deprecatedNode(); 452 ASSERT(startNode); 453 454 makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss(); 455 456 // Never remove the start block unless it's a table, in which case we won't merge content in. 457 if (startNode->isSameNode(m_startBlock.get()) && !startOffset && canHaveChildrenForEditing(startNode) && !isHTMLTableElement(*startNode)) { 458 startOffset = 0; 459 startNode = NodeTraversal::next(*startNode); 460 if (!startNode) 461 return; 462 } 463 464 if (startOffset >= caretMaxOffset(startNode) && startNode->isTextNode()) { 465 Text* text = toText(startNode); 466 if (text->length() > (unsigned)caretMaxOffset(startNode)) 467 deleteTextFromNode(text, caretMaxOffset(startNode), text->length() - caretMaxOffset(startNode)); 468 } 469 470 if (startOffset >= lastOffsetForEditing(startNode)) { 471 startNode = NodeTraversal::nextSkippingChildren(*startNode); 472 startOffset = 0; 473 } 474 475 // Done adjusting the start. See if we're all done. 476 if (!startNode) 477 return; 478 479 if (startNode == m_downstreamEnd.deprecatedNode()) { 480 if (m_downstreamEnd.deprecatedEditingOffset() - startOffset > 0) { 481 if (startNode->isTextNode()) { 482 // in a text node that needs to be trimmed 483 Text* text = toText(startNode); 484 deleteTextFromNode(text, startOffset, m_downstreamEnd.deprecatedEditingOffset() - startOffset); 485 } else { 486 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.deprecatedEditingOffset()); 487 m_endingPosition = m_upstreamStart; 488 } 489 } 490 491 // The selection to delete is all in one node. 492 if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode())) 493 removeNode(startNode); 494 } 495 else { 496 bool startNodeWasDescendantOfEndNode = m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode()); 497 // The selection to delete spans more than one node. 498 RefPtrWillBeRawPtr<Node> node(startNode); 499 500 if (startOffset > 0) { 501 if (startNode->isTextNode()) { 502 // in a text node that needs to be trimmed 503 Text* text = toText(node); 504 deleteTextFromNode(text, startOffset, text->length() - startOffset); 505 node = NodeTraversal::next(*node); 506 } else { 507 node = NodeTraversal::childAt(*startNode, startOffset); 508 } 509 } else if (startNode == m_upstreamEnd.deprecatedNode() && startNode->isTextNode()) { 510 Text* text = toText(m_upstreamEnd.deprecatedNode()); 511 deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset()); 512 } 513 514 // handle deleting all nodes that are completely selected 515 while (node && node != m_downstreamEnd.deprecatedNode()) { 516 if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_downstreamEnd) >= 0) { 517 // NodeTraversal::nextSkippingChildren just blew past the end position, so stop deleting 518 node = nullptr; 519 } else if (!m_downstreamEnd.deprecatedNode()->isDescendantOf(node.get())) { 520 RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::nextSkippingChildren(*node); 521 // if we just removed a node from the end container, update end position so the 522 // check above will work 523 updatePositionForNodeRemoval(m_downstreamEnd, *node); 524 removeNode(node.get()); 525 node = nextNode.get(); 526 } else { 527 Node& n = NodeTraversal::lastWithinOrSelf(*node); 528 if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(&n)) { 529 removeNode(node.get()); 530 node = nullptr; 531 } else { 532 node = NodeTraversal::next(*node); 533 } 534 } 535 } 536 537 if (m_downstreamEnd.deprecatedNode() != startNode && !m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode()) && m_downstreamEnd.inDocument() && m_downstreamEnd.deprecatedEditingOffset() >= caretMinOffset(m_downstreamEnd.deprecatedNode())) { 538 if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildrenForEditing(m_downstreamEnd.deprecatedNode())) { 539 // The node itself is fully selected, not just its contents. Delete it. 540 removeNode(m_downstreamEnd.deprecatedNode()); 541 } else { 542 if (m_downstreamEnd.deprecatedNode()->isTextNode()) { 543 // in a text node that needs to be trimmed 544 Text* text = toText(m_downstreamEnd.deprecatedNode()); 545 if (m_downstreamEnd.deprecatedEditingOffset() > 0) { 546 deleteTextFromNode(text, 0, m_downstreamEnd.deprecatedEditingOffset()); 547 } 548 // Remove children of m_downstreamEnd.deprecatedNode() that come after m_upstreamStart. 549 // Don't try to remove children if m_upstreamStart was inside m_downstreamEnd.deprecatedNode() 550 // and m_upstreamStart has been removed from the document, because then we don't 551 // know how many children to remove. 552 // FIXME: Make m_upstreamStart a position we update as we remove content, then we can 553 // always know which children to remove. 554 } else if (!(startNodeWasDescendantOfEndNode && !m_upstreamStart.inDocument())) { 555 int offset = 0; 556 if (m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode())) { 557 Node* n = m_upstreamStart.deprecatedNode(); 558 while (n && n->parentNode() != m_downstreamEnd.deprecatedNode()) 559 n = n->parentNode(); 560 if (n) 561 offset = n->nodeIndex() + 1; 562 } 563 removeChildrenInRange(m_downstreamEnd.deprecatedNode(), offset, m_downstreamEnd.deprecatedEditingOffset()); 564 m_downstreamEnd = createLegacyEditingPosition(m_downstreamEnd.deprecatedNode(), offset); 565 } 566 } 567 } 568 } 569 } 570 571 void DeleteSelectionCommand::fixupWhitespace() 572 { 573 document().updateLayoutIgnorePendingStylesheets(); 574 // FIXME: isRenderedCharacter should be removed, and we should use VisiblePosition::characterAfter and VisiblePosition::characterBefore 575 if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharacter() && m_leadingWhitespace.deprecatedNode()->isTextNode()) { 576 Text* textNode = toText(m_leadingWhitespace.deprecatedNode()); 577 ASSERT(!textNode->renderer() || textNode->renderer()->style()->collapseWhiteSpace()); 578 replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString()); 579 } 580 if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedCharacter() && m_trailingWhitespace.deprecatedNode()->isTextNode()) { 581 Text* textNode = toText(m_trailingWhitespace.deprecatedNode()); 582 ASSERT(!textNode->renderer() ||textNode->renderer()->style()->collapseWhiteSpace()); 583 replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.deprecatedEditingOffset(), 1, nonBreakingSpaceString()); 584 } 585 } 586 587 // If a selection starts in one block and ends in another, we have to merge to bring content before the 588 // start together with content after the end. 589 void DeleteSelectionCommand::mergeParagraphs() 590 { 591 if (!m_mergeBlocksAfterDelete) { 592 if (m_pruneStartBlockIfNecessary) { 593 // We aren't going to merge into the start block, so remove it if it's empty. 594 prune(m_startBlock); 595 // Removing the start block during a deletion is usually an indication that we need 596 // a placeholder, but not in this case. 597 m_needPlaceholder = false; 598 } 599 return; 600 } 601 602 // It shouldn't have been asked to both try and merge content into the start block and prune it. 603 ASSERT(!m_pruneStartBlockIfNecessary); 604 605 // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839). 606 if (!m_downstreamEnd.inDocument() || !m_upstreamStart.inDocument()) 607 return; 608 609 // FIXME: The deletion algorithm shouldn't let this happen. 610 if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0) 611 return; 612 613 // There's nothing to merge. 614 if (m_upstreamStart == m_downstreamEnd) 615 return; 616 617 VisiblePosition startOfParagraphToMove(m_downstreamEnd); 618 VisiblePosition mergeDestination(m_upstreamStart); 619 620 // m_downstreamEnd's block has been emptied out by deletion. There is no content inside of it to 621 // move, so just remove it. 622 Element* endBlock = enclosingBlock(m_downstreamEnd.deprecatedNode()); 623 if (!endBlock || !endBlock->contains(startOfParagraphToMove.deepEquivalent().deprecatedNode()) || !startOfParagraphToMove.deepEquivalent().deprecatedNode()) { 624 removeNode(enclosingBlock(m_downstreamEnd.deprecatedNode())); 625 return; 626 } 627 628 // We need to merge into m_upstreamStart's block, but it's been emptied out and collapsed by deletion. 629 if (!mergeDestination.deepEquivalent().deprecatedNode() || (!mergeDestination.deepEquivalent().deprecatedNode()->isDescendantOf(enclosingBlock(m_upstreamStart.containerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChildren() || !m_upstreamStart.containerNode()->hasChildren())) || (m_startsAtEmptyLine && mergeDestination != startOfParagraphToMove)) { 630 insertNodeAt(createBreakElement(document()).get(), m_upstreamStart); 631 mergeDestination = VisiblePosition(m_upstreamStart); 632 } 633 634 if (mergeDestination == startOfParagraphToMove) 635 return; 636 637 VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary); 638 639 if (mergeDestination == endOfParagraphToMove) 640 return; 641 642 // If the merge destination and source to be moved are both list items of different lists, merge them into single list. 643 Node* listItemInFirstParagraph = enclosingNodeOfType(m_upstreamStart, isListItem); 644 Node* listItemInSecondParagraph = enclosingNodeOfType(m_downstreamEnd, isListItem); 645 if (listItemInFirstParagraph && listItemInSecondParagraph 646 && listItemInFirstParagraph->parentElement() != listItemInSecondParagraph->parentElement() 647 && canMergeLists(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement())) { 648 mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listItemInSecondParagraph->parentElement()); 649 m_endingPosition = mergeDestination.deepEquivalent(); 650 return; 651 } 652 653 // The rule for merging into an empty block is: only do so if its farther to the right. 654 // FIXME: Consider RTL. 655 if (!m_startsAtEmptyLine && isStartOfParagraph(mergeDestination) && startOfParagraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds().x()) { 656 if (isHTMLBRElement(*mergeDestination.deepEquivalent().downstream().deprecatedNode())) { 657 removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downstream().deprecatedNode()); 658 m_endingPosition = startOfParagraphToMove.deepEquivalent(); 659 return; 660 } 661 } 662 663 // Block images, tables and horizontal rules cannot be made inline with content at mergeDestination. If there is 664 // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the caret to just before the selection we deleted. 665 // See https://bugs.webkit.org/show_bug.cgi?id=25439 666 if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalent().deprecatedNode()) && !isStartOfParagraph(mergeDestination)) { 667 m_endingPosition = m_upstreamStart; 668 return; 669 } 670 671 // moveParagraphs will insert placeholders if it removes blocks that would require their use, don't let block 672 // removals that it does cause the insertion of *another* placeholder. 673 bool needPlaceholder = m_needPlaceholder; 674 bool paragraphToMergeIsEmpty = (startOfParagraphToMove == endOfParagraphToMove); 675 moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination, false, !paragraphToMergeIsEmpty); 676 m_needPlaceholder = needPlaceholder; 677 // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph). 678 m_endingPosition = endingSelection().start(); 679 } 680 681 void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows() 682 { 683 if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) { 684 Node* row = m_endTableRow->previousSibling(); 685 while (row && row != m_startTableRow) { 686 RefPtrWillBeRawPtr<Node> previousRow = row->previousSibling(); 687 if (isTableRowEmpty(row)) 688 // Use a raw removeNode, instead of DeleteSelectionCommand's, because 689 // that won't remove rows, it only empties them in preparation for this function. 690 CompositeEditCommand::removeNode(row); 691 row = previousRow.get(); 692 } 693 } 694 695 // Remove empty rows after the start row. 696 if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) { 697 Node* row = m_startTableRow->nextSibling(); 698 while (row && row != m_endTableRow) { 699 RefPtrWillBeRawPtr<Node> nextRow = row->nextSibling(); 700 if (isTableRowEmpty(row)) 701 CompositeEditCommand::removeNode(row); 702 row = nextRow.get(); 703 } 704 } 705 706 if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) 707 if (isTableRowEmpty(m_endTableRow.get())) { 708 // Don't remove m_endTableRow if it's where we're putting the ending selection. 709 if (!m_endingPosition.deprecatedNode()->isDescendantOf(m_endTableRow.get())) { 710 // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty. 711 // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow 712 // was fully selected here. 713 CompositeEditCommand::removeNode(m_endTableRow.get()); 714 } 715 } 716 } 717 718 void DeleteSelectionCommand::calculateTypingStyleAfterDelete() 719 { 720 // Clearing any previously set typing style and doing an early return. 721 if (!m_typingStyle) { 722 document().frame()->selection().clearTypingStyle(); 723 return; 724 } 725 726 // Compute the difference between the style before the delete and the style now 727 // after the delete has been done. Set this style on the frame, so other editing 728 // commands being composed with this one will work, and also cache it on the command, 729 // so the LocalFrame::appliedEditing can set it after the whole composite command 730 // has completed. 731 732 // If we deleted into a blockquote, but are now no longer in a blockquote, use the alternate typing style 733 if (m_deleteIntoBlockquoteStyle && !enclosingNodeOfType(m_endingPosition, isMailHTMLBlockquoteElement, CanCrossEditingBoundary)) 734 m_typingStyle = m_deleteIntoBlockquoteStyle; 735 m_deleteIntoBlockquoteStyle = nullptr; 736 737 m_typingStyle->prepareToApplyAt(m_endingPosition); 738 if (m_typingStyle->isEmpty()) 739 m_typingStyle = nullptr; 740 // This is where we've deleted all traces of a style but not a whole paragraph (that's handled above). 741 // In this case if we start typing, the new characters should have the same style as the just deleted ones, 742 // but, if we change the selection, come back and start typing that style should be lost. Also see 743 // preserveTypingStyle() below. 744 document().frame()->selection().setTypingStyle(m_typingStyle); 745 } 746 747 void DeleteSelectionCommand::clearTransientState() 748 { 749 m_selectionToDelete = VisibleSelection(); 750 m_upstreamStart.clear(); 751 m_downstreamStart.clear(); 752 m_upstreamEnd.clear(); 753 m_downstreamEnd.clear(); 754 m_endingPosition.clear(); 755 m_leadingWhitespace.clear(); 756 m_trailingWhitespace.clear(); 757 } 758 759 // This method removes div elements with no attributes that have only one child or no children at all. 760 void DeleteSelectionCommand::removeRedundantBlocks() 761 { 762 Node* node = m_endingPosition.containerNode(); 763 Element* rootElement = node->rootEditableElement(); 764 765 while (node != rootElement) { 766 if (isRemovableBlock(node)) { 767 if (node == m_endingPosition.anchorNode()) 768 updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node); 769 770 CompositeEditCommand::removeNodePreservingChildren(node); 771 node = m_endingPosition.anchorNode(); 772 } else 773 node = node->parentNode(); 774 } 775 } 776 777 void DeleteSelectionCommand::doApply() 778 { 779 // If selection has not been set to a custom selection when the command was created, 780 // use the current ending selection. 781 if (!m_hasSelectionToDelete) 782 m_selectionToDelete = endingSelection(); 783 784 if (!m_selectionToDelete.isNonOrphanedRange()) 785 return; 786 787 // save this to later make the selection with 788 EAffinity affinity = m_selectionToDelete.affinity(); 789 790 Position downstreamEnd = m_selectionToDelete.end().downstream(); 791 bool rootWillStayOpenWithoutPlaceholder = downstreamEnd.containerNode() == downstreamEnd.containerNode()->rootEditableElement() 792 || (downstreamEnd.containerNode()->isTextNode() && downstreamEnd.containerNode()->parentNode() == downstreamEnd.containerNode()->rootEditableElement()); 793 bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd()); 794 m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder 795 && isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditingBoundary) 796 && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBoundary) 797 && !lineBreakAtEndOfSelectionToDelete; 798 if (m_needPlaceholder) { 799 // Don't need a placeholder when deleting a selection that starts just before a table 800 // and ends inside it (we do need placeholders to hold open empty cells, but that's 801 // handled elsewhere). 802 if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart())) 803 if (m_selectionToDelete.end().deprecatedNode()->isDescendantOf(table)) 804 m_needPlaceholder = false; 805 } 806 807 808 // set up our state 809 initializePositionData(); 810 811 bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(VisiblePosition(m_upstreamStart).previous()); 812 813 // Delete any text that may hinder our ability to fixup whitespace after the delete 814 deleteInsignificantTextDownstream(m_trailingWhitespace); 815 816 saveTypingStyleState(); 817 818 // deleting just a BR is handled specially, at least because we do not 819 // want to replace it with a placeholder BR! 820 if (handleSpecialCaseBRDelete()) { 821 calculateTypingStyleAfterDelete(); 822 setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional())); 823 clearTransientState(); 824 rebalanceWhitespace(); 825 return; 826 } 827 828 handleGeneralDelete(); 829 830 fixupWhitespace(); 831 832 mergeParagraphs(); 833 834 removePreviouslySelectedEmptyTableRows(); 835 836 if (!m_needPlaceholder && rootWillStayOpenWithoutPlaceholder) { 837 VisiblePosition visualEnding(m_endingPosition); 838 bool hasPlaceholder = lineBreakExistsAtVisiblePosition(visualEnding) 839 && visualEnding.next(CannotCrossEditingBoundary).isNull(); 840 m_needPlaceholder = hasPlaceholder && lineBreakBeforeStart && !lineBreakAtEndOfSelectionToDelete; 841 } 842 843 RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBreakElement(document()) : nullptr; 844 845 if (placeholder) { 846 if (m_sanitizeMarkup) 847 removeRedundantBlocks(); 848 insertNodeAt(placeholder.get(), m_endingPosition); 849 } 850 851 rebalanceWhitespaceAt(m_endingPosition); 852 853 calculateTypingStyleAfterDelete(); 854 855 setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional())); 856 clearTransientState(); 857 } 858 859 EditAction DeleteSelectionCommand::editingAction() const 860 { 861 // Note that DeleteSelectionCommand is also used when the user presses the Delete key, 862 // but in that case there's a TypingCommand that supplies the editingAction(), so 863 // the Undo menu correctly shows "Undo Typing" 864 return EditActionCut; 865 } 866 867 // Normally deletion doesn't preserve the typing style that was present before it. For example, 868 // type a character, Bold, then delete the character and start typing. The Bold typing style shouldn't 869 // stick around. Deletion should preserve a typing style that *it* sets, however. 870 bool DeleteSelectionCommand::preservesTypingStyle() const 871 { 872 return m_typingStyle; 873 } 874 875 void DeleteSelectionCommand::trace(Visitor* visitor) 876 { 877 visitor->trace(m_selectionToDelete); 878 visitor->trace(m_upstreamStart); 879 visitor->trace(m_downstreamStart); 880 visitor->trace(m_upstreamEnd); 881 visitor->trace(m_downstreamEnd); 882 visitor->trace(m_endingPosition); 883 visitor->trace(m_leadingWhitespace); 884 visitor->trace(m_trailingWhitespace); 885 visitor->trace(m_startBlock); 886 visitor->trace(m_endBlock); 887 visitor->trace(m_typingStyle); 888 visitor->trace(m_deleteIntoBlockquoteStyle); 889 visitor->trace(m_startRoot); 890 visitor->trace(m_endRoot); 891 visitor->trace(m_startTableRow); 892 visitor->trace(m_endTableRow); 893 visitor->trace(m_temporaryPlaceholder); 894 CompositeEditCommand::trace(visitor); 895 } 896 897 } // namespace blink 898
