| /* |
| * Copyright (C) 2005 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "InsertTextCommand.h" |
| |
| #include "Document.h" |
| #include "Editing.h" |
| #include "Editor.h" |
| #include "Frame.h" |
| #include "HTMLElement.h" |
| #include "HTMLInterchange.h" |
| #include "Text.h" |
| #include "VisibleUnits.h" |
| |
| namespace WebCore { |
| |
| InsertTextCommand::InsertTextCommand(Document& document, const String& text, bool selectInsertedText, RebalanceType rebalanceType, EditAction editingAction) |
| : CompositeEditCommand(document, editingAction) |
| , m_text(text) |
| , m_selectInsertedText(selectInsertedText) |
| , m_rebalanceType(rebalanceType) |
| { |
| } |
| |
| InsertTextCommand::InsertTextCommand(Document& document, const String& text, Ref<TextInsertionMarkerSupplier>&& markerSupplier, EditAction editingAction) |
| : CompositeEditCommand(document, editingAction) |
| , m_text(text) |
| , m_selectInsertedText(false) |
| , m_rebalanceType(RebalanceLeadingAndTrailingWhitespaces) |
| , m_markerSupplier(WTFMove(markerSupplier)) |
| { |
| } |
| |
| Position InsertTextCommand::positionInsideTextNode(const Position& p) |
| { |
| Position pos = p; |
| if (isTabSpanTextNode(pos.anchorNode())) { |
| auto textNode = document().createEditingTextNode(emptyString()); |
| insertNodeAtTabSpanPosition(textNode.copyRef(), pos); |
| return firstPositionInNode(textNode.ptr()); |
| } |
| |
| // Prepare for text input by looking at the specified position. |
| // It may be necessary to insert a text node to receive characters. |
| if (!pos.containerNode()->isTextNode()) { |
| auto textNode = document().createEditingTextNode(emptyString()); |
| insertNodeAt(textNode.copyRef(), pos); |
| return firstPositionInNode(textNode.ptr()); |
| } |
| |
| return pos; |
| } |
| |
| void InsertTextCommand::setEndingSelectionWithoutValidation(const Position& startPosition, const Position& endPosition) |
| { |
| // We could have inserted a part of composed character sequence, |
| // so we are basically treating ending selection as a range to avoid validation. |
| // <http://bugs.webkit.org/show_bug.cgi?id=15781> |
| VisibleSelection forcedEndingSelection; |
| forcedEndingSelection.setWithoutValidation(startPosition, endPosition); |
| forcedEndingSelection.setIsDirectional(endingSelection().isDirectional()); |
| setEndingSelection(forcedEndingSelection); |
| } |
| |
| // This avoids the expense of a full fledged delete operation, and avoids a layout that typically results |
| // from text removal. |
| bool InsertTextCommand::performTrivialReplace(const String& text, bool selectInsertedText) |
| { |
| if (!endingSelection().isRange()) |
| return false; |
| |
| if (text.contains('\t') || text.contains(' ') || text.contains('\n')) |
| return false; |
| |
| Position start = endingSelection().start(); |
| Position endPosition = replaceSelectedTextInNode(text); |
| if (endPosition.isNull()) |
| return false; |
| |
| setEndingSelectionWithoutValidation(start, endPosition); |
| if (!selectInsertedText) |
| setEndingSelection(VisibleSelection(endingSelection().visibleEnd(), endingSelection().isDirectional())); |
| |
| return true; |
| } |
| |
| bool InsertTextCommand::performOverwrite(const String& text, bool selectInsertedText) |
| { |
| Position start = endingSelection().start(); |
| RefPtr<Text> textNode = start.containerText(); |
| if (!textNode) |
| return false; |
| |
| unsigned count = std::min(text.length(), textNode->length() - start.offsetInContainerNode()); |
| if (!count) |
| return false; |
| |
| replaceTextInNode(*textNode, start.offsetInContainerNode(), count, text); |
| |
| Position endPosition = Position(textNode.get(), start.offsetInContainerNode() + text.length()); |
| setEndingSelectionWithoutValidation(start, endPosition); |
| if (!selectInsertedText) |
| setEndingSelection(VisibleSelection(endingSelection().visibleEnd(), endingSelection().isDirectional())); |
| |
| return true; |
| } |
| |
| void InsertTextCommand::doApply() |
| { |
| ASSERT(m_text.find('\n') == notFound); |
| |
| if (endingSelection().isNoneOrOrphaned()) |
| return; |
| |
| // Delete the current selection. |
| // FIXME: This delete operation blows away the typing style. |
| if (endingSelection().isRange()) { |
| if (performTrivialReplace(m_text, m_selectInsertedText)) |
| return; |
| deleteSelection(false, true, true, false, false); |
| // deleteSelection eventually makes a new endingSelection out of a Position. If that Position doesn't have |
| // a renderer (e.g. it is on a <frameset> in the DOM), the VisibleSelection cannot be canonicalized to |
| // anything other than NoSelection. The rest of this function requires a real endingSelection, so bail out. |
| if (endingSelection().isNoneOrOrphaned()) |
| return; |
| } else if (document().editor().isOverwriteModeEnabled()) { |
| if (performOverwrite(m_text, m_selectInsertedText)) |
| return; |
| } |
| |
| Position startPosition(endingSelection().start()); |
| |
| Position placeholder; |
| // We want to remove preserved newlines and brs that will collapse (and thus become unnecessary) when content |
| // is inserted just before them. |
| // FIXME: We shouldn't really have to do this, but removing placeholders is a workaround for 9661. |
| // If the caret is just before a placeholder, downstream will normalize the caret to it. |
| Position downstream(startPosition.downstream()); |
| if (lineBreakExistsAtPosition(downstream)) { |
| // FIXME: This doesn't handle placeholders at the end of anonymous blocks. |
| VisiblePosition caret(startPosition); |
| if (isEndOfBlock(caret) && isStartOfParagraph(caret)) |
| placeholder = downstream; |
| // Don't remove the placeholder yet, otherwise the block we're inserting into would collapse before |
| // we get a chance to insert into it. We check for a placeholder now, though, because doing so requires |
| // the creation of a VisiblePosition, and if we did that post-insertion it would force a layout. |
| } |
| |
| // Insert the character at the leftmost candidate. |
| startPosition = startPosition.upstream(); |
| |
| // It is possible for the node that contains startPosition to contain only unrendered whitespace, |
| // and so deleteInsignificantText could remove it. Save the position before the node in case that happens. |
| Position positionBeforeStartNode(positionInParentBeforeNode(startPosition.containerNode())); |
| deleteInsignificantText(startPosition.upstream(), startPosition.downstream()); |
| if (!startPosition.anchorNode()->isConnected()) |
| startPosition = positionBeforeStartNode; |
| if (!startPosition.isCandidate()) |
| startPosition = startPosition.downstream(); |
| |
| startPosition = positionAvoidingSpecialElementBoundary(startPosition); |
| |
| Position endPosition; |
| |
| if (m_text == "\t") { |
| endPosition = insertTab(startPosition); |
| startPosition = endPosition.previous(); |
| if (placeholder.isNotNull()) |
| removePlaceholderAt(placeholder); |
| } else { |
| // Make sure the document is set up to receive m_text |
| startPosition = positionInsideTextNode(startPosition); |
| ASSERT(startPosition.anchorType() == Position::PositionIsOffsetInAnchor); |
| ASSERT(startPosition.containerNode()); |
| ASSERT(startPosition.containerNode()->isTextNode()); |
| if (placeholder.isNotNull()) |
| removePlaceholderAt(placeholder); |
| RefPtr<Text> textNode = startPosition.containerText(); |
| const unsigned offset = startPosition.offsetInContainerNode(); |
| |
| insertTextIntoNode(*textNode, offset, m_text); |
| endPosition = Position(textNode.get(), offset + m_text.length()); |
| if (m_markerSupplier) |
| m_markerSupplier->addMarkersToTextNode(*textNode, offset, m_text); |
| |
| if (m_rebalanceType == RebalanceLeadingAndTrailingWhitespaces) { |
| // The insertion may require adjusting adjacent whitespace, if it is present. |
| rebalanceWhitespaceAt(endPosition); |
| // Rebalancing on both sides isn't necessary if we've inserted only spaces. |
| if (!shouldRebalanceLeadingWhitespaceFor(m_text)) |
| rebalanceWhitespaceAt(startPosition); |
| } else { |
| ASSERT(m_rebalanceType == RebalanceAllWhitespaces); |
| ASSERT(textNodeForRebalance(startPosition) == textNodeForRebalance(endPosition)); |
| if (auto textForRebalance = textNodeForRebalance(startPosition)) { |
| ASSERT(textForRebalance == textNode); |
| rebalanceWhitespaceOnTextSubstring(*textNode, startPosition.offsetInContainerNode(), endPosition.offsetInContainerNode()); |
| } |
| |
| } |
| } |
| |
| setEndingSelectionWithoutValidation(startPosition, endPosition); |
| |
| // Handle the case where there is a typing style. |
| if (RefPtr<EditingStyle> typingStyle = document().selection().typingStyle()) { |
| typingStyle->prepareToApplyAt(endPosition, EditingStyle::PreserveWritingDirection); |
| if (!typingStyle->isEmpty()) |
| applyStyle(typingStyle.get()); |
| } |
| |
| if (!m_selectInsertedText) |
| setEndingSelection(VisibleSelection(endingSelection().end(), endingSelection().affinity(), endingSelection().isDirectional())); |
| } |
| |
| Position InsertTextCommand::insertTab(const Position& pos) |
| { |
| Position insertPos = VisiblePosition(pos).deepEquivalent(); |
| if (insertPos.isNull()) |
| return pos; |
| |
| Node* node = insertPos.containerNode(); |
| unsigned int offset = node->isTextNode() ? insertPos.offsetInContainerNode() : 0; |
| |
| // keep tabs coalesced in tab span |
| if (isTabSpanTextNode(node)) { |
| Ref<Text> textNode = downcast<Text>(*node); |
| insertTextIntoNode(textNode, offset, "\t"); |
| return Position(textNode.ptr(), offset + 1); |
| } |
| |
| // create new tab span |
| auto spanNode = createTabSpanElement(document()); |
| auto* spanNodePtr = spanNode.ptr(); |
| |
| // place it |
| if (!is<Text>(*node)) |
| insertNodeAt(WTFMove(spanNode), insertPos); |
| else { |
| Ref<Text> textNode = downcast<Text>(*node); |
| if (offset >= textNode->length()) |
| insertNodeAfter(WTFMove(spanNode), textNode); |
| else { |
| // split node to make room for the span |
| // NOTE: splitTextNode uses textNode for the |
| // second node in the split, so we need to |
| // insert the span before it. |
| if (offset > 0) |
| splitTextNode(textNode, offset); |
| insertNodeBefore(WTFMove(spanNode), textNode); |
| } |
| } |
| |
| // return the position following the new tab |
| return lastPositionInNode(spanNodePtr); |
| } |
| |
| } |
