1 /* 2 * Copyright (C) 2006, 2010 Apple 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/InsertListCommand.h" 28 29 #include "HTMLNames.h" 30 #include "bindings/v8/ExceptionStatePlaceholder.h" 31 #include "core/dom/Element.h" 32 #include "core/editing/TextIterator.h" 33 #include "core/editing/VisibleUnits.h" 34 #include "core/editing/htmlediting.h" 35 #include "core/html/HTMLElement.h" 36 37 namespace WebCore { 38 39 using namespace HTMLNames; 40 41 static Node* enclosingListChild(Node* node, Node* listNode) 42 { 43 Node* listChild = enclosingListChild(node); 44 while (listChild && enclosingList(listChild) != listNode) 45 listChild = enclosingListChild(listChild->parentNode()); 46 return listChild; 47 } 48 49 PassRefPtr<HTMLElement> InsertListCommand::insertList(Document* document, Type type) 50 { 51 RefPtr<InsertListCommand> insertCommand = create(document, type); 52 insertCommand->apply(); 53 return insertCommand->m_listElement; 54 } 55 56 HTMLElement* InsertListCommand::fixOrphanedListChild(Node* node) 57 { 58 RefPtr<HTMLElement> listElement = createUnorderedListElement(document()); 59 insertNodeBefore(listElement, node); 60 removeNode(node); 61 appendNode(node, listElement); 62 m_listElement = listElement; 63 return listElement.get(); 64 } 65 66 PassRefPtr<HTMLElement> InsertListCommand::mergeWithNeighboringLists(PassRefPtr<HTMLElement> passedList) 67 { 68 RefPtr<HTMLElement> list = passedList; 69 Element* previousList = list->previousElementSibling(); 70 if (canMergeLists(previousList, list.get())) 71 mergeIdenticalElements(previousList, list); 72 73 if (!list || !list->nextElementSibling() || !list->nextElementSibling()->isHTMLElement()) 74 return list.release(); 75 76 RefPtr<HTMLElement> nextList = toHTMLElement(list->nextElementSibling()); 77 if (canMergeLists(list.get(), nextList.get())) { 78 mergeIdenticalElements(list, nextList); 79 return nextList.release(); 80 } 81 return list.release(); 82 } 83 84 bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection, const QualifiedName& listTag) 85 { 86 VisiblePosition start = selection.visibleStart(); 87 88 if (!enclosingList(start.deepEquivalent().deprecatedNode())) 89 return false; 90 91 VisiblePosition end = startOfParagraph(selection.visibleEnd()); 92 while (start.isNotNull() && start != end) { 93 Element* listNode = enclosingList(start.deepEquivalent().deprecatedNode()); 94 if (!listNode || !listNode->hasTagName(listTag)) 95 return false; 96 start = startOfNextParagraph(start); 97 } 98 99 return true; 100 } 101 102 InsertListCommand::InsertListCommand(Document* document, Type type) 103 : CompositeEditCommand(document), m_type(type) 104 { 105 } 106 107 void InsertListCommand::doApply() 108 { 109 if (!endingSelection().isNonOrphanedCaretOrRange()) 110 return; 111 112 if (!endingSelection().rootEditableElement()) 113 return; 114 115 VisiblePosition visibleEnd = endingSelection().visibleEnd(); 116 VisiblePosition visibleStart = endingSelection().visibleStart(); 117 // When a selection ends at the start of a paragraph, we rarely paint 118 // the selection gap before that paragraph, because there often is no gap. 119 // In a case like this, it's not obvious to the user that the selection 120 // ends "inside" that paragraph, so it would be confusing if InsertUn{Ordered}List 121 // operated on that paragraph. 122 // FIXME: We paint the gap before some paragraphs that are indented with left 123 // margin/padding, but not others. We should make the gap painting more consistent and 124 // then use a left margin/padding rule here. 125 if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd, CanSkipOverEditingBoundary)) 126 setEndingSelection(VisibleSelection(visibleStart, visibleEnd.previous(CannotCrossEditingBoundary), endingSelection().isDirectional())); 127 128 const QualifiedName& listTag = (m_type == OrderedList) ? olTag : ulTag; 129 if (endingSelection().isRange()) { 130 VisibleSelection selection = selectionForParagraphIteration(endingSelection()); 131 ASSERT(selection.isRange()); 132 VisiblePosition startOfSelection = selection.visibleStart(); 133 VisiblePosition endOfSelection = selection.visibleEnd(); 134 VisiblePosition startOfLastParagraph = startOfParagraph(endOfSelection, CanSkipOverEditingBoundary); 135 136 if (startOfParagraph(startOfSelection, CanSkipOverEditingBoundary) != startOfLastParagraph) { 137 bool forceCreateList = !selectionHasListOfType(selection, listTag); 138 139 RefPtr<Range> currentSelection = endingSelection().firstRange(); 140 VisiblePosition startOfCurrentParagraph = startOfSelection; 141 while (!inSameParagraph(startOfCurrentParagraph, startOfLastParagraph, CanCrossEditingBoundary)) { 142 // doApply() may operate on and remove the last paragraph of the selection from the document 143 // if it's in the same list item as startOfCurrentParagraph. Return early to avoid an 144 // infinite loop and because there is no more work to be done. 145 // FIXME(<rdar://problem/5983974>): The endingSelection() may be incorrect here. Compute 146 // the new location of endOfSelection and use it as the end of the new selection. 147 if (!startOfLastParagraph.deepEquivalent().anchorNode()->inDocument()) 148 return; 149 setEndingSelection(startOfCurrentParagraph); 150 151 // Save and restore endOfSelection and startOfLastParagraph when necessary 152 // since moveParagraph and movePragraphWithClones can remove nodes. 153 // FIXME: This is an inefficient way to keep selection alive because indexForVisiblePosition walks from 154 // the beginning of the document to the endOfSelection everytime this code is executed. 155 // But not using index is hard because there are so many ways we can lose selection inside doApplyForSingleParagraph. 156 RefPtr<ContainerNode> scope; 157 int indexForEndOfSelection = indexForVisiblePosition(endOfSelection, scope); 158 doApplyForSingleParagraph(forceCreateList, listTag, currentSelection.get()); 159 if (endOfSelection.isNull() || endOfSelection.isOrphan() || startOfLastParagraph.isNull() || startOfLastParagraph.isOrphan()) { 160 endOfSelection = visiblePositionForIndex(indexForEndOfSelection, scope.get()); 161 // If endOfSelection is null, then some contents have been deleted from the document. 162 // This should never happen and if it did, exit early immediately because we've lost the loop invariant. 163 ASSERT(endOfSelection.isNotNull()); 164 if (endOfSelection.isNull()) 165 return; 166 startOfLastParagraph = startOfParagraph(endOfSelection, CanSkipOverEditingBoundary); 167 } 168 169 // Fetch the start of the selection after moving the first paragraph, 170 // because moving the paragraph will invalidate the original start. 171 // We'll use the new start to restore the original selection after 172 // we modified all selected paragraphs. 173 if (startOfCurrentParagraph == startOfSelection) 174 startOfSelection = endingSelection().visibleStart(); 175 176 startOfCurrentParagraph = startOfNextParagraph(endingSelection().visibleStart()); 177 } 178 setEndingSelection(endOfSelection); 179 doApplyForSingleParagraph(forceCreateList, listTag, currentSelection.get()); 180 // Fetch the end of the selection, for the reason mentioned above. 181 endOfSelection = endingSelection().visibleEnd(); 182 setEndingSelection(VisibleSelection(startOfSelection, endOfSelection, endingSelection().isDirectional())); 183 return; 184 } 185 } 186 187 doApplyForSingleParagraph(false, listTag, endingSelection().firstRange().get()); 188 } 189 190 void InsertListCommand::doApplyForSingleParagraph(bool forceCreateList, const QualifiedName& listTag, Range* currentSelection) 191 { 192 // FIXME: This will produce unexpected results for a selection that starts just before a 193 // table and ends inside the first cell, selectionForParagraphIteration should probably 194 // be renamed and deployed inside setEndingSelection(). 195 Node* selectionNode = endingSelection().start().deprecatedNode(); 196 Node* listChildNode = enclosingListChild(selectionNode); 197 bool switchListType = false; 198 if (listChildNode) { 199 // Remove the list chlild. 200 RefPtr<HTMLElement> listNode = enclosingList(listChildNode); 201 if (!listNode) { 202 listNode = fixOrphanedListChild(listChildNode); 203 listNode = mergeWithNeighboringLists(listNode); 204 } 205 if (!listNode->hasTagName(listTag)) 206 // listChildNode will be removed from the list and a list of type m_type will be created. 207 switchListType = true; 208 209 // If the list is of the desired type, and we are not removing the list, then exit early. 210 if (!switchListType && forceCreateList) 211 return; 212 213 // If the entire list is selected, then convert the whole list. 214 if (switchListType && isNodeVisiblyContainedWithin(listNode.get(), currentSelection)) { 215 bool rangeStartIsInList = visiblePositionBeforeNode(listNode.get()) == currentSelection->startPosition(); 216 bool rangeEndIsInList = visiblePositionAfterNode(listNode.get()) == currentSelection->endPosition(); 217 218 RefPtr<HTMLElement> newList = createHTMLElement(document(), listTag); 219 insertNodeBefore(newList, listNode); 220 221 Node* firstChildInList = enclosingListChild(VisiblePosition(firstPositionInNode(listNode.get())).deepEquivalent().deprecatedNode(), listNode.get()); 222 Node* outerBlock = firstChildInList->isBlockFlowElement() ? firstChildInList : listNode.get(); 223 224 moveParagraphWithClones(firstPositionInNode(listNode.get()), lastPositionInNode(listNode.get()), newList.get(), outerBlock); 225 226 // Manually remove listNode because moveParagraphWithClones sometimes leaves it behind in the document. 227 // See the bug 33668 and editing/execCommand/insert-list-orphaned-item-with-nested-lists.html. 228 // FIXME: This might be a bug in moveParagraphWithClones or deleteSelection. 229 if (listNode && listNode->inDocument()) 230 removeNode(listNode); 231 232 newList = mergeWithNeighboringLists(newList); 233 234 // Restore the start and the end of current selection if they started inside listNode 235 // because moveParagraphWithClones could have removed them. 236 if (rangeStartIsInList && newList) 237 currentSelection->setStart(newList, 0, IGNORE_EXCEPTION); 238 if (rangeEndIsInList && newList) 239 currentSelection->setEnd(newList, lastOffsetInNode(newList.get()), IGNORE_EXCEPTION); 240 241 setEndingSelection(VisiblePosition(firstPositionInNode(newList.get()))); 242 243 return; 244 } 245 246 unlistifyParagraph(endingSelection().visibleStart(), listNode.get(), listChildNode); 247 } 248 249 if (!listChildNode || switchListType || forceCreateList) 250 m_listElement = listifyParagraph(endingSelection().visibleStart(), listTag); 251 } 252 253 void InsertListCommand::unlistifyParagraph(const VisiblePosition& originalStart, HTMLElement* listNode, Node* listChildNode) 254 { 255 Node* nextListChild; 256 Node* previousListChild; 257 VisiblePosition start; 258 VisiblePosition end; 259 if (listChildNode->hasTagName(liTag)) { 260 start = firstPositionInNode(listChildNode); 261 end = lastPositionInNode(listChildNode); 262 nextListChild = listChildNode->nextSibling(); 263 previousListChild = listChildNode->previousSibling(); 264 } else { 265 // A paragraph is visually a list item minus a list marker. The paragraph will be moved. 266 start = startOfParagraph(originalStart, CanSkipOverEditingBoundary); 267 end = endOfParagraph(start, CanSkipOverEditingBoundary); 268 nextListChild = enclosingListChild(end.next().deepEquivalent().deprecatedNode(), listNode); 269 ASSERT(nextListChild != listChildNode); 270 previousListChild = enclosingListChild(start.previous().deepEquivalent().deprecatedNode(), listNode); 271 ASSERT(previousListChild != listChildNode); 272 } 273 // When removing a list, we must always create a placeholder to act as a point of insertion 274 // for the list content being removed. 275 RefPtr<Element> placeholder = createBreakElement(document()); 276 RefPtr<Element> nodeToInsert = placeholder; 277 // If the content of the list item will be moved into another list, put it in a list item 278 // so that we don't create an orphaned list child. 279 if (enclosingList(listNode)) { 280 nodeToInsert = createListItemElement(document()); 281 appendNode(placeholder, nodeToInsert); 282 } 283 284 if (nextListChild && previousListChild) { 285 // We want to pull listChildNode out of listNode, and place it before nextListChild 286 // and after previousListChild, so we split listNode and insert it between the two lists. 287 // But to split listNode, we must first split ancestors of listChildNode between it and listNode, 288 // if any exist. 289 // FIXME: We appear to split at nextListChild as opposed to listChildNode so that when we remove 290 // listChildNode below in moveParagraphs, previousListChild will be removed along with it if it is 291 // unrendered. But we ought to remove nextListChild too, if it is unrendered. 292 splitElement(listNode, splitTreeToNode(nextListChild, listNode)); 293 insertNodeBefore(nodeToInsert, listNode); 294 } else if (nextListChild || listChildNode->parentNode() != listNode) { 295 // Just because listChildNode has no previousListChild doesn't mean there isn't any content 296 // in listNode that comes before listChildNode, as listChildNode could have ancestors 297 // between it and listNode. So, we split up to listNode before inserting the placeholder 298 // where we're about to move listChildNode to. 299 if (listChildNode->parentNode() != listNode) 300 splitElement(listNode, splitTreeToNode(listChildNode, listNode).get()); 301 insertNodeBefore(nodeToInsert, listNode); 302 } else 303 insertNodeAfter(nodeToInsert, listNode); 304 305 VisiblePosition insertionPoint = VisiblePosition(positionBeforeNode(placeholder.get())); 306 moveParagraphs(start, end, insertionPoint, /* preserveSelection */ true, /* preserveStyle */ true, listChildNode); 307 } 308 309 static Element* adjacentEnclosingList(const VisiblePosition& pos, const VisiblePosition& adjacentPos, const QualifiedName& listTag) 310 { 311 Element* listNode = outermostEnclosingList(adjacentPos.deepEquivalent().deprecatedNode()); 312 313 if (!listNode) 314 return 0; 315 316 Node* previousCell = enclosingTableCell(pos.deepEquivalent()); 317 Node* currentCell = enclosingTableCell(adjacentPos.deepEquivalent()); 318 319 if (!listNode->hasTagName(listTag) 320 || listNode->contains(pos.deepEquivalent().deprecatedNode()) 321 || previousCell != currentCell 322 || enclosingList(listNode) != enclosingList(pos.deepEquivalent().deprecatedNode())) 323 return 0; 324 325 return listNode; 326 } 327 328 PassRefPtr<HTMLElement> InsertListCommand::listifyParagraph(const VisiblePosition& originalStart, const QualifiedName& listTag) 329 { 330 VisiblePosition start = startOfParagraph(originalStart, CanSkipOverEditingBoundary); 331 VisiblePosition end = endOfParagraph(start, CanSkipOverEditingBoundary); 332 333 if (start.isNull() || end.isNull()) 334 return 0; 335 336 // Check for adjoining lists. 337 RefPtr<HTMLElement> listItemElement = createListItemElement(document()); 338 RefPtr<HTMLElement> placeholder = createBreakElement(document()); 339 appendNode(placeholder, listItemElement); 340 341 // Place list item into adjoining lists. 342 Element* previousList = adjacentEnclosingList(start.deepEquivalent(), start.previous(CannotCrossEditingBoundary), listTag); 343 Element* nextList = adjacentEnclosingList(start.deepEquivalent(), end.next(CannotCrossEditingBoundary), listTag); 344 RefPtr<HTMLElement> listElement; 345 if (previousList) 346 appendNode(listItemElement, previousList); 347 else if (nextList) 348 insertNodeAt(listItemElement, positionBeforeNode(nextList)); 349 else { 350 // Create the list. 351 listElement = createHTMLElement(document(), listTag); 352 appendNode(listItemElement, listElement); 353 354 if (start == end && isBlock(start.deepEquivalent().deprecatedNode())) { 355 // Inserting the list into an empty paragraph that isn't held open 356 // by a br or a '\n', will invalidate start and end. Insert 357 // a placeholder and then recompute start and end. 358 RefPtr<Node> placeholder = insertBlockPlaceholder(start.deepEquivalent()); 359 start = positionBeforeNode(placeholder.get()); 360 end = start; 361 } 362 363 // Insert the list at a position visually equivalent to start of the 364 // paragraph that is being moved into the list. 365 // Try to avoid inserting it somewhere where it will be surrounded by 366 // inline ancestors of start, since it is easier for editing to produce 367 // clean markup when inline elements are pushed down as far as possible. 368 Position insertionPos(start.deepEquivalent().upstream()); 369 // Also avoid the containing list item. 370 Node* listChild = enclosingListChild(insertionPos.deprecatedNode()); 371 if (listChild && listChild->hasTagName(liTag)) 372 insertionPos = positionInParentBeforeNode(listChild); 373 374 insertNodeAt(listElement, insertionPos); 375 376 // We inserted the list at the start of the content we're about to move 377 // Update the start of content, so we don't try to move the list into itself. bug 19066 378 // Layout is necessary since start's node's inline renderers may have been destroyed by the insertion 379 // The end of the content may have changed after the insertion and layout so update it as well. 380 if (insertionPos == start.deepEquivalent()) { 381 listElement->document()->updateLayoutIgnorePendingStylesheets(); 382 start = startOfParagraph(originalStart, CanSkipOverEditingBoundary); 383 end = endOfParagraph(start, CanSkipOverEditingBoundary); 384 } 385 } 386 387 moveParagraph(start, end, positionBeforeNode(placeholder.get()), true); 388 389 if (listElement) 390 return mergeWithNeighboringLists(listElement); 391 392 if (canMergeLists(previousList, nextList)) 393 mergeIdenticalElements(previousList, nextList); 394 395 return listElement; 396 } 397 398 } 399
