Source/core/editing/DeleteSelectionCommand.cpp - Issue 1294543005: Move execCommand related files in core/editing/ related files into core/editing/commands/

Side by Side Diff: Source/core/editing/DeleteSelectionCommand.cpp

Issue 1294543005: Move execCommand related files in core/editing/ related files into core/editing/commands/ (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: 2015-08-17T17:57:33 Created 5 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
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/EditingUtilities.h"

36 #include "core/editing/Editor.h"

37 #include "core/editing/VisibleUnits.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/layout/LayoutTableCell.h"

44 #include "core/layout/LayoutText.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)).deepEquivalent() == Visibl ePosition(lastPositionInNode(cell)).deepEquivalent();

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 smartDel ete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMa rkup)

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 = nullptr;

106 HTMLElement* endSpecialContainer = nullptr;

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 begi nning of the previous line, or (HR,0) when forward deleting,

112 // but in these cases, we want to delete it, so manually expand the selectio n

113 if (isHTMLHRElement(*start.anchorNode()))

114 start = positionBeforeNode(start.anchorNode());

115 else if (isHTMLHRElement(*end.anchorNode()))

116 end = positionAfterNode(end.anchorNode());

117

118 // FIXME: This is only used so that moveParagraphs can avoid the bugs in spe cial element expansion.

119 if (!m_expandForSpecialElements)

120 return;

121

122 while (1) {

123 startSpecialContainer = 0;

124 endSpecialContainer = 0;

125

126 Position s = positionBeforeContainingSpecialElement(start, &startSpecial Container);

127 Position e = positionAfterContainingSpecialElement(end, &endSpecialConta iner);

128

129 if (!startSpecialContainer && !endSpecialContainer)

130 break;

131

132 if (VisiblePosition(start).deepEquivalent() != m_selectionToDelete.visib leStart().deepEquivalent() \|\| VisiblePosition(end).deepEquivalent() != m_selecti onToDelete.visibleEnd().deepEquivalent())

133 break;

134

135 // If we're going to expand to include the startSpecialContainer, it mus t be fully selected.

136 if (startSpecialContainer && !endSpecialContainer && comparePositions(po sitionInParentAfterNode(*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(st art, positionInParentBeforeNode(*endSpecialContainer)) > -1)

141 break;

142

143 if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSp ecialContainer))

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(star tSpecialContainer))

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& s tart, 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, &isHTMLTa bleRowElement));

184 m_endTableRow = toHTMLTableRowElement(enclosingNodeOfType(end, &isHTMLTableR owElement));

185

186 // Don't move content out of a table cell.

187 // If the cell is non-editable, enclosingNodeOfType won't return it by defau lt, so

188 // tell that function that we don't care if it returns non-editable nodes.

189 Node* startCell = enclosingNodeOfType(m_upstreamStart, &isTableCell, CanCros sEditingBoundary);

190 Node* endCell = enclosingNodeOfType(m_downstreamEnd, &isTableCell, CanCrossE ditingBoundary);

191 // FIXME: This isn't right. A borderless table with two rows and a single c olumn 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 toget her as a result of the deletion.

196 // Sometimes they aren't (like when no merge is requested), so we must choos e 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 le vel of content after deleting

205 // selections that contain a whole number paragraphs plus a line break, sinc e it is unclear to most users

206 // that such a selection actually ends at the start of the next paragraph. T his 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(VisiblePosit ion(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 adjustmen ts to the selection

218 m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selection ToDelete.affinity());

219 m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAUL T_AFFINITY);

220

221 if (m_smartDelete) {

222

223 // skip smart delete if the selection to delete already starts or ends w ith whitespace

224 Position pos = VisiblePosition(m_upstreamStart, m_selectionToDelete.affi nity()).deepEquivalent();

225 bool skipSmartDelete = trailingWhitespacePosition(pos, VP_DEFAULT_AFFINI TY, ConsiderNonCollapsibleWhitespace).isNotNull();

226 if (!skipSmartDelete)

227 skipSmartDelete = leadingWhitespacePosition(m_downstreamEnd, VP_DEFA ULT_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_DEF AULT_AFFINITY).previous();

233 pos = visiblePos.deepEquivalent();

234 // Expand out one character upstream for smart delete and recalculat e

235 // positions based on this change.

236 m_upstreamStart = pos.upstream();

237 m_downstreamStart = pos.downstream();

238 m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, vis iblePos.affinity());

