static char* webkitAccessibleTextGetWordForBoundary(AtkText* text, int offset, AtkTextBoundary boundaryType, GetTextRelativePosition textPosition, int* startOffset, int* endOffset) { AccessibilityObject* coreObject = core(text); Document* document = coreObject->document(); if (!document) return emptyTextSelectionAtOffset(0, startOffset, endOffset); Node* node = getNodeForAccessibilityObject(coreObject); if (!node) return emptyTextSelectionAtOffset(0, startOffset, endOffset); int actualOffset = atkOffsetToWebCoreOffset(text, offset); // Besides of the usual conversion from ATK offsets to WebCore offsets, // we need to consider the potential embedded objects that might have been // inserted in the text exposed through AtkText when calculating the offset. actualOffset -= numberOfReplacedElementsBeforeOffset(text, actualOffset); VisiblePosition caretPosition = coreObject->visiblePositionForIndex(actualOffset); VisibleSelection currentWord = wordAtPositionForAtkBoundary(coreObject, caretPosition, boundaryType); // Take into account other relative positions, if needed, by // calculating the new position that we would need to consider. VisiblePosition newPosition = caretPosition; switch (textPosition) { case GetTextPositionAt: break; case GetTextPositionBefore: // Early return if asking for the previous word while already at the beginning. if (isFirstVisiblePositionInNode(currentWord.visibleStart(), node)) return emptyTextSelectionAtOffset(0, startOffset, endOffset); if (isStartOfLine(currentWord.end())) newPosition = currentWord.visibleStart().previous(); else newPosition = startOfWord(currentWord.start(), LeftWordIfOnBoundary); break; case GetTextPositionAfter: // Early return if asking for the following word while already at the end. if (isLastVisiblePositionInNode(currentWord.visibleEnd(), node)) return emptyTextSelectionAtOffset(accessibilityObjectLength(coreObject), startOffset, endOffset); if (isEndOfLine(currentWord.end())) newPosition = currentWord.visibleEnd().next(); else newPosition = endOfWord(currentWord.end(), RightWordIfOnBoundary); break; default: ASSERT_NOT_REACHED(); } // Determine the relevant word we are actually interested in // and calculate the ATK offsets for it, then return everything. VisibleSelection selectedWord = newPosition != caretPosition ? wordAtPositionForAtkBoundary(coreObject, newPosition, boundaryType) : currentWord; getSelectionOffsetsForObject(coreObject, selectedWord, *startOffset, *endOffset); return webkitAccessibleTextGetText(text, *startOffset, *endOffset); }
VisibleSelection visibleSelectionForClosestActualWordStart(const VisibleSelection& selection) { // VisibleSelection validation has a special case when the caret is at the end of a paragraph where // it selects the paragraph marker. As well, if the position is at the end of a word, it will select // only the space between words. We want to select an actual word so we move the selection to // the start of the leftmost word if the character after the selection point is whitespace. if (selection.selectionType() != VisibleSelection::RangeSelection) { int leftDistance = 0; int rightDistance = 0; VisibleSelection leftSelection(previousWordPosition(selection.start())); bool leftSelectionIsOnWord = !isWhitespace(leftSelection.visibleStart().characterAfter()) && leftSelection.start().containerNode() == selection.start().containerNode(); if (leftSelectionIsOnWord) { VisibleSelection rangeSelection(endOfWord(leftSelection.start()), selection.visibleStart()); leftDistance = TextIterator::rangeLength(rangeSelection.toNormalizedRange().get()); } VisibleSelection rightSelection = previousWordPosition(nextWordPosition(selection.start())); bool rightSelectionIsOnWord = !isWhitespace(rightSelection.visibleStart().characterAfter()) && rightSelection.start().containerNode() == selection.start().containerNode(); if (rightSelectionIsOnWord) { VisibleSelection rangeSelection = VisibleSelection(rightSelection.visibleStart(), selection.visibleStart()); rightDistance = TextIterator::rangeLength(rangeSelection.toNormalizedRange().get()); } // Make sure we found an actual word. If not, return the original selection. if (!leftSelectionIsOnWord && !rightSelectionIsOnWord) return selection; if (!rightSelectionIsOnWord || (leftSelectionIsOnWord && leftDistance <= rightDistance)) { // Left is closer or right is invalid. return leftSelection; } // Right is closer or equal, or left was invalid. return rightSelection; } // No adjustment required. return selection; }
void SpellChecker::spellCheckOldSelection(const VisibleSelection& oldSelection, const VisibleSelection& newAdjacentWords) { VisiblePosition oldStart(oldSelection.visibleStart()); VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary)); if (oldAdjacentWords != newAdjacentWords) { if (isContinuousSpellCheckingEnabled() && isGrammarCheckingEnabled()) { VisibleSelection selectedSentence = VisibleSelection(startOfSentence(oldStart), endOfSentence(oldStart)); markMisspellingsAndBadGrammar(oldAdjacentWords, true, selectedSentence); } else { markMisspellingsAndBadGrammar(oldAdjacentWords, false, oldAdjacentWords); } } }
void SpellChecker::respondToChangedSelection(const VisibleSelection& oldSelection, FrameSelection::SetSelectionOptions options) { bool closeTyping = options & FrameSelection::CloseTyping; bool isContinuousSpellCheckingEnabled = this->isContinuousSpellCheckingEnabled(); bool isContinuousGrammarCheckingEnabled = isContinuousSpellCheckingEnabled && isGrammarCheckingEnabled(); if (isContinuousSpellCheckingEnabled) { VisibleSelection newAdjacentWords; VisibleSelection newSelectedSentence; const VisibleSelection newSelection = m_frame.selection().selection(); VisiblePosition newStart(newSelection.visibleStart()); newAdjacentWords = VisibleSelection(startOfWord(newStart, LeftWordIfOnBoundary), endOfWord(newStart, RightWordIfOnBoundary)); if (isContinuousGrammarCheckingEnabled) newSelectedSentence = VisibleSelection(startOfSentence(newStart), endOfSentence(newStart)); // Don't check spelling and grammar if the change of selection is triggered by spelling correction itself. bool shouldCheckSpellingAndGrammar = !(options & FrameSelection::SpellCorrectionTriggered); // When typing we check spelling elsewhere, so don't redo it here. // If this is a change in selection resulting from a delete operation, // oldSelection may no longer be in the document. // FIXME(http://crbug.com/382809): if oldSelection is on a textarea // element, we cause synchronous layout. if (shouldCheckSpellingAndGrammar && closeTyping && !isSelectionInTextField(oldSelection) && (isSelectionInTextArea(oldSelection) || oldSelection.isContentEditable()) && oldSelection.start().inDocument()) { spellCheckOldSelection(oldSelection, newAdjacentWords); } // FIXME(http://crbug.com/382809): // shouldEraseMarkersAfterChangeSelection is true, we cause synchronous // layout. if (textChecker().shouldEraseMarkersAfterChangeSelection(TextCheckingTypeSpelling)) { if (RefPtr<Range> wordRange = newAdjacentWords.toNormalizedRange()) m_frame.document()->markers().removeMarkers(wordRange.get(), DocumentMarker::Spelling); } if (textChecker().shouldEraseMarkersAfterChangeSelection(TextCheckingTypeGrammar)) { if (RefPtr<Range> sentenceRange = newSelectedSentence.toNormalizedRange()) m_frame.document()->markers().removeMarkers(sentenceRange.get(), DocumentMarker::Grammar); } } // When continuous spell checking is off, existing markers disappear after the selection changes. if (!isContinuousSpellCheckingEnabled) m_frame.document()->markers().removeMarkers(DocumentMarker::Spelling); if (!isContinuousGrammarCheckingEnabled) m_frame.document()->markers().removeMarkers(DocumentMarker::Grammar); }
void IndentOutdentCommand::indentRegion() { VisibleSelection selection = selectionForParagraphIteration(endingSelection()); VisiblePosition startOfSelection = selection.visibleStart(); VisiblePosition endOfSelection = selection.visibleEnd(); int startIndex = indexForVisiblePosition(startOfSelection); int endIndex = indexForVisiblePosition(endOfSelection); ASSERT(!startOfSelection.isNull()); ASSERT(!endOfSelection.isNull()); // Special case empty unsplittable elements because there's nothing to split // and there's nothing to move. Position start = startOfSelection.deepEquivalent().downstream(); if (isAtUnsplittableElement(start)) { RefPtr<Element> blockquote = createIndentBlockquoteElement(document()); insertNodeAt(blockquote, start); RefPtr<Element> placeholder = createBreakElement(document()); appendNode(placeholder, blockquote); setEndingSelection(VisibleSelection(Position(placeholder.get(), 0), DOWNSTREAM)); return; } RefPtr<Element> blockquoteForNextIndent; VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection); VisiblePosition endAfterSelection = endOfParagraph(endOfParagraph(endOfSelection).next()); while (endOfCurrentParagraph != endAfterSelection) { // Iterate across the selected paragraphs... VisiblePosition endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next()); if (tryIndentingAsListItem(endOfCurrentParagraph)) blockquoteForNextIndent = 0; else indentIntoBlockquote(endOfCurrentParagraph, endOfNextParagraph, blockquoteForNextIndent); // blockquoteForNextIndent maybe updated // this is due to the way prepareBlockquoteLevelForInsertion was designed. // Sanity check: Make sure our moveParagraph calls didn't remove endOfNextParagraph.deepEquivalent().node() // If somehow we did, return to prevent crashes. if (endOfNextParagraph.isNotNull() && !endOfNextParagraph.deepEquivalent().node()->inDocument()) { ASSERT_NOT_REACHED(); return; } endOfCurrentParagraph = endOfNextParagraph; } RefPtr<Range> startRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, 0, true); RefPtr<Range> endRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endIndex, 0, true); if (startRange && endRange) setEndingSelection(VisibleSelection(startRange->startPosition(), endRange->startPosition(), DOWNSTREAM)); }
void ApplyBlockElementCommand::doApply() { if (!endingSelection().rootEditableElement()) return; VisiblePosition visibleEnd = endingSelection().visibleEnd(); VisiblePosition visibleStart = endingSelection().visibleStart(); if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() || visibleEnd.isOrphan()) return; // When a selection ends at the start of a paragraph, we rarely paint // the selection gap before that paragraph, because there often is no gap. // In a case like this, it's not obvious to the user that the selection // ends "inside" that paragraph, so it would be confusing if Indent/Outdent // operated on that paragraph. // FIXME: We paint the gap before some paragraphs that are indented with left // margin/padding, but not others. We should make the gap painting more consistent and // then use a left margin/padding rule here. if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd)) { VisibleSelection newSelection(visibleStart, visibleEnd.previous(CannotCrossEditingBoundary), endingSelection().isDirectional()); if (newSelection.isNone()) return; setEndingSelection(newSelection); } VisibleSelection selection = selectionForParagraphIteration(endingSelection()); VisiblePosition startOfSelection = selection.visibleStart(); VisiblePosition endOfSelection = selection.visibleEnd(); ASSERT(!startOfSelection.isNull()); ASSERT(!endOfSelection.isNull()); RefPtrWillBeRawPtr<ContainerNode> startScope = nullptr; int startIndex = indexForVisiblePosition(startOfSelection, startScope); RefPtrWillBeRawPtr<ContainerNode> endScope = nullptr; int endIndex = indexForVisiblePosition(endOfSelection, endScope); formatSelection(startOfSelection, endOfSelection); document().updateLayoutIgnorePendingStylesheets(); ASSERT(startScope == endScope); ASSERT(startIndex >= 0); ASSERT(startIndex <= endIndex); if (startScope == endScope && startIndex >= 0 && startIndex <= endIndex) { VisiblePosition start(visiblePositionForIndex(startIndex, startScope.get())); VisiblePosition end(visiblePositionForIndex(endIndex, endScope.get())); if (start.isNotNull() && end.isNotNull()) setEndingSelection(VisibleSelection(start, end, endingSelection().isDirectional())); } }
bool InsertListCommand::selectionHasListOfType(const VisibleSelection& selection, const HTMLQualifiedName& listTag) { VisiblePosition start = selection.visibleStart(); if (!enclosingList(start.deepEquivalent().deprecatedNode())) return false; VisiblePosition end = startOfParagraph(selection.visibleEnd()); while (start.isNotNull() && start != end) { HTMLElement* listElement = enclosingList(start.deepEquivalent().deprecatedNode()); if (!listElement || !listElement->hasTagName(listTag)) return false; start = startOfNextParagraph(start); } return true; }
bool InsertListCommand::modifyRange() { VisibleSelection selection = selectionForParagraphIteration(endingSelection()); ASSERT(selection.isRange()); VisiblePosition startOfSelection = selection.visibleStart(); VisiblePosition endOfSelection = selection.visibleEnd(); VisiblePosition startOfLastParagraph = startOfParagraph(endOfSelection); if (startOfParagraph(startOfSelection) == startOfLastParagraph) return false; Node* startList = enclosingList(startOfSelection.deepEquivalent().node()); Node* endList = enclosingList(endOfSelection.deepEquivalent().node()); if (!startList || startList != endList) m_forceCreateList = true; setEndingSelection(startOfSelection); doApply(); // Fetch the start of the selection after moving the first paragraph, // because moving the paragraph will invalidate the original start. // We'll use the new start to restore the original selection after // we modified all selected paragraphs. startOfSelection = endingSelection().visibleStart(); VisiblePosition startOfCurrentParagraph = startOfNextParagraph(startOfSelection); while (startOfCurrentParagraph != startOfLastParagraph) { // doApply() may operate on and remove the last paragraph of the selection from the document // if it's in the same list item as startOfCurrentParagraph. Return early to avoid an // infinite loop and because there is no more work to be done. // FIXME(<rdar://problem/5983974>): The endingSelection() may be incorrect here. Compute // the new location of endOfSelection and use it as the end of the new selection. if (!startOfLastParagraph.deepEquivalent().node()->inDocument()) return true; setEndingSelection(startOfCurrentParagraph); doApply(); startOfCurrentParagraph = startOfNextParagraph(endingSelection().visibleStart()); } setEndingSelection(endOfSelection); doApply(); // Fetch the end of the selection, for the reason mentioned above. endOfSelection = endingSelection().visibleEnd(); setEndingSelection(VisibleSelection(startOfSelection, endOfSelection)); m_forceCreateList = false; return true; }
void IndentOutdentCommand::doApply() { if (!endingSelection().isNonOrphanedCaretOrRange()) return; if (!endingSelection().rootEditableElement()) return; VisiblePosition visibleEnd = endingSelection().visibleEnd(); VisiblePosition visibleStart = endingSelection().visibleStart(); // When a selection ends at the start of a paragraph, we rarely paint // the selection gap before that paragraph, because there often is no gap. // In a case like this, it's not obvious to the user that the selection // ends "inside" that paragraph, so it would be confusing if Indent/Outdent // operated on that paragraph. // FIXME: We paint the gap before some paragraphs that are indented with left // margin/padding, but not others. We should make the gap painting more consistent and // then use a left margin/padding rule here. if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd)) setEndingSelection(VisibleSelection(visibleStart, visibleEnd.previous(true))); VisibleSelection selection = selectionForParagraphIteration(endingSelection()); VisiblePosition startOfSelection = selection.visibleStart(); VisiblePosition endOfSelection = selection.visibleEnd(); int startIndex = indexForVisiblePosition(startOfSelection); int endIndex = indexForVisiblePosition(endOfSelection); ASSERT(!startOfSelection.isNull()); ASSERT(!endOfSelection.isNull()); if (m_typeOfAction == Indent) indentRegion(startOfSelection, endOfSelection); else outdentRegion(startOfSelection, endOfSelection); updateLayout(); RefPtr<Range> startRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), startIndex, 0, true); RefPtr<Range> endRange = TextIterator::rangeFromLocationAndLength(document()->documentElement(), endIndex, 0, true); if (startRange && endRange) setEndingSelection(VisibleSelection(startRange->startPosition(), endRange->startPosition(), DOWNSTREAM)); }
void SpellChecker::markMisspellingsAfterLineBreak(const VisibleSelection& wordSelection) { if (unifiedTextCheckerEnabled()) { TextCheckingTypeMask textCheckingOptions = 0; if (isContinuousSpellCheckingEnabled()) textCheckingOptions |= TextCheckingTypeSpelling; if (isGrammarCheckingEnabled()) textCheckingOptions |= TextCheckingTypeGrammar; VisibleSelection wholeParagraph( startOfParagraph(wordSelection.visibleStart()), endOfParagraph(wordSelection.visibleEnd())); markAllMisspellingsAndBadGrammarInRanges( textCheckingOptions, wordSelection.toNormalizedRange().get(), wholeParagraph.toNormalizedRange().get()); } else { RefPtr<Range> misspellingRange = wordSelection.firstRange(); markMisspellings(wordSelection, misspellingRange); } }
bool InsertListCommand::selectionHasListOfType( const VisibleSelection& selection, const HTMLQualifiedName& listTag) { DCHECK(!document().needsLayoutTreeUpdate()); DocumentLifecycle::DisallowTransitionScope disallowTransition( document().lifecycle()); VisiblePosition start = selection.visibleStart(); if (!enclosingList(start.deepEquivalent().anchorNode())) return false; VisiblePosition end = startOfParagraph(selection.visibleEnd()); while (start.isNotNull() && start.deepEquivalent() != end.deepEquivalent()) { HTMLElement* listElement = enclosingList(start.deepEquivalent().anchorNode()); if (!listElement || !listElement->hasTagName(listTag)) return false; start = startOfNextParagraph(start); } return true; }
void Editor::transpose() { if (!canEdit()) return; VisibleSelection selection = m_frame.selection().selection(); if (!selection.isCaret()) return; // Make a selection that goes back one character and forward two characters. VisiblePosition caret = selection.visibleStart(); VisiblePosition next = isEndOfParagraph(caret) ? caret : caret.next(); VisiblePosition previous = next.previous(); if (next == previous) return; previous = previous.previous(); if (!inSameParagraph(next, previous)) return; RefPtr<Range> range = makeRange(previous, next); if (!range) return; VisibleSelection newSelection(range.get(), DOWNSTREAM); // Transpose the two characters. String text = plainText(range.get()); if (text.length() != 2) return; String transposed = text.right(1) + text.left(1); // Select the two characters. if (newSelection != m_frame.selection().selection()) m_frame.selection().setSelection(newSelection); // Insert the transposed characters. replaceSelectionWithText(transposed, false, false); }
void InsertLineBreakCommand::doApply() { deleteSelection(); VisibleSelection selection = endingSelection(); if (!selection.isNonOrphanedCaretOrRange()) return; VisiblePosition caret(selection.visibleStart()); // FIXME: If the node is hidden, we should still be able to insert text. // For now, we return to avoid a crash. https://bugs.webkit.org/show_bug.cgi?id=40342 if (caret.isNull()) return; Position pos(caret.deepEquivalent()); pos = positionAvoidingSpecialElementBoundary(pos); pos = positionOutsideTabSpan(pos); RefPtrWillBeRawPtr<Node> nodeToInsert = nullptr; if (shouldUseBreakElement(pos)) nodeToInsert = HTMLBRElement::create(document()); else nodeToInsert = document().createTextNode("\n"); // FIXME: Need to merge text nodes when inserting just after or before text. if (isEndOfParagraph(caret) && !lineBreakExistsAtVisiblePosition(caret)) { bool needExtraLineBreak = !isHTMLHRElement(*pos.anchorNode()) && !isHTMLTableElement(*pos.anchorNode()); insertNodeAt(nodeToInsert.get(), pos); if (needExtraLineBreak) insertNodeBefore(nodeToInsert->cloneNode(false), nodeToInsert); VisiblePosition endingPosition = createVisiblePosition(positionBeforeNode(nodeToInsert.get())); setEndingSelection(VisibleSelection(endingPosition, endingSelection().isDirectional())); } else if (pos.computeEditingOffset() <= caretMinOffset(pos.anchorNode())) { insertNodeAt(nodeToInsert.get(), pos); // Insert an extra br or '\n' if the just inserted one collapsed. if (!isStartOfParagraph(createVisiblePosition(positionBeforeNode(nodeToInsert.get())))) insertNodeBefore(nodeToInsert->cloneNode(false).get(), nodeToInsert.get()); setEndingSelection(VisibleSelection(positionInParentAfterNode(*nodeToInsert), TextAffinity::Downstream, endingSelection().isDirectional())); // If we're inserting after all of the rendered text in a text node, or into a non-text node, // a simple insertion is sufficient. } else if (!pos.anchorNode()->isTextNode() || pos.computeOffsetInContainerNode() >= caretMaxOffset(pos.anchorNode())) { insertNodeAt(nodeToInsert.get(), pos); setEndingSelection(VisibleSelection(positionInParentAfterNode(*nodeToInsert), TextAffinity::Downstream, endingSelection().isDirectional())); } else if (pos.anchorNode()->isTextNode()) { // Split a text node Text* textNode = toText(pos.anchorNode()); splitTextNode(textNode, pos.computeOffsetInContainerNode()); insertNodeBefore(nodeToInsert, textNode); Position endingPosition = firstPositionInNode(textNode); // Handle whitespace that occurs after the split document().updateLayoutIgnorePendingStylesheets(); // TODO(yosin) |isRenderedCharacter()| should be removed, and we should // use |VisiblePosition::characterAfter()|. if (!isRenderedCharacter(endingPosition)) { Position positionBeforeTextNode(positionInParentBeforeNode(*textNode)); // Clear out all whitespace and insert one non-breaking space deleteInsignificantTextDownstream(endingPosition); ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace()); // Deleting insignificant whitespace will remove textNode if it contains nothing but insignificant whitespace. if (textNode->inDocument()) { insertTextIntoNode(textNode, 0, nonBreakingSpaceString()); } else { RefPtrWillBeRawPtr<Text> nbspNode = document().createTextNode(nonBreakingSpaceString()); insertNodeAt(nbspNode.get(), positionBeforeTextNode); endingPosition = firstPositionInNode(nbspNode.get()); } } setEndingSelection(VisibleSelection(endingPosition, TextAffinity::Downstream, endingSelection().isDirectional())); } // Handle the case where there is a typing style. RefPtrWillBeRawPtr<EditingStyle> typingStyle = document().frame()->selection().typingStyle(); if (typingStyle && !typingStyle->isEmpty()) { // Apply the typing style to the inserted line break, so that if the selection // leaves and then comes back, new input will have the right style. // FIXME: We shouldn't always apply the typing style to the line break here, // see <rdar://problem/5794462>. applyStyle(typingStyle.get(), firstPositionInOrBeforeNode(nodeToInsert.get()), lastPositionInOrAfterNode(nodeToInsert.get())); // Even though this applyStyle operates on a Range, it still sets an endingSelection(). // It tries to set a VisibleSelection around the content it operated on. So, that VisibleSelection // will either (a) select the line break we inserted, or it will (b) be a caret just // before the line break (if the line break is at the end of a block it isn't selectable). // So, this next call sets the endingSelection() to a caret just after the line break // that we inserted, or just before it if it's at the end of a block. setEndingSelection(endingSelection().visibleEnd()); } rebalanceWhitespace(); }
void InsertLineBreakCommand::doApply(EditingState* editingState) { deleteSelection(editingState); if (editingState->isAborted()) return; document().updateStyleAndLayoutIgnorePendingStylesheets(); VisibleSelection selection = endingSelection(); if (!selection.isNonOrphanedCaretOrRange()) return; // TODO(xiaochengh): Stop storing VisiblePositions through mutations. VisiblePosition caret(selection.visibleStart()); // FIXME: If the node is hidden, we should still be able to insert text. For // now, we return to avoid a crash. // https://bugs.webkit.org/show_bug.cgi?id=40342 if (caret.isNull()) return; Position pos(caret.deepEquivalent()); pos = positionAvoidingSpecialElementBoundary(pos, editingState); if (editingState->isAborted()) return; pos = positionOutsideTabSpan(pos); Node* nodeToInsert = nullptr; if (shouldUseBreakElement(pos)) nodeToInsert = HTMLBRElement::create(document()); else nodeToInsert = document().createTextNode("\n"); document().updateStyleAndLayoutIgnorePendingStylesheets(); // FIXME: Need to merge text nodes when inserting just after or before text. if (isEndOfParagraph(createVisiblePosition(caret.toPositionWithAffinity())) && !lineBreakExistsAtVisiblePosition(caret)) { bool needExtraLineBreak = !isHTMLHRElement(*pos.anchorNode()) && !isHTMLTableElement(*pos.anchorNode()); insertNodeAt(nodeToInsert, pos, editingState); if (editingState->isAborted()) return; if (needExtraLineBreak) { Node* extraNode; // TODO(tkent): Can we remove HTMLTextFormControlElement dependency? if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(nodeToInsert)) { extraNode = textControl->createPlaceholderBreakElement(); // The placeholder BR should be the last child. There might be // empty Text nodes at |pos|. appendNode(extraNode, nodeToInsert->parentNode(), editingState); } else { extraNode = nodeToInsert->cloneNode(false); insertNodeAfter(extraNode, nodeToInsert, editingState); } if (editingState->isAborted()) return; nodeToInsert = extraNode; } setEndingSelection(SelectionInDOMTree::Builder() .collapse(Position::beforeNode(nodeToInsert)) .setIsDirectional(endingSelection().isDirectional()) .build()); } else if (pos.computeEditingOffset() <= caretMinOffset(pos.anchorNode())) { insertNodeAt(nodeToInsert, pos, editingState); if (editingState->isAborted()) return; document().updateStyleAndLayoutIgnorePendingStylesheets(); // Insert an extra br or '\n' if the just inserted one collapsed. if (!isStartOfParagraph(VisiblePosition::beforeNode(nodeToInsert))) { insertNodeBefore(nodeToInsert->cloneNode(false), nodeToInsert, editingState); if (editingState->isAborted()) return; } setEndingSelection(SelectionInDOMTree::Builder() .collapse(Position::inParentAfterNode(*nodeToInsert)) .setIsDirectional(endingSelection().isDirectional()) .build()); // If we're inserting after all of the rendered text in a text node, or into // a non-text node, a simple insertion is sufficient. } else if (!pos.anchorNode()->isTextNode() || pos.computeOffsetInContainerNode() >= caretMaxOffset(pos.anchorNode())) { insertNodeAt(nodeToInsert, pos, editingState); if (editingState->isAborted()) return; setEndingSelection(SelectionInDOMTree::Builder() .collapse(Position::inParentAfterNode(*nodeToInsert)) .setIsDirectional(endingSelection().isDirectional()) .build()); } else if (pos.anchorNode()->isTextNode()) { // Split a text node Text* textNode = toText(pos.anchorNode()); splitTextNode(textNode, pos.computeOffsetInContainerNode()); insertNodeBefore(nodeToInsert, textNode, editingState); if (editingState->isAborted()) return; Position endingPosition = Position::firstPositionInNode(textNode); // Handle whitespace that occurs after the split document().updateStyleAndLayoutIgnorePendingStylesheets(); // TODO(yosin) |isRenderedCharacter()| should be removed, and we should // use |VisiblePosition::characterAfter()|. if (!isRenderedCharacter(endingPosition)) { Position positionBeforeTextNode(Position::inParentBeforeNode(*textNode)); // Clear out all whitespace and insert one non-breaking space deleteInsignificantTextDownstream(endingPosition); DCHECK(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace()); // Deleting insignificant whitespace will remove textNode if it contains // nothing but insignificant whitespace. if (textNode->isConnected()) { insertTextIntoNode(textNode, 0, nonBreakingSpaceString()); } else { Text* nbspNode = document().createTextNode(nonBreakingSpaceString()); insertNodeAt(nbspNode, positionBeforeTextNode, editingState); if (editingState->isAborted()) return; endingPosition = Position::firstPositionInNode(nbspNode); } } setEndingSelection(SelectionInDOMTree::Builder() .collapse(endingPosition) .setIsDirectional(endingSelection().isDirectional()) .build()); } // Handle the case where there is a typing style. EditingStyle* typingStyle = document().frame()->selection().typingStyle(); if (typingStyle && !typingStyle->isEmpty()) { // Apply the typing style to the inserted line break, so that if the // selection leaves and then comes back, new input will have the right // style. // FIXME: We shouldn't always apply the typing style to the line break here, // see <rdar://problem/5794462>. applyStyle(typingStyle, firstPositionInOrBeforeNode(nodeToInsert), lastPositionInOrAfterNode(nodeToInsert), editingState); if (editingState->isAborted()) return; // Even though this applyStyle operates on a Range, it still sets an // endingSelection(). It tries to set a VisibleSelection around the content // it operated on. So, that VisibleSelection will either // (a) select the line break we inserted, or it will // (b) be a caret just before the line break (if the line break is at the // end of a block it isn't selectable). // So, this next call sets the endingSelection() to a caret just after the // line break that we inserted, or just before it if it's at the end of a // block. setEndingSelection(SelectionInDOMTree::Builder() .collapse(endingSelection().end()) .build()); } rebalanceWhitespace(); }
void InsertListCommand::doApply() { if (!endingSelection().isNonOrphanedCaretOrRange()) return; if (!endingSelection().rootEditableElement()) return; VisiblePosition visibleEnd = endingSelection().visibleEnd(); VisiblePosition visibleStart = endingSelection().visibleStart(); // When a selection ends at the start of a paragraph, we rarely paint // the selection gap before that paragraph, because there often is no gap. // In a case like this, it's not obvious to the user that the selection // ends "inside" that paragraph, so it would be confusing if InsertUn{Ordered}List // operated on that paragraph. // FIXME: We paint the gap before some paragraphs that are indented with left // margin/padding, but not others. We should make the gap painting more consistent and // then use a left margin/padding rule here. if (visibleEnd != visibleStart && isStartOfParagraph(visibleEnd, CanSkipOverEditingBoundary)) { setEndingSelection(VisibleSelection(visibleStart, visibleEnd.previous(CannotCrossEditingBoundary), endingSelection().isDirectional())); if (!endingSelection().rootEditableElement()) return; } const HTMLQualifiedName& listTag = (m_type == OrderedList) ? olTag : ulTag; if (endingSelection().isRange()) { bool forceListCreation = false; VisibleSelection selection = selectionForParagraphIteration(endingSelection()); ASSERT(selection.isRange()); VisiblePosition startOfSelection = selection.visibleStart(); VisiblePosition endOfSelection = selection.visibleEnd(); VisiblePosition startOfLastParagraph = startOfParagraph(endOfSelection, CanSkipOverEditingBoundary); RefPtrWillBeRawPtr<Range> currentSelection = endingSelection().firstRange(); RefPtrWillBeRawPtr<ContainerNode> scopeForStartOfSelection = nullptr; RefPtrWillBeRawPtr<ContainerNode> scopeForEndOfSelection = nullptr; // FIXME: This is an inefficient way to keep selection alive because // indexForVisiblePosition walks from the beginning of the document to the // endOfSelection everytime this code is executed. But not using index is hard // because there are so many ways we can los eselection inside doApplyForSingleParagraph. int indexForStartOfSelection = indexForVisiblePosition(startOfSelection, scopeForStartOfSelection); int indexForEndOfSelection = indexForVisiblePosition(endOfSelection, scopeForEndOfSelection); if (startOfParagraph(startOfSelection, CanSkipOverEditingBoundary) != startOfLastParagraph) { forceListCreation = !selectionHasListOfType(selection, listTag); VisiblePosition startOfCurrentParagraph = startOfSelection; while (startOfCurrentParagraph.isNotNull() && !inSameParagraph(startOfCurrentParagraph, startOfLastParagraph, CanCrossEditingBoundary)) { // doApply() may operate on and remove the last paragraph of the selection from the document // if it's in the same list item as startOfCurrentParagraph. Return early to avoid an // infinite loop and because there is no more work to be done. // FIXME(<rdar://problem/5983974>): The endingSelection() may be incorrect here. Compute // the new location of endOfSelection and use it as the end of the new selection. if (!startOfLastParagraph.deepEquivalent().inDocument()) return; setEndingSelection(startOfCurrentParagraph); // Save and restore endOfSelection and startOfLastParagraph when necessary // since moveParagraph and movePragraphWithClones can remove nodes. doApplyForSingleParagraph(forceListCreation, listTag, *currentSelection); if (endOfSelection.isNull() || endOfSelection.isOrphan() || startOfLastParagraph.isNull() || startOfLastParagraph.isOrphan()) { endOfSelection = visiblePositionForIndex(indexForEndOfSelection, scopeForEndOfSelection.get()); // If endOfSelection is null, then some contents have been deleted from the document. // This should never happen and if it did, exit early immediately because we've lost the loop invariant. ASSERT(endOfSelection.isNotNull()); if (endOfSelection.isNull() || !endOfSelection.rootEditableElement()) return; startOfLastParagraph = startOfParagraph(endOfSelection, CanSkipOverEditingBoundary); } startOfCurrentParagraph = startOfNextParagraph(endingSelection().visibleStart()); } setEndingSelection(endOfSelection); } doApplyForSingleParagraph(forceListCreation, listTag, *currentSelection); // Fetch the end of the selection, for the reason mentioned above. if (endOfSelection.isNull() || endOfSelection.isOrphan()) { endOfSelection = visiblePositionForIndex(indexForEndOfSelection, scopeForEndOfSelection.get()); if (endOfSelection.isNull()) return; } if (startOfSelection.isNull() || startOfSelection.isOrphan()) { startOfSelection = visiblePositionForIndex(indexForStartOfSelection, scopeForStartOfSelection.get()); if (startOfSelection.isNull()) return; } setEndingSelection(VisibleSelection(startOfSelection, endOfSelection, endingSelection().isDirectional())); return; } ASSERT(endingSelection().firstRange()); doApplyForSingleParagraph(false, listTag, *endingSelection().firstRange()); }
static int32_t insertionPointFromCurrentSelection(const VisibleSelection& currentSelection) { VisiblePosition selectionStart = currentSelection.visibleStart(); VisiblePosition paragraphStart = startOfParagraph(selectionStart); return TextIterator::rangeLength(makeRange(paragraphStart, selectionStart).get()); }
void InsertListCommand::doApply(EditingState* editingState) { // Only entry points are Editor::Command::execute and // IndentOutdentCommand::outdentParagraph, both of which ensure clean layout. DCHECK(!document().needsLayoutTreeUpdate()); if (!endingSelection().isNonOrphanedCaretOrRange()) return; if (!endingSelection().rootEditableElement()) return; VisiblePosition visibleEnd = endingSelection().visibleEnd(); VisiblePosition visibleStart = endingSelection().visibleStart(); // When a selection ends at the start of a paragraph, we rarely paint // the selection gap before that paragraph, because there often is no gap. // In a case like this, it's not obvious to the user that the selection // ends "inside" that paragraph, so it would be confusing if // InsertUn{Ordered}List operated on that paragraph. // FIXME: We paint the gap before some paragraphs that are indented with left // margin/padding, but not others. We should make the gap painting more // consistent and then use a left margin/padding rule here. if (visibleEnd.deepEquivalent() != visibleStart.deepEquivalent() && isStartOfParagraph(visibleEnd, CanSkipOverEditingBoundary)) { setEndingSelection(createVisibleSelection( visibleStart, previousPositionOf(visibleEnd, CannotCrossEditingBoundary), endingSelection().isDirectional())); if (!endingSelection().rootEditableElement()) return; } const HTMLQualifiedName& listTag = (m_type == OrderedList) ? olTag : ulTag; if (endingSelection().isRange()) { bool forceListCreation = false; VisibleSelection selection = selectionForParagraphIteration(endingSelection()); DCHECK(selection.isRange()); VisiblePosition visibleStartOfSelection = selection.visibleStart(); VisiblePosition visibleEndOfSelection = selection.visibleEnd(); PositionWithAffinity startOfSelection = visibleStartOfSelection.toPositionWithAffinity(); PositionWithAffinity endOfSelection = visibleEndOfSelection.toPositionWithAffinity(); Position startOfLastParagraph = startOfParagraph(visibleEndOfSelection, CanSkipOverEditingBoundary) .deepEquivalent(); Range* currentSelection = firstRangeOf(endingSelection()); ContainerNode* scopeForStartOfSelection = nullptr; ContainerNode* scopeForEndOfSelection = nullptr; // FIXME: This is an inefficient way to keep selection alive because // indexForVisiblePosition walks from the beginning of the document to the // visibleEndOfSelection everytime this code is executed. But not using // index is hard because there are so many ways we can lose selection inside // doApplyForSingleParagraph. int indexForStartOfSelection = indexForVisiblePosition( visibleStartOfSelection, scopeForStartOfSelection); int indexForEndOfSelection = indexForVisiblePosition(visibleEndOfSelection, scopeForEndOfSelection); if (startOfParagraph(visibleStartOfSelection, CanSkipOverEditingBoundary) .deepEquivalent() != startOfLastParagraph) { forceListCreation = !selectionHasListOfType(selection, listTag); VisiblePosition startOfCurrentParagraph = visibleStartOfSelection; while (inSameTreeAndOrdered(startOfCurrentParagraph.deepEquivalent(), startOfLastParagraph) && !inSameParagraph(startOfCurrentParagraph, createVisiblePosition(startOfLastParagraph), CanCrossEditingBoundary)) { // doApply() may operate on and remove the last paragraph of the // selection from the document if it's in the same list item as // startOfCurrentParagraph. Return early to avoid an infinite loop and // because there is no more work to be done. // FIXME(<rdar://problem/5983974>): The endingSelection() may be // incorrect here. Compute the new location of visibleEndOfSelection // and use it as the end of the new selection. if (!startOfLastParagraph.isConnected()) return; setEndingSelection(startOfCurrentParagraph); // Save and restore visibleEndOfSelection and startOfLastParagraph when // necessary since moveParagraph and movePragraphWithClones can remove // nodes. bool singleParagraphResult = doApplyForSingleParagraph( forceListCreation, listTag, *currentSelection, editingState); if (editingState->isAborted()) return; if (!singleParagraphResult) break; document().updateStyleAndLayoutIgnorePendingStylesheets(); // Make |visibleEndOfSelection| valid again. if (!endOfSelection.isConnected() || !startOfLastParagraph.isConnected()) { visibleEndOfSelection = visiblePositionForIndex( indexForEndOfSelection, scopeForEndOfSelection); endOfSelection = visibleEndOfSelection.toPositionWithAffinity(); // If visibleEndOfSelection is null, then some contents have been // deleted from the document. This should never happen and if it did, // exit early immediately because we've lost the loop invariant. DCHECK(visibleEndOfSelection.isNotNull()); if (visibleEndOfSelection.isNull() || !rootEditableElementOf(visibleEndOfSelection)) return; startOfLastParagraph = startOfParagraph(visibleEndOfSelection, CanSkipOverEditingBoundary) .deepEquivalent(); } else { visibleEndOfSelection = createVisiblePosition(endOfSelection); } startOfCurrentParagraph = startOfNextParagraph(endingSelection().visibleStart()); } setEndingSelection(visibleEndOfSelection); } doApplyForSingleParagraph(forceListCreation, listTag, *currentSelection, editingState); if (editingState->isAborted()) return; document().updateStyleAndLayoutIgnorePendingStylesheets(); // Fetch the end of the selection, for the reason mentioned above. if (!endOfSelection.isConnected()) { visibleEndOfSelection = visiblePositionForIndex(indexForEndOfSelection, scopeForEndOfSelection); if (visibleEndOfSelection.isNull()) return; } else { visibleEndOfSelection = createVisiblePosition(endOfSelection); } if (!startOfSelection.isConnected()) { visibleStartOfSelection = visiblePositionForIndex( indexForStartOfSelection, scopeForStartOfSelection); if (visibleStartOfSelection.isNull()) return; } else { visibleStartOfSelection = createVisiblePosition(startOfSelection); } setEndingSelection( createVisibleSelection(visibleStartOfSelection, visibleEndOfSelection, endingSelection().isDirectional())); return; } DCHECK(firstRangeOf(endingSelection())); doApplyForSingleParagraph(false, listTag, *firstRangeOf(endingSelection()), editingState); }