Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "DeleteRangeTransaction.h"
#include "DeleteContentTransactionBase.h"
#include "DeleteNodeTransaction.h"
#include "DeleteTextTransaction.h"
#include "EditTransactionBase.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, mPointToPutCaret)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction)
NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction)
void DeleteRangeTransaction::AppendChild(
DeleteContentTransactionBase& aTransaction) {
mChildren.AppendElement(aTransaction);
}
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()));
mPointToPutCaret = rangeToDelete->StartRef();
if (MOZ_UNLIKELY(!mPointToPutCaret.IsSetAndValid())) {
for (const OwningNonNull<EditTransactionBase>& transaction :
Reversed(mChildren)) {
if (const DeleteContentTransactionBase* deleteContentTransaction =
transaction->GetAsDeleteContentTransactionBase()) {
mPointToPutCaret = deleteContentTransaction->SuggestPointToPutCaret();
if (mPointToPutCaret.IsSetAndValid()) {
break;
}
continue;
}
MOZ_ASSERT_UNREACHABLE(
"Child transactions must be DeleteContentTransactionBase");
}
}
return NS_OK;
}
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;
}
AppendChild(*deleteTextTransaction);
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) {
AppendChild(*deleteNodeTransaction);
}
}
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;
}
AppendChild(*deleteTextTransaction);
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) {
AppendChild(*deleteNodeTransaction);
}
}
return NS_OK;
}
} // namespace mozilla