diff options
Diffstat (limited to 'editor/libeditor/DeleteRangeTransaction.cpp')
| -rw-r--r-- | editor/libeditor/DeleteRangeTransaction.cpp | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/editor/libeditor/DeleteRangeTransaction.cpp b/editor/libeditor/DeleteRangeTransaction.cpp new file mode 100644 index 0000000000..0980201c0b --- /dev/null +++ b/editor/libeditor/DeleteRangeTransaction.cpp @@ -0,0 +1,270 @@ +/* -*- 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 "mozilla/Assertions.h" +#include "mozilla/ContentIterator.h" +#include "mozilla/dom/Selection.h" +#include "mozilla/EditorBase.h" +#include "mozilla/mozalloc.h" +#include "mozilla/RangeBoundary.h" +#include "nsCOMPtr.h" +#include "nsDebug.h" +#include "nsError.h" +#include "nsIContent.h" +#include "nsINode.h" +#include "nsAString.h" + +namespace mozilla { + +using namespace dom; + +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) + +NS_IMETHODIMP DeleteRangeTransaction::DoTransaction() { + 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); + + // build the child transactions + const RangeBoundary& startRef = rangeToDelete->StartRef(); + const RangeBoundary& endRef = rangeToDelete->EndRef(); + MOZ_ASSERT(startRef.IsSetAndValid()); + MOZ_ASSERT(endRef.IsSetAndValid()); + + if (startRef.Container() == endRef.Container()) { + // the selection begins and ends in the same node + nsresult rv = CreateTxnsToDeleteBetween(startRef.AsRaw(), endRef.AsRaw()); + if (NS_FAILED(rv)) { + NS_WARNING("DeleteRangeTransaction::CreateTxnsToDeleteBetween() failed"); + return rv; + } + } else { + // the selection ends in a different node from where it started. delete + // the relevant content in the start node + nsresult rv = CreateTxnsToDeleteContent(startRef.AsRaw(), nsIEditor::eNext); + if (NS_FAILED(rv)) { + NS_WARNING("DeleteRangeTransaction::CreateTxnsToDeleteContent() failed"); + return rv; + } + // delete the intervening nodes + rv = CreateTxnsToDeleteNodesBetween(rangeToDelete); + if (NS_FAILED(rv)) { + NS_WARNING( + "DeleteRangeTransaction::CreateTxnsToDeleteNodesBetween() failed"); + return rv; + } + // delete the relevant content in the end node + rv = CreateTxnsToDeleteContent(endRef.AsRaw(), nsIEditor::ePrevious); + if (NS_FAILED(rv)) { + NS_WARNING("DeleteRangeTransaction::CreateTxnsToDeleteContent() 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; + } + + if (!mEditorBase->AllowsTransactionsToChangeSelection()) { + return NS_OK; + } + + RefPtr<Selection> selection = mEditorBase->GetSelection(); + if (NS_WARN_IF(!selection)) { + return NS_ERROR_NOT_INITIALIZED; + } + rv = selection->CollapseInLimiter(startRef.AsRaw()); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "Selection::CollapseInLimiter() failed"); + return rv; +} + +NS_IMETHODIMP DeleteRangeTransaction::UndoTransaction() { + nsresult rv = EditAggregateTransaction::UndoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::UndoTransaction() failed"); + return rv; +} + +NS_IMETHODIMP DeleteRangeTransaction::RedoTransaction() { + nsresult rv = EditAggregateTransaction::RedoTransaction(); + NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), + "EditAggregateTransaction::RedoTransaction() failed"); + return rv; +} + +nsresult DeleteRangeTransaction::CreateTxnsToDeleteBetween( + const RawRangeBoundary& aStart, const RawRangeBoundary& aEnd) { + if (NS_WARN_IF(!aStart.IsSetAndValid()) || + NS_WARN_IF(!aEnd.IsSetAndValid()) || + NS_WARN_IF(aStart.Container() != aEnd.Container())) { + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + // see what kind of node we have + if (Text* textNode = Text::FromNode(aStart.Container())) { + // if the node is a chardata node, then delete chardata content + int32_t numToDel; + if (aStart == aEnd) { + numToDel = 1; + } else { + numToDel = *aEnd.Offset(RawRangeBoundary::OffsetFilter::kValidOffsets) - + *aStart.Offset(RawRangeBoundary::OffsetFilter::kValidOffsets); + MOZ_DIAGNOSTIC_ASSERT(numToDel > 0); + } + + RefPtr<DeleteTextTransaction> deleteTextTransaction = + DeleteTextTransaction::MaybeCreate( + *mEditorBase, *textNode, + *aStart.Offset(RawRangeBoundary::OffsetFilter::kValidOffsets), + numToDel); + // 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; + } + + // 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 = aStart.GetChildAtOffset(); + child && child != aEnd.GetChildAtOffset(); + child = child->GetNextSibling()) { + RefPtr<DeleteNodeTransaction> deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *child); + // XXX This is odd handling. Even if some children are not editable, + // editor should append transactions because they could be editable + // at undoing/redoing. Additionally, if the transaction needs to + // delete/restore all nodes, it should at undoing/redoing. + if (deleteNodeTransaction) { + DebugOnly<nsresult> rvIgnored = AppendChild(deleteNodeTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + } + } + + return NS_OK; +} + +nsresult DeleteRangeTransaction::CreateTxnsToDeleteContent( + const RawRangeBoundary& aPoint, nsIEditor::EDirection aAction) { + if (NS_WARN_IF(!aPoint.IsSetAndValid())) { + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + Text* textNode = Text::FromNode(aPoint.Container()); + if (!textNode) { + return NS_OK; + } + + // If the node is a chardata node, then delete chardata content + uint32_t startOffset, numToDelete; + if (nsIEditor::eNext == aAction) { + startOffset = *aPoint.Offset(RawRangeBoundary::OffsetFilter::kValidOffsets); + numToDelete = aPoint.Container()->Length() - startOffset; + } else { + startOffset = 0; + numToDelete = *aPoint.Offset(RawRangeBoundary::OffsetFilter::kValidOffsets); + } + + if (!numToDelete) { + return NS_OK; + } + + RefPtr<DeleteTextTransaction> deleteTextTransaction = + DeleteTextTransaction::MaybeCreate(*mEditorBase, *textNode, startOffset, + numToDelete); + NS_WARNING_ASSERTION(deleteTextTransaction, + "DeleteTextTransaction::MaybeCreate() failed"); + // If the text node isn't editable, it should be never undone/redone. + // So, the transaction shouldn't be recorded. + if (!deleteTextTransaction) { + 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::CreateTxnsToDeleteNodesBetween( + nsRange* aRangeToDelete) { + if (NS_WARN_IF(!mEditorBase)) { + return NS_ERROR_NOT_AVAILABLE; + } + + ContentSubtreeIterator subtreeIter; + nsresult rv = subtreeIter.Init(aRangeToDelete); + 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; + } + + RefPtr<DeleteNodeTransaction> deleteNodeTransaction = + DeleteNodeTransaction::MaybeCreate(*mEditorBase, *node->AsContent()); + // XXX This is odd handling. Even if some nodes in the range are not + // editable, editor should append transactions because they could + // at undoing/redoing. Additionally, if the transaction needs to + // delete/restore all nodes, it should at undoing/redoing. + if (!deleteNodeTransaction) { + NS_WARNING("DeleteNodeTransaction::MaybeCreate() failed"); + return NS_ERROR_FAILURE; + } + DebugOnly<nsresult> rvIgnored = AppendChild(deleteNodeTransaction); + NS_WARNING_ASSERTION( + NS_SUCCEEDED(rvIgnored), + "DeleteRangeTransaction::AppendChild() failed, but ignored"); + } + return NS_OK; +} + +} // namespace mozilla |