2 * Copyright (C) 2005 Apple Computer, Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
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.
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.
27 #include "core/editing/DeleteSelectionCommand.h"
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"
48 using namespace HTMLNames;
50 static bool isTableCellEmpty(Node* cell)
52 ASSERT(isTableCell(cell));
53 return VisiblePosition(firstPositionInNode(cell)) == VisiblePosition(lastPositionInNode(cell));
56 static bool isTableRowEmpty(Node* row)
58 if (!isHTMLTableRowElement(row))
61 for (Node* child = row->firstChild(); child; child = child->nextSibling())
62 if (isTableCell(child) && !isTableCellEmpty(child))
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)
80 , m_typingStyle(nullptr)
81 , m_deleteIntoBlockquoteStyle(nullptr)
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)
98 , m_typingStyle(nullptr)
99 , m_deleteIntoBlockquoteStyle(nullptr)
103 void DeleteSelectionCommand::initializeStartEnd(Position& start, Position& end)
105 HTMLElement* startSpecialContainer = nullptr;
106 HTMLElement* endSpecialContainer = nullptr;
108 start = m_selectionToDelete.start();
109 end = m_selectionToDelete.end();
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());
118 // FIXME: This is only used so that moveParagraphs can avoid the bugs in special element expansion.
119 if (!m_expandForSpecialElements)
123 startSpecialContainer = 0;
124 endSpecialContainer = 0;
126 Position s = positionBeforeContainingSpecialElement(start, &startSpecialContainer);
127 Position e = positionAfterContainingSpecialElement(end, &endSpecialContainer);
129 if (!startSpecialContainer && !endSpecialContainer)
132 if (VisiblePosition(start) != m_selectionToDelete.visibleStart() || VisiblePosition(end) != m_selectionToDelete.visibleEnd())
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)
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)
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).
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).
158 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end)
160 bool isBaseFirst = startingSelection().isBaseFirst();
161 VisiblePosition newBase(isBaseFirst ? start : end);
162 VisiblePosition newExtent(isBaseFirst ? end : start);
163 setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional()));
166 void DeleteSelectionCommand::initializePositionData()
169 initializeStartEnd(start, end);
171 ASSERT(isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle));
172 if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle))
173 end = lastEditablePositionBeforePositionInRoot(end, highestEditableRoot(start));
175 m_upstreamStart = start.upstream();
176 m_downstreamStart = start.downstream();
177 m_upstreamEnd = end.upstream();
178 m_downstreamEnd = end.downstream();
180 m_startRoot = editableRootForPosition(start);
181 m_endRoot = editableRootForPosition(end);
183 m_startTableRow = toHTMLTableRowElement(enclosingNodeOfType(start, &isHTMLTableRowElement));
184 m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableRowElement));
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;
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;
202 m_endingPosition = m_downstreamStart;
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;
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);
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();
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());
240 setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);
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);
253 setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd);
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);
267 // We don't want to inherit style from an element which can't have contents.
268 static bool shouldNotInheritStyleFrom(const Node& node)
270 return !node.canContainRangeEndPoint();
273 void DeleteSelectionCommand::saveTypingStyleState()
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())
285 if (shouldNotInheritStyleFrom(*m_selectionToDelete.start().anchorNode()))
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()));
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());
297 m_deleteIntoBlockquoteStyle = nullptr;
300 bool DeleteSelectionCommand::handleSpecialCaseBRDelete()
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();
307 if (!nodeAfterUpstreamStart || !nodeAfterDownstreamStart)
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);
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;
329 static Position firstEditablePositionInNode(Node* node)
333 while (next && !next->hasEditableStyle())
334 next = NodeTraversal::next(*next, node);
335 return next ? firstPositionInOrBeforeNode(next) : Position();
338 void DeleteSelectionCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
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())
349 // Search this non-editable region for editable regions to empty.
350 RefPtrWillBeRawPtr<Node> child = node->firstChild();
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)
360 // Don't remove editable regions that are inside non-editable ones, just clear them.
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();
370 Node* remove = child;
371 child = child->nextSibling();
372 removeNode(remove, shouldAssumeContentIsAlwaysEditable);
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);
386 if (node == m_startBlock) {
387 VisiblePosition previous = VisiblePosition(firstPositionInNode(m_startBlock.get())).previous();
388 if (previous.isNotNull() && !isEndOfBlock(previous))
389 m_needPlaceholder = true;
391 if (node == m_endBlock) {
392 VisiblePosition next = VisiblePosition(lastPositionInNode(m_endBlock.get())).next();
393 if (next.isNotNull() && !isStartOfBlock(next))
394 m_needPlaceholder = true;
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);
402 CompositeEditCommand::removeNode(node, shouldAssumeContentIsAlwaysEditable);
405 static void updatePositionForTextRemoval(Text* node, int offset, int count, Position& position)
407 if (position.anchorType() != Position::PositionIsOffsetInAnchor || position.containerNode() != node)
410 if (position.offsetInContainerNode() > offset + count)
411 position.moveToOffset(position.offsetInContainerNode() - count);
412 else if (position.offsetInContainerNode() > offset)
413 position.moveToOffset(offset);
416 void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> node, unsigned offset, unsigned count)
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);
424 CompositeEditCommand::deleteTextFromNode(node, offset, count);
427 void DeleteSelectionCommand::makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss()
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()) {
438 appendNode(node, rootEditableElement);
445 void DeleteSelectionCommand::handleGeneralDelete()
447 if (m_upstreamStart.isNull())
450 int startOffset = m_upstreamStart.deprecatedEditingOffset();
451 Node* startNode = m_upstreamStart.deprecatedNode();
454 makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss();
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)) {
459 startNode = NodeTraversal::next(*startNode);
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));
470 if (startOffset >= lastOffsetForEditing(startNode)) {
471 startNode = NodeTraversal::nextSkippingChildren(*startNode);
475 // Done adjusting the start. See if we're all done.
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);
486 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.deprecatedEditingOffset());
487 m_endingPosition = m_upstreamStart;
491 // The selection to delete is all in one node.
492 if (!startNode->renderer() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))
493 removeNode(startNode);
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);
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);
507 node = NodeTraversal::childAt(*startNode, startOffset);
509 } else if (startNode == m_upstreamEnd.deprecatedNode() && startNode->isTextNode()) {
510 Text* text = toText(m_upstreamEnd.deprecatedNode());
511 deleteTextFromNode(text, 0, m_upstreamEnd.deprecatedEditingOffset());
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
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();
527 Node& n = NodeTraversal::lastWithinOrSelf(*node);
528 if (m_downstreamEnd.deprecatedNode() == n && m_downstreamEnd.deprecatedEditingOffset() >= caretMaxOffset(&n)) {
529 removeNode(node.get());
532 node = NodeTraversal::next(*node);
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());
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());
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())) {
556 if (m_upstreamStart.deprecatedNode()->isDescendantOf(m_downstreamEnd.deprecatedNode())) {
557 Node* n = m_upstreamStart.deprecatedNode();
558 while (n && n->parentNode() != m_downstreamEnd.deprecatedNode())
561 offset = n->nodeIndex() + 1;
563 removeChildrenInRange(m_downstreamEnd.deprecatedNode(), offset, m_downstreamEnd.deprecatedEditingOffset());
564 m_downstreamEnd = createLegacyEditingPosition(m_downstreamEnd.deprecatedNode(), offset);
571 void DeleteSelectionCommand::fixupWhitespace()
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());
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());
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()
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.
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;
602 // It shouldn't have been asked to both try and merge content into the start block and prune it.
603 ASSERT(!m_pruneStartBlockIfNecessary);
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())
609 // FIXME: The deletion algorithm shouldn't let this happen.
610 if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
613 // There's nothing to merge.
614 if (m_upstreamStart == m_downstreamEnd)
617 VisiblePosition startOfParagraphToMove(m_downstreamEnd);
618 VisiblePosition mergeDestination(m_upstreamStart);
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()));
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);
634 if (mergeDestination == startOfParagraphToMove)
637 VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove, CanSkipOverEditingBoundary);
639 if (mergeDestination == endOfParagraphToMove)
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();
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();
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;
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();
681 void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
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();
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);
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());
718 void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
720 // Clearing any previously set typing style and doing an early return.
721 if (!m_typingStyle) {
722 document().frame()->selection().clearTypingStyle();
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
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;
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);
747 void DeleteSelectionCommand::clearTransientState()
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();
759 // This method removes div elements with no attributes that have only one child or no children at all.
760 void DeleteSelectionCommand::removeRedundantBlocks()
762 Node* node = m_endingPosition.containerNode();
763 Element* rootElement = node->rootEditableElement();
765 while (node != rootElement) {
766 if (isRemovableBlock(node)) {
767 if (node == m_endingPosition.anchorNode())
768 updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node);
770 CompositeEditCommand::removeNodePreservingChildren(node);
771 node = m_endingPosition.anchorNode();
773 node = node->parentNode();
777 void DeleteSelectionCommand::doApply()
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();
784 if (!m_selectionToDelete.isNonOrphanedRange())
787 // save this to later make the selection with
788 EAffinity affinity = m_selectionToDelete.affinity();
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;
809 initializePositionData();
811 bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(VisiblePosition(m_upstreamStart).previous());
813 // Delete any text that may hinder our ability to fixup whitespace after the delete
814 deleteInsignificantTextDownstream(m_trailingWhitespace);
816 saveTypingStyleState();
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();
828 handleGeneralDelete();
834 removePreviouslySelectedEmptyTableRows();
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;
843 RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBreakElement(document()) : nullptr;
846 if (m_sanitizeMarkup)
847 removeRedundantBlocks();
848 insertNodeAt(placeholder.get(), m_endingPosition);
851 rebalanceWhitespaceAt(m_endingPosition);
853 calculateTypingStyleAfterDelete();
855 setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelection().isDirectional()));
856 clearTransientState();
859 EditAction DeleteSelectionCommand::editingAction() const
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;
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
872 return m_typingStyle;
875 void DeleteSelectionCommand::trace(Visitor* visitor)
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);