239

240 setStartingSelectionOnSmartDelete(m_upstreamStart, m_upstreamEnd);

241 }

242

243 // trailing whitespace is only considered for smart delete if there is n o leading

244 // whitespace, as in the case where you double-click the first word of a paragraph.

245 if (!skipSmartDelete && !hasLeadingWhitespaceBeforeAdjustment && trailin gWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY, ConsiderNonCollapsible Whitespace).isNotNull()) {

246 // Expand out one character downstream for smart delete and recalcul ate

247 // positions based on this change.

248 pos = VisiblePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY).next().d eepEquivalent();

249 m_upstreamEnd = pos.upstream();

250 m_downstreamEnd = pos.downstream();

251 m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, V P_DEFAULT_AFFINITY);

252

253 setStartingSelectionOnSmartDelete(m_downstreamStart, m_downstreamEnd );

254 }

255 }

256

257 // We must pass call parentAnchoredEquivalent on the positions since some ed iting 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 editi ng positions.

261 // FIXME: Passing false to enclosingNodeOfType tells it that it's OK to retu rn a non-editable

262 // node. This was done to match existing behavior, but it seems wrong.

263 m_startBlock = enclosingNodeOfType(m_downstreamStart.parentAnchoredEquivalen t(), &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 b e the

277 // same as the style at the start of the selection after deletion (since tho se

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.anchorNode() == m_downstreamEnd.anchorNode() && m_upstre amStart.anchorNode()->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(), EditingSty le::EditingPropertiesInEffect);

