diff options
Diffstat (limited to 'editor/libeditor/DeleteRangeTransaction.cpp')
| -rw-r--r-- | editor/libeditor/DeleteRangeTransaction.cpp | 396 |
1 files changed, 396 insertions, 0 deletions
diff --git a/editor/libeditor/DeleteRangeTransaction.cpp b/editor/libeditor/DeleteRangeTransaction.cpp new file mode 100644 index 0000000000..07ec383778 --- /dev/null +++ b/editor/libeditor/DeleteRangeTransaction.cpp @@ -0,0 +1,396 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DeleteRangeTransaction.h" + +#include "DeleteNodeTransaction.h" +#include "DeleteTextTransaction.h" +#include "EditorBase.h" +#include "EditorDOMPoint.h" +#include "EditorUtils.h" +#include "HTMLEditUtils.h" + +#include "mozilla/Assertions.h" +#include "mozilla/ContentIterator.h" +#include "mozilla/Logging.h" +#include "mozilla/mozalloc.h" +#include "mozilla/RangeBoundary.h" +#include "mozilla/StaticPrefs_editor.h" +#include "mozilla/ToString.h" +#include "mozilla/dom/Selection.h" +#include "nsAtom.h" +#include "nsCOMPtr.h" +#include "nsDebug.h" +#include "nsError.h" +#include "nsGkAtoms.h" +#include "nsIContent.h" +#include "nsINode.h" +#include "nsAString.h" + +namespace mozilla { + +using namespace dom; + +using EditorType = EditorUtils::EditorType; + +DeleteRangeTransaction::DeleteRangeTransaction(EditorBase& aEditorBase, + const nsRange& aRangeToDelete) + : mEditorBase(&aEditorBase), mRangeToDelete(aRangeToDelete.CloneRange()) {} + +NS_IMPL_CYCLE_COLLECTION_INHERITED(DeleteRangeTransaction, + EditAggregateTransaction, mEditorBase, + mRangeToDelete) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction) +NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction) + +nsresult +DeleteRangeTransaction::MaybeExtendDeletingRangeWithSurroundingWhitespace( + nsRange& aRange) const { + if (!mEditorBase->mEditActionData->SelectionCreatedByDoubleclick() || + !StaticPrefs:: + editor_word_select_delete_space_after_doubleclick_selection()) { + return NS_OK; + } + EditorRawDOMPoint startPoint(aRange.StartRef()); + EditorRawDOMPoint endPoint(aRange.EndRef()); + const bool maybeRangeStartsAfterWhiteSpace = + startPoint.IsInTextNode() && !startPoint.IsStartOfContainer(); + const bool maybeRangeEndsAtWhiteSpace = + endPoint.IsInTextNode() && !endPoint.IsEndOfContainer(); + + if (!maybeRangeStartsAfterWhiteSpace && !maybeRangeEndsAtWhiteSpace) { + // no whitespace before or after word => nothing to do here. + return NS_OK; + } + + const bool precedingCharIsWhitespace = + maybeRangeStartsAfterWhiteSpace + ? startPoint.IsPreviousCharASCIISpaceOrNBSP() + : false; + const bool trailingCharIsWhitespace = + maybeRangeEndsAtWhiteSpace ? endPoint.IsCharASCIISpaceOrNBSP() : false; + + // if possible, try to remove the preceding whitespace + // so the caret is at the end of the previous word. + if (precedingCharIsWhitespace) { + // "one [two]", "one [two] three" or "one [two], three" + ErrorResult err; + aRange.SetStart(startPoint.PreviousPoint(), err); + if (auto rv = err.StealNSResult(); NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "MaybeExtendDeletingRangeWithSurroundingWhitespace" + " failed to update the start of the deleting range"); + return rv; + } + } else if (trailingCharIsWhitespace) { + // "[one] two" + ErrorResult err; + aRange.SetEnd(endPoint.NextPoint(), err); + if (auto rv = err.StealNSResult(); NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "MaybeExtendDeletingRangeWithSurroundingWhitespace" + " failed to update the end of the deleting range"); + return rv; + } + } + + return NS_OK; +} + +NS_IMETHODIMP DeleteRangeTransaction::DoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + if (NS_WARN_IF(!mEditorBase) || NS_WARN_IF(!mRangeToDelete)) { + return NS_ERROR_NOT_AVAILABLE; + } + + // Swap mRangeToDelete out into a stack variable, so we make sure to null it + // out on return from this function. Once this function returns, we no longer + // need mRangeToDelete, and keeping it alive in the long term slows down all + // DOM mutations because it's observing them. + RefPtr<nsRange> rangeToDelete; + rangeToDelete.swap(mRangeToDelete); + + MaybeExtendDeletingRangeWithSurroundingWhitespace(*rangeToDelete); + + // build the child transactions + // XXX We should move this to the constructor. Then, we don't need to make + // this class has mRangeToDelete with nullptr since transaction instances + // may be created a lot and live long. + { + EditorRawDOMRange extendedRange(*rangeToDelete); + MOZ_ASSERT(extendedRange.IsPositionedAndValid()); + + if (extendedRange.InSameContainer()) { + // the selection begins and ends in the same node + nsresult rv = AppendTransactionsToDeleteIn(extendedRange); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionsToDeleteIn() failed"); + return rv; + } + } else { + // If the range ends at end of a node, we may need to extend the range to + // make ContentSubtreeIterator iterates close tag of the unnecessary nodes + // in AppendTransactionsToDeleteNodesEntirelyIn. + for (EditorRawDOMPoint endOfRange = extendedRange.EndRef(); + endOfRange.IsInContentNode() && endOfRange.IsEndOfContainer() && + endOfRange.GetContainer() != extendedRange.StartRef().GetContainer(); + endOfRange = extendedRange.EndRef()) { + extendedRange.SetEnd( + EditorRawDOMPoint::After(*endOfRange.ContainerAs<nsIContent>())); + } + + // the selection ends in a different node from where it started. delete + // the relevant content in the start node + nsresult rv = AppendTransactionToDeleteText(extendedRange.StartRef(), + nsIEditor::eNext); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionToDeleteText() failed"); + return rv; + } + // delete the intervening nodes + rv = AppendTransactionsToDeleteNodesWhoseEndBoundaryIn(extendedRange); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::" + "AppendTransactionsToDeleteNodesWhoseEndBoundaryIn() failed"); + return rv; + } + // delete the relevant content in the end node + rv = AppendTransactionToDeleteText(extendedRange.EndRef(), + nsIEditor::ePrevious); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::AppendTransactionToDeleteText() failed"); + return rv; + } + } + } + + // if we've successfully built this aggregate transaction, then do it. + nsresult rv = EditAggregateTransaction::DoTransaction(); + if (NS_FAILED(rv)) { + NS_WARNING("EditAggregateTransaction::DoTransaction() failed"); + return rv; + } + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + if (!mEditorBase->AllowsTransactionsToChangeSelection()) { + return NS_OK; + } + + OwningNonNull<EditorBase> editorBase = *mEditorBase; + rv = editorBase->CollapseSelectionTo( + EditorRawDOMPoint(rangeToDelete->StartRef())); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditorBase::CollapseSelectionTo() failed"); + return rv; +} + +NS_IMETHODIMP DeleteRangeTransaction::UndoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + nsresult rv = EditAggregateTransaction::UndoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::UndoTransaction() failed"); + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + return rv; +} + +NS_IMETHODIMP DeleteRangeTransaction::RedoTransaction() { + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "Start==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + + nsresult rv = EditAggregateTransaction::RedoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::RedoTransaction() failed"); + + MOZ_LOG(GetLogModule(), LogLevel::Info, + ("%p DeleteRangeTransaction::%s this={ mName=%s } " + "End==============================", + this, __FUNCTION__, + nsAtomCString(mName ? mName.get() : nsGkAtoms::_empty).get())); + return rv; +} + +nsresult DeleteRangeTransaction::AppendTransactionsToDeleteIn( + const EditorRawDOMRange& aRangeToDelete) { + if (NS_WARN_IF(!aRangeToDelete.IsPositionedAndValid())) { + return NS_ERROR_INVALID_ARG; + } + MOZ_ASSERT(aRangeToDelete.InSameContainer()); + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + // see what kind of node we have + if (Text* textNode = aRangeToDelete.StartRef().GetContainerAs<Text>()) { + if (mEditorBase->IsHTMLEditor() && + NS_WARN_IF( + !EditorUtils::IsEditableContent(*textNode, EditorType::HTML))) { + // Just ignore to append the transaction for non-editable node. + return NS_OK; + } + // if the node is a chardata node, then delete chardata content + uint32_t textLengthToDelete; + if (aRangeToDelete.Collapsed()) { + textLengthToDelete = 1; + } else { + textLengthToDelete = + aRangeToDelete.EndRef().Offset() - aRangeToDelete.StartRef().Offset(); + MOZ_DIAGNOSTIC_ASSERT(textLengthToDelete > 0); + } + + RefPtr<DeleteTextTransaction> deleteTextTransaction = + DeleteTextTransaction::MaybeCreate(*mEditorBase, *textNode, + aRangeToDelete.StartRef().Offset(), + textLengthToDelete); + // If the text node isn't editable, it should be never undone/redone. + // So, the transaction shouldn't be recorded. + if (!deleteTextTransaction) { + NS_WARNING("DeleteTextTransaction::MaybeCreate() failed"); + return NS_ERROR_FAILURE; + } + DebugOnly<nsresult> rvIgnored = AppendChild(deleteTextTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + return NS_OK; + } + + MOZ_ASSERT(mEditorBase->IsHTMLEditor()); + + // Even if we detect invalid range, we should ignore it for removing + // specified range's nodes as far as possible. + // XXX This is super expensive. Probably, we should make + // DeleteNodeTransaction() can treat multiple siblings. + for (nsIContent* child = aRangeToDelete.StartRef().GetChild(); + child && child != aRangeToDelete.EndRef().GetChild(); + child = child->GetNextSibling()) { + if (NS_WARN_IF(!HTMLEditUtils::IsRemovableNode(*child))) { + continue; // Should we abort? + } + RefPtr<DeleteNodeTransaction> deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *child); + if (deleteNodeTransaction) { + DebugOnly<nsresult> rvIgnored = AppendChild(deleteNodeTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + } + } + + return NS_OK; +} + +nsresult DeleteRangeTransaction::AppendTransactionToDeleteText( + const EditorRawDOMPoint& aMaybePointInText, nsIEditor::EDirection aAction) { + if (NS_WARN_IF(!aMaybePointInText.IsSetAndValid())) { + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + if (!aMaybePointInText.IsInTextNode()) { + return NS_OK; + } + + // If the node is a text node, then delete text before or after the point. + Text& textNode = *aMaybePointInText.ContainerAs<Text>(); + uint32_t startOffset, numToDelete; + if (nsIEditor::eNext == aAction) { + startOffset = aMaybePointInText.Offset(); + numToDelete = textNode.TextDataLength() - startOffset; + } else { + startOffset = 0; + numToDelete = aMaybePointInText.Offset(); + } + + if (!numToDelete) { + return NS_OK; + } + + RefPtr<DeleteTextTransaction> deleteTextTransaction = + DeleteTextTransaction::MaybeCreate(*mEditorBase, textNode, startOffset, + numToDelete); + // If the text node isn't editable, it should be never undone/redone. + // So, the transaction shouldn't be recorded. + if (MOZ_UNLIKELY(!deleteTextTransaction)) { + NS_WARNING("DeleteTextTransaction::MaybeCreate() failed"); + return NS_ERROR_FAILURE; + } + DebugOnly<nsresult> rvIgnored = AppendChild(deleteTextTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + return NS_OK; +} + +nsresult +DeleteRangeTransaction::AppendTransactionsToDeleteNodesWhoseEndBoundaryIn( + const EditorRawDOMRange& aRangeToDelete) { + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + ContentSubtreeIterator subtreeIter; + nsresult rv = subtreeIter.Init(aRangeToDelete.StartRef().ToRawRangeBoundary(), + aRangeToDelete.EndRef().ToRawRangeBoundary()); + if (NS_FAILED(rv)) { + NS_WARNING("ContentSubtreeIterator::Init() failed"); + return rv; + } + + for (; !subtreeIter.IsDone(); subtreeIter.Next()) { + nsINode* node = subtreeIter.GetCurrentNode(); + if (NS_WARN_IF(!node) || NS_WARN_IF(!node->IsContent())) { + return NS_ERROR_FAILURE; + } + + if (NS_WARN_IF(!HTMLEditUtils::IsRemovableNode(*node->AsContent()))) { + continue; + } + RefPtr<DeleteNodeTransaction> deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *node->AsContent()); + if (deleteNodeTransaction) { + DebugOnly<nsresult> rvIgnored = AppendChild(deleteNodeTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + } + } + return NS_OK; +} + +} // namespace mozilla |