Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/editor/libeditor/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 14 kB

Quelle DeleteRangeTransaction.cpp Sprache: C

/* -*- 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 "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

quality93%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.