290 m_typingStyle->removeStyleAddedByElement(enclosingAnchorElement(m_selectionT oDelete.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 outsid e of a Mail blockquote

294 if (enclosingNodeOfType(m_selectionToDelete.start(), isMailHTMLBlockquoteEle ment))

295 m_deleteIntoBlockquoteStyle = EditingStyle::create(m_selectionToDelete.e nd());

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 b y itself after another BR.

311 bool upstreamStartIsBR = isHTMLBRElement(*nodeAfterUpstreamStart);

312 bool downstreamStartIsBR = isHTMLBRElement(*nodeAfterDownstreamStart);

313 bool isBROnLineByItself = upstreamStartIsBR && downstreamStartIsBR && nodeAf terDownstreamStart == 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(VisiblePosi tion(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(VisiblePositio n(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, Shoul dAssumeContentIsAlwaysEditable 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 inserte d.

376 document().updateLayoutIgnorePendingStylesheets();

377 LayoutObject* r = node->layoutObject();

378 if (r && r->isTableCell() && toLayoutTableCell(r)->contentHeight() <= 0) {

379 Position firstEditablePosition = firstEditablePositionInNode(node.ge t());

380 if (firstEditablePosition.isNotNull())

381 insertBlockPlaceholder(firstEditablePosition);

382 }

383 return;

384 }

385

386 if (node == m_startBlock) {

387 VisiblePosition previous = VisiblePosition(firstPositionInNode(m_startBl ock.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, Posi tion& position)

406 {

407 if (!position.isOffsetInAnchor() \|\| position.computeContainerNode() != node)

408 return;

409

410 if (position.offsetInContainerNode() > offset + count)

411 position = Position(position.computeContainerNode(), position.offsetInCo ntainerNode() - count);

412 else if (position.offsetInContainerNode() > offset)

413 position = Position(position.computeContainerNode(), offset);

414 }

415

416 void DeleteSelectionCommand::deleteTextFromNode(PassRefPtrWillBeRawPtr<Text> nod e, 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::makeStylingElementsDirectChildrenOfEditableRootToPr eventStyleLoss()

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->rootEditable Element();

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.computeEditingOffset();

451 Node* startNode = m_upstreamStart.anchorNode();

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 && canHaveChil drenForEditing(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 >= EditingStrategy::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.anchorNode()) {

480 if (m_downstreamEnd.computeEditingOffset() - 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.computeOff setInContainerNode() - startOffset);

485 } else {

486 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.co mputeEditingOffset());

487 m_endingPosition = m_upstreamStart;

488 }

489 }

490

491 // The selection to delete is all in one node.

492 if (!startNode->layoutObject() \|\| (!startOffset && m_downstreamEnd.atLas tEditingPositionForNode()))

493 removeNode(startNode);

494 }

495 else {

496 bool startNodeWasDescendantOfEndNode = m_upstreamStart.anchorNode()->isD escendantOf(m_downstreamEnd.anchorNode());

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() - startOffs et);

505 node = NodeTraversal::next(*node);

506 } else {

507 node = NodeTraversal::childAt(*startNode, startOffset);

508 }

509 } else if (startNode == m_upstreamEnd.anchorNode() && startNode->isTextN ode()) {

510 Text* text = toText(m_upstreamEnd.anchorNode());

511 deleteTextFromNode(text, 0, m_upstreamEnd.computeOffsetInContainerNo de());

512 }

513

514 // handle deleting all nodes that are completely selected

515 while (node && node != m_downstreamEnd.anchorNode()) {

516 if (comparePositions(firstPositionInOrBeforeNode(node.get()), m_down streamEnd) >= 0) {

517 // NodeTraversal::nextSkippingChildren just blew past the end po sition, so stop deleting

518 node = nullptr;

519 } else if (!m_downstreamEnd.anchorNode()->isDescendantOf(node.get()) ) {

520 RefPtrWillBeRawPtr<Node> nextNode = NodeTraversal::nextSkippingC hildren(*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.anchorNode() == n && m_downstreamEnd.compute EditingOffset() >= caretMaxOffset(&n)) {

529 removeNode(node.get());

530 node = nullptr;

531 } else {

532 node = NodeTraversal::next(*node);

533 }

534 }

535 }

536

537 if (m_downstreamEnd.anchorNode() != startNode && !m_upstreamStart.anchor Node()->isDescendantOf(m_downstreamEnd.anchorNode()) && m_downstreamEnd.inDocume nt() && m_downstreamEnd.computeEditingOffset() >= caretMinOffset(m_downstreamEnd .anchorNode())) {

538 if (m_downstreamEnd.atLastEditingPositionForNode() && !canHaveChildr enForEditing(m_downstreamEnd.anchorNode())) {

539 // The node itself is fully selected, not just its contents. De lete it.

540 removeNode(m_downstreamEnd.anchorNode());

541 } else {

542 if (m_downstreamEnd.anchorNode()->isTextNode()) {

543 // in a text node that needs to be trimmed

544 Text* text = toText(m_downstreamEnd.anchorNode());

545 if (m_downstreamEnd.computeEditingOffset() > 0) {

546 deleteTextFromNode(text, 0, m_downstreamEnd.computeEditi ngOffset());

547 }

548 // Remove children of m_downstreamEnd.anchorNode() that come aft er m_upstreamStart.

549 // Don't try to remove children if m_upstreamStart was inside m_ downstreamEnd.anchorNode()

550 // and m_upstreamStart has been removed from the document, becau se 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.anchorNode()->isDescendantOf(m_downstrea mEnd.anchorNode())) {

557 Node* n = m_upstreamStart.anchorNode();

558 while (n && n->parentNode() != m_downstreamEnd.anchorNod e())

559 n = n->parentNode();

560 if (n)

561 offset = n->nodeIndex() + 1;

562 }

563 removeChildrenInRange(m_downstreamEnd.anchorNode(), offset, m_downstreamEnd.computeEditingOffset());

564 m_downstreamEnd = createLegacyEditingPosition(m_downstreamEn d.anchorNode(), 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 VisiblePo sition::characterAfter and VisiblePosition::characterBefore

575 if (m_leadingWhitespace.isNotNull() && !m_leadingWhitespace.isRenderedCharac ter() && m_leadingWhitespace.anchorNode()->isTextNode()) {

576 Text* textNode = toText(m_leadingWhitespace.anchorNode());

577 ASSERT(!textNode->layoutObject() \|\| textNode->layoutObject()->style()->c ollapseWhiteSpace());

578 replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.compute OffsetInContainerNode(), 1, nonBreakingSpaceString());

579 }

580 if (m_trailingWhitespace.isNotNull() && !m_trailingWhitespace.isRenderedChar acter() && m_trailingWhitespace.anchorNode()->isTextNode()) {

581 Text* textNode = toText(m_trailingWhitespace.anchorNode());

582 ASSERT(!textNode->layoutObject() \|\| textNode->layoutObject()->style()->c ollapseWhiteSpace());

583 replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.comput eOffsetInContainerNode(), 1, nonBreakingSpaceString());

584 }

585 }

586

587 // If a selection starts in one block and ends in another, we have to merge to b ring 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 indicati on 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 co ntent inside of it to

621 // move, so just remove it.

622 Element* endBlock = enclosingBlock(m_downstreamEnd.anchorNode());

623 if (!endBlock \|\| !endBlock->contains(startOfParagraphToMove.deepEquivalent() .anchorNode()) \|\| !startOfParagraphToMove.deepEquivalent().anchorNode()) {

624 removeNode(enclosingBlock(m_downstreamEnd.anchorNode()));

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().anchorNode() \|\| (!mergeDestination.de epEquivalent().anchorNode()->isDescendantOf(enclosingBlock(m_upstreamStart.compu teContainerNode())) && (!mergeDestination.deepEquivalent().anchorNode()->hasChil dren() \|\| !m_upstreamStart.computeContainerNode()->hasChildren())) \|\| (m_startsA tEmptyLine && mergeDestination.deepEquivalent() != startOfParagraphToMove.deepEq uivalent())) {

630 insertNodeAt(createBreakElement(document()).get(), m_upstreamStart);

631 mergeDestination = VisiblePosition(m_upstreamStart);

632 }

633

634 if (mergeDestination.deepEquivalent() == startOfParagraphToMove.deepEquivale nt())

635 return;

636

637 VisiblePosition endOfParagraphToMove = endOfParagraph(startOfParagraphToMove , CanSkipOverEditingBoundary);

638

639 if (mergeDestination.deepEquivalent() == endOfParagraphToMove.deepEquivalent ())

640 return;

641

642 // If the merge destination and source to be moved are both list items of di fferent lists, merge them into single list.

643 Node* listItemInFirstParagraph = enclosingNodeOfType(m_upstreamStart, isList Item);

644 Node* listItemInSecondParagraph = enclosingNodeOfType(m_downstreamEnd, isLis tItem);

645 if (listItemInFirstParagraph && listItemInSecondParagraph

646 && listItemInFirstParagraph->parentElement() != listItemInSecondParagrap h->parentElement()

647 && canMergeLists(listItemInFirstParagraph->parentElement(), listItemInSe condParagraph->parentElement())) {

648 mergeIdenticalElements(listItemInFirstParagraph->parentElement(), listIt emInSecondParagraph->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) && startOfP aragraphToMove.absoluteCaretBounds().x() > mergeDestination.absoluteCaretBounds( ).x()) {

656 if (isHTMLBRElement(*mergeDestination.deepEquivalent().downstream().anch orNode())) {

657 removeNodeAndPruneAncestors(mergeDestination.deepEquivalent().downst ream().anchorNode());

658 m_endingPosition = startOfParagraphToMove.deepEquivalent();

659 return;

660 }

661 }

662

663 // Block images, tables and horizontal rules cannot be made inline with cont ent at mergeDestination. If there is

664 // any (!isStartOfParagraph(mergeDestination)), don't merge, just move the c aret to just before the selection we deleted.

665 // See https://bugs.webkit.org/show_bug.cgi?id=25439

666 if (isRenderedAsNonInlineTableImageOrHR(startOfParagraphToMove.deepEquivalen t().anchorNode()) && !isStartOfParagraph(mergeDestination)) {

667 m_endingPosition = m_upstreamStart;

668 return;

669 }

670

671 // moveParagraphs will insert placeholders if it removes blocks that would r equire 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.deepEquivalent() == en dOfParagraphToMove.deepEquivalent();

675 moveParagraph(startOfParagraphToMove, endOfParagraphToMove, mergeDestination , false, !paragraphToMergeIsEmpty);

676 m_needPlaceholder = needPlaceholder;

677 // The endingPosition was likely clobbered by the move, so recompute it (mov eParagraph 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_start TableRow) {

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, be cause

689 // that won't remove rows, it only empties them in preparation f or 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_start TableRow)

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.anchorNode()->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 edi ting

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 co mmand

730 // has completed.

731

732 // If we deleted into a blockquote, but are now no longer in a blockquote, u se the alternate typing style

733 if (m_deleteIntoBlockquoteStyle && !enclosingNodeOfType(m_endingPosition, is MailHTMLBlockquoteElement, 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 paragra ph (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 sh ould 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 = Position();

751 m_downstreamStart = Position();

752 m_upstreamEnd = Position();

753 m_downstreamEnd = Position();

754 m_endingPosition = Position();

755 m_leadingWhitespace = Position();

756 m_trailingWhitespace = Position();

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.computeContainerNode();

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() \|\| !m_selectionToDelete.isCont entEditable())

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.computeContainerNode () == downstreamEnd.computeContainerNode()->rootEditableElement()

792 \|\| (downstreamEnd.computeContainerNode()->isTextNode() && downstreamEnd. computeContainerNode()->parentNode() == downstreamEnd.computeContainerNode()->ro otEditableElement());

793 bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(m_ selectionToDelete.visibleEnd());

794 m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder

795 && isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditin gBoundary)

796 && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBou ndary)

797 && !lineBreakAtEndOfSelectionToDelete;

798 if (m_needPlaceholder) {

799 // Don't need a placeholder when deleting a selection that starts just b efore 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.visib leStart()))

803 if (m_selectionToDelete.end().anchorNode()->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, endingSe lection().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 && !lineBreak AtEndOfSelectionToDelete;

841 }

842

843 RefPtrWillBeRawPtr<HTMLBRElement> placeholder = m_needPlaceholder ? createBr eakElement(document()) : nullptr;

844

845 if (placeholder) {

846 if (m_sanitizeMarkup)

847 removeRedundantBlocks();

848 // handleGeneralDelete cause DOM mutation events so \|m_endingPosition\|

849 // can be out of document.

850 if (m_endingPosition.inDocument())

851 insertNodeAt(placeholder.get(), m_endingPosition);

852 }

853

854 rebalanceWhitespaceAt(m_endingPosition);

855

856 calculateTypingStyleAfterDelete();

857

858 setEndingSelection(VisibleSelection(m_endingPosition, affinity, endingSelect ion().isDirectional()));

859 clearTransientState();

860 }

861

862 EditAction DeleteSelectionCommand::editingAction() const

863 {

864 // Note that DeleteSelectionCommand is also used when the user presses the D elete key,

865 // but in that case there's a TypingCommand that supplies the editingAction( ), so

866 // the Undo menu correctly shows "Undo Typing"

867 return EditActionCut;

868 }

869

870 // Normally deletion doesn't preserve the typing style that was present before i t. For example,

871 // type a character, Bold, then delete the character and start typing. The Bold typing style shouldn't

872 // stick around. Deletion should preserve a typing style that it sets, howeve r.

873 bool DeleteSelectionCommand::preservesTypingStyle() const

874 {

875 return m_typingStyle;

876 }

877

878 DEFINE_TRACE(DeleteSelectionCommand)

879 {

880 visitor->trace(m_selectionToDelete);

881 visitor->trace(m_upstreamStart);

882 visitor->trace(m_downstreamStart);

883 visitor->trace(m_upstreamEnd);

884 visitor->trace(m_downstreamEnd);

885 visitor->trace(m_endingPosition);

886 visitor->trace(m_leadingWhitespace);

887 visitor->trace(m_trailingWhitespace);

888 visitor->trace(m_startBlock);

889 visitor->trace(m_endBlock);

890 visitor->trace(m_typingStyle);

891 visitor->trace(m_deleteIntoBlockquoteStyle);

892 visitor->trace(m_startRoot);

893 visitor->trace(m_endRoot);

894 visitor->trace(m_startTableRow);

895 visitor->trace(m_endTableRow);

896 visitor->trace(m_temporaryPlaceholder);

897 CompositeEditCommand::trace(visitor);

898 }

899

900 } // namespace blink

OLD	NEW

« Source/core/core.gypi ('K') | « Source/core/editing/DeleteSelectionCommand.h ('k') | Source/core/editing/EditAction.h » ('j') | Source/core/editing/commands/EditAction.h » ('J')