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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "EditorUtils.h"
#include "EditorDOMPoint.h"
#include "EditorForwards.h" // for CollectChildrenOptions
#include "HTMLEditHelpers.h" // for MoveNodeResult
#include "HTMLEditUtils.h" // for HTMLEditUtils
#include "TextEditor.h"
#include "WSRunObject.h"
#include "gfxFontUtils.h"
#include "mozilla/ComputedStyle.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/OwningNonNull.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/HTMLBRElement.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/Text.h"
#include "nsContentUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsComputedDOMStyle.h"
#include "nsError.h"
#include "nsFrameSelection.h"
#include "nsIContent.h"
#include "nsIInterfaceRequestorUtils.h"
#include "nsILoadContext.h"
#include "nsINode.h"
#include "nsITransferable.h"
#include "nsRange.h"
#include "nsStyleStruct.h"
#include "nsTextFragment.h"
class nsISupports;
namespace mozilla {
using namespace dom;
/******************************************************************************
* mozilla::EditActionResult
*****************************************************************************/
EditActionResult& EditActionResult::operator|=(
const MoveNodeResult& aMoveNodeResult) {
mHandled |= aMoveNodeResult.Handled();
// When both result are same, keep the result.
if (mRv == aMoveNodeResult.inspectErr()) {
return *this;
}
// If one of the result is NS_ERROR_EDITOR_DESTROYED, use it since it's
// the most important error code for editor.
if (EditorDestroyed() || aMoveNodeResult.EditorDestroyed()) {
mRv = NS_ERROR_EDITOR_DESTROYED;
return *this;
}
// If aMoveNodeResult hasn't been set explicit nsresult value, keep current
// result.
if (aMoveNodeResult.NotInitialized()) {
return *this;
}
// If one of the results is error, use NS_ERROR_FAILURE.
if (Failed() || aMoveNodeResult.isErr()) {
mRv = NS_ERROR_FAILURE;
return *this;
}
// Otherwise, use generic success code, NS_OK.
mRv = NS_OK;
return *this;
}
/******************************************************************************
* mozilla::AutoRangeArray
*****************************************************************************/
template AutoRangeArray::AutoRangeArray(const EditorDOMRange& aRange);
template AutoRangeArray::AutoRangeArray(const EditorRawDOMRange& aRange);
template AutoRangeArray::AutoRangeArray(const EditorDOMPoint& aRange);
template AutoRangeArray::AutoRangeArray(const EditorRawDOMPoint& aRange);
AutoRangeArray::AutoRangeArray(const dom::Selection& aSelection) {
Initialize(aSelection);
}
template <typename PointType>
AutoRangeArray::AutoRangeArray(const EditorDOMRangeBase<PointType>& aRange) {
MOZ_ASSERT(aRange.IsPositionedAndValid());
RefPtr<nsRange> range = aRange.CreateRange(IgnoreErrors());
if (NS_WARN_IF(!range) || NS_WARN_IF(!range->IsPositioned())) {
return;
}
mRanges.AppendElement(std::move(range));
}
template <typename PT, typename CT>
AutoRangeArray::AutoRangeArray(const EditorDOMPointBase<PT, CT>& aPoint) {
MOZ_ASSERT(aPoint.IsSetAndValid());
RefPtr<nsRange> range = aPoint.CreateCollapsedRange(IgnoreErrors());
if (NS_WARN_IF(!range) || NS_WARN_IF(!range->IsPositioned())) {
return;
}
mRanges.AppendElement(std::move(range));
}
AutoRangeArray::~AutoRangeArray() {
if (mSavedRanges.isSome()) {
ClearSavedRanges();
}
}
// static
bool AutoRangeArray::IsEditableRange(const dom::AbstractRange& aRange,
const Element& aEditingHost) {
// TODO: Perhaps, we should check whether the start/end boundaries are
// first/last point of non-editable element.
EditorRawDOMPoint atStart(aRange.StartRef());
const bool isStartEditable =
atStart.IsInContentNode() &&
EditorUtils::IsEditableContent(*atStart.ContainerAsContent(),
EditorUtils::EditorType::HTML) &&
!HTMLEditUtils::IsNonEditableReplacedContent(
*atStart.ContainerAsContent());
if (!isStartEditable) {
return false;
}
if (aRange.GetStartContainer() != aRange.GetEndContainer()) {
EditorRawDOMPoint atEnd(aRange.EndRef());
const bool isEndEditable =
atEnd.IsInContentNode() &&
EditorUtils::IsEditableContent(*atEnd.ContainerAsContent(),
EditorUtils::EditorType::HTML) &&
!HTMLEditUtils::IsNonEditableReplacedContent(
*atEnd.ContainerAsContent());
if (!isEndEditable) {
return false;
}
// Now, both start and end points are editable, but if they are in
// different editing host, we cannot edit the range.
if (atStart.ContainerAsContent() != atEnd.ContainerAsContent() &&
atStart.ContainerAsContent()->GetEditingHost() !=
atEnd.ContainerAsContent()->GetEditingHost()) {
return false;
}
}
// HTMLEditor does not support modifying outside `<body>` element for now.
nsINode* commonAncestor = aRange.GetClosestCommonInclusiveAncestor();
return commonAncestor && commonAncestor->IsContent() &&
commonAncestor->IsInclusiveDescendantOf(&aEditingHost);
}
void AutoRangeArray::EnsureOnlyEditableRanges(const Element& aEditingHost) {
for (size_t i = mRanges.Length(); i > 0; i--) {
const OwningNonNull<nsRange>& range = mRanges[i - 1];
if (!AutoRangeArray::IsEditableRange(range, aEditingHost)) {
mRanges.RemoveElementAt(i - 1);
}
}
mAnchorFocusRange = mRanges.IsEmpty() ? nullptr : mRanges.LastElement().get();
}
void AutoRangeArray::EnsureRangesInTextNode(const Text& aTextNode) {
auto GetOffsetInTextNode = [&aTextNode](const nsINode* aNode,
uint32_t aOffset) -> uint32_t {
MOZ_DIAGNOSTIC_ASSERT(aNode);
if (aNode == &aTextNode) {
return aOffset;
}
const nsIContent* anonymousDivElement = aTextNode.GetParent();
MOZ_DIAGNOSTIC_ASSERT(anonymousDivElement);
MOZ_DIAGNOSTIC_ASSERT(anonymousDivElement->IsHTMLElement(nsGkAtoms::div));
MOZ_DIAGNOSTIC_ASSERT(anonymousDivElement->GetFirstChild() == &aTextNode);
if (aNode == anonymousDivElement && aOffset == 0u) {
return 0u; // Point before the text node so that use start of the text.
}
MOZ_DIAGNOSTIC_ASSERT(aNode->IsInclusiveDescendantOf(anonymousDivElement));
// Point after the text node so that use end of the text.
return aTextNode.TextDataLength();
};
for (uint32_t i : IntegerRange(mRanges.Length())) {
const OwningNonNull<nsRange>& range = mRanges[i];
if (MOZ_LIKELY(range->GetStartContainer() == &aTextNode &&
range->GetEndContainer() == &aTextNode)) {
continue;
}
range->SetStartAndEnd(
const_cast<Text*>(&aTextNode),
GetOffsetInTextNode(range->GetStartContainer(), range->StartOffset()),
const_cast<Text*>(&aTextNode),
GetOffsetInTextNode(range->GetEndContainer(), range->EndOffset()));
}
if (MOZ_UNLIKELY(mRanges.Length() >= 2)) {
// For avoiding to handle same things in same range, we should drop and
// merge unnecessary ranges. Note that the ranges never overlap
// because selection ranges are not allowed it so that we need to check only
// end offset vs start offset of next one.
for (uint32_t i : Reversed(IntegerRange(mRanges.Length() - 1u))) {
MOZ_ASSERT(mRanges[i]->EndOffset() < mRanges[i + 1]->StartOffset());
// XXX Should we delete collapsed range unless the index is 0? Without
// Selection API, such situation cannot happen so that `TextEditor`
// may behave unexpectedly.
if (MOZ_UNLIKELY(mRanges[i]->EndOffset() >=
mRanges[i + 1]->StartOffset())) {
const uint32_t newEndOffset = mRanges[i + 1]->EndOffset();
mRanges.RemoveElementAt(i + 1);
if (MOZ_UNLIKELY(NS_WARN_IF(newEndOffset > mRanges[i]->EndOffset()))) {
// So, this case shouldn't happen.
mRanges[i]->SetStartAndEnd(
const_cast<Text*>(&aTextNode), mRanges[i]->StartOffset(),
const_cast<Text*>(&aTextNode), newEndOffset);
}
}
}
}
}
Result<nsIEditor::EDirection, nsresult>
AutoRangeArray::ExtendAnchorFocusRangeFor(
const EditorBase& aEditorBase, nsIEditor::EDirection aDirectionAndAmount) {
MOZ_ASSERT(aEditorBase.IsEditActionDataAvailable());
MOZ_ASSERT(mAnchorFocusRange);
MOZ_ASSERT(mAnchorFocusRange->IsPositioned());
MOZ_ASSERT(mAnchorFocusRange->StartRef().IsSet());
MOZ_ASSERT(mAnchorFocusRange->EndRef().IsSet());
if (!EditorUtils::IsFrameSelectionRequiredToExtendSelection(
aDirectionAndAmount, *this)) {
return aDirectionAndAmount;
}
if (NS_WARN_IF(!aEditorBase.SelectionRef().RangeCount())) {
return Err(NS_ERROR_FAILURE);
}
// At this point, the anchor-focus ranges must match for bidi information.
// See `EditorBase::AutoCaretBidiLevelManager`.
MOZ_ASSERT(aEditorBase.SelectionRef().GetAnchorFocusRange()->StartRef() ==
mAnchorFocusRange->StartRef());
MOZ_ASSERT(aEditorBase.SelectionRef().GetAnchorFocusRange()->EndRef() ==
mAnchorFocusRange->EndRef());
RefPtr<nsFrameSelection> frameSelection =
aEditorBase.SelectionRef().GetFrameSelection();
if (NS_WARN_IF(!frameSelection)) {
return Err(NS_ERROR_NOT_INITIALIZED);
}
RefPtr<Element> editingHost;
if (aEditorBase.IsHTMLEditor()) {
editingHost = aEditorBase.AsHTMLEditor()->ComputeEditingHost();
if (!editingHost) {
return Err(NS_ERROR_FAILURE);
}
}
Result<RefPtr<nsRange>, nsresult> result(NS_ERROR_UNEXPECTED);
nsIEditor::EDirection directionAndAmountResult = aDirectionAndAmount;
switch (aDirectionAndAmount) {
case nsIEditor::eNextWord:
result = frameSelection->CreateRangeExtendedToNextWordBoundary<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(
result.isOk(),
"nsFrameSelection::CreateRangeExtendedToNextWordBoundary() failed");
// DeleteSelectionWithTransaction() doesn't handle these actions
// because it's inside batching, so don't confuse it:
directionAndAmountResult = nsIEditor::eNone;
break;
case nsIEditor::ePreviousWord:
result =
frameSelection->CreateRangeExtendedToPreviousWordBoundary<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(
result.isOk(),
"nsFrameSelection::CreateRangeExtendedToPreviousWordBoundary() "
"failed");
// DeleteSelectionWithTransaction() doesn't handle these actions
// because it's inside batching, so don't confuse it:
directionAndAmountResult = nsIEditor::eNone;
break;
case nsIEditor::eNext:
result =
frameSelection
->CreateRangeExtendedToNextGraphemeClusterBoundary<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(result.isOk(),
"nsFrameSelection::"
"CreateRangeExtendedToNextGraphemeClusterBoundary() "
"failed");
// Don't set directionAndAmount to eNone (see Bug 502259)
break;
case nsIEditor::ePrevious: {
// Only extend the selection where the selection is after a UTF-16
// surrogate pair or a variation selector.
// For other cases we don't want to do that, in order
// to make sure that pressing backspace will only delete the last
// typed character.
// XXX This is odd if the previous one is a sequence for a grapheme
// cluster.
const auto atStartOfSelection = GetFirstRangeStartPoint<EditorDOMPoint>();
if (MOZ_UNLIKELY(NS_WARN_IF(!atStartOfSelection.IsSet()))) {
return Err(NS_ERROR_FAILURE);
}
// node might be anonymous DIV, so we find better text node
const EditorDOMPoint insertionPoint =
aEditorBase.FindBetterInsertionPoint(atStartOfSelection);
if (MOZ_UNLIKELY(!insertionPoint.IsSet())) {
NS_WARNING(
"EditorBase::FindBetterInsertionPoint() failed, but ignored");
return aDirectionAndAmount;
}
if (!insertionPoint.IsInTextNode()) {
return aDirectionAndAmount;
}
const nsTextFragment* data =
&insertionPoint.GetContainerAsText()->TextFragment();
uint32_t offset = insertionPoint.Offset();
if (!(offset > 1 &&
data->IsLowSurrogateFollowingHighSurrogateAt(offset - 1)) &&
!(offset > 0 &&
gfxFontUtils::IsVarSelector(data->CharAt(offset - 1)))) {
return aDirectionAndAmount;
}
// Different from the `eNext` case, we look for character boundary.
// I'm not sure whether this inconsistency between "Delete" and
// "Backspace" is intentional or not.
result = frameSelection
->CreateRangeExtendedToPreviousCharacterBoundary<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(
result.isOk(),
"nsFrameSelection::"
"CreateRangeExtendedToPreviousGraphemeClusterBoundary() failed");
break;
}
case nsIEditor::eToBeginningOfLine:
result =
frameSelection->CreateRangeExtendedToPreviousHardLineBreak<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(
result.isOk(),
"nsFrameSelection::CreateRangeExtendedToPreviousHardLineBreak() "
"failed");
directionAndAmountResult = nsIEditor::eNone;
break;
case nsIEditor::eToEndOfLine:
result =
frameSelection->CreateRangeExtendedToNextHardLineBreak<nsRange>();
if (NS_WARN_IF(aEditorBase.Destroyed())) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
NS_WARNING_ASSERTION(
result.isOk(),
"nsFrameSelection::CreateRangeExtendedToNextHardLineBreak() failed");
directionAndAmountResult = nsIEditor::eNext;
break;
default:
return aDirectionAndAmount;
}
if (result.isErr()) {
return Err(result.inspectErr());
}
RefPtr<nsRange> extendedRange(result.unwrap().forget());
if (!extendedRange || NS_WARN_IF(!extendedRange->IsPositioned())) {
NS_WARNING("Failed to extend the range, but ignored");
return directionAndAmountResult;
}
// If the new range isn't editable, keep using the original range.
if (aEditorBase.IsHTMLEditor() &&
!AutoRangeArray::IsEditableRange(*extendedRange, *editingHost)) {
return aDirectionAndAmount;
}
if (NS_WARN_IF(!frameSelection->IsValidSelectionPoint(
extendedRange->GetStartContainer())) ||
NS_WARN_IF(!frameSelection->IsValidSelectionPoint(
extendedRange->GetEndContainer()))) {
NS_WARNING("A range was extended to outer of selection limiter");
return Err(NS_ERROR_FAILURE);
}
// Swap focus/anchor range with the extended range.
DebugOnly<bool> found = false;
for (OwningNonNull<nsRange>& range : mRanges) {
if (range == mAnchorFocusRange) {
range = *extendedRange;
found = true;
break;
}
}
MOZ_ASSERT(found);
mAnchorFocusRange.swap(extendedRange);
return directionAndAmountResult;
}
Result<bool, nsresult>
AutoRangeArray::ShrinkRangesIfStartFromOrEndAfterAtomicContent(
const HTMLEditor& aHTMLEditor, nsIEditor::EDirection aDirectionAndAmount,
IfSelectingOnlyOneAtomicContent aIfSelectingOnlyOneAtomicContent,
const Element* aEditingHost) {
if (IsCollapsed()) {
return false;
}
switch (aDirectionAndAmount) {
case nsIEditor::eNext:
case nsIEditor::eNextWord:
case nsIEditor::ePrevious:
case nsIEditor::ePreviousWord:
break;
default:
return false;
}
bool changed = false;
for (auto& range : mRanges) {
MOZ_ASSERT(!range->IsInSelection(),
"Changing range in selection may cause running script");
Result<bool, nsresult> result =
WSRunScanner::ShrinkRangeIfStartsFromOrEndsAfterAtomicContent(
aHTMLEditor, range, aEditingHost);
if (result.isErr()) {
NS_WARNING(
"WSRunScanner::ShrinkRangeIfStartsFromOrEndsAfterAtomicContent() "
"failed");
return Err(result.inspectErr());
}
changed |= result.inspect();
}
if (mRanges.Length() == 1 && aIfSelectingOnlyOneAtomicContent ==
IfSelectingOnlyOneAtomicContent::Collapse) {
MOZ_ASSERT(mRanges[0].get() == mAnchorFocusRange.get());
if (mAnchorFocusRange->GetStartContainer() ==
mAnchorFocusRange->GetEndContainer() &&
mAnchorFocusRange->GetChildAtStartOffset() &&
mAnchorFocusRange->StartRef().GetNextSiblingOfChildAtOffset() ==
mAnchorFocusRange->GetChildAtEndOffset()) {
mAnchorFocusRange->Collapse(aDirectionAndAmount == nsIEditor::eNext ||
aDirectionAndAmount == nsIEditor::eNextWord);
changed = true;
}
}
return changed;
}
bool AutoRangeArray::SaveAndTrackRanges(HTMLEditor& aHTMLEditor) {
if (mSavedRanges.isSome()) {
return false;
}
mSavedRanges.emplace(*this);
aHTMLEditor.RangeUpdaterRef().RegisterSelectionState(mSavedRanges.ref());
mTrackingHTMLEditor = &aHTMLEditor;
return true;
}
void AutoRangeArray::ClearSavedRanges() {
if (mSavedRanges.isNothing()) {
return;
}
OwningNonNull<HTMLEditor> htmlEditor(std::move(mTrackingHTMLEditor));
MOZ_ASSERT(!mTrackingHTMLEditor);
htmlEditor->RangeUpdaterRef().DropSelectionState(mSavedRanges.ref());
mSavedRanges.reset();
}
// static
void AutoRangeArray::
UpdatePointsToSelectAllChildrenIfCollapsedInEmptyBlockElement(
EditorDOMPoint& aStartPoint, EditorDOMPoint& aEndPoint,
const Element& aEditingHost) {
// FYI: This was moved from
// MOOSE major hack:
// The GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock() and
// GetPointAfterFollowingLineBreakOrAtFollowingBlock() don't really do the
// right thing for collapsed ranges inside block elements that contain nothing
// but a solo <br>. It's easier/ to put a workaround here than to revamp
// them. :-(
if (aStartPoint != aEndPoint) {
return;
}
if (!aStartPoint.IsInContentNode()) {
return;
}
// XXX Perhaps, this should be more careful. This may not select only one
// node because this just check whether the block is empty or not,
// and may not select in non-editable block. However, for inline
// editing host case, it's right to look for block element without
// editable state check. Now, this method is used for preparation for
// other things. So, cannot write test for this method behavior.
// So, perhaps, we should get rid of this method and each caller should
// handle its job better.
Element* const maybeNonEditableBlockElement =
HTMLEditUtils::GetInclusiveAncestorElement(
*aStartPoint.ContainerAsContent(),
HTMLEditUtils::ClosestBlockElement);
if (!maybeNonEditableBlockElement) {
return;
}
// Make sure we don't go higher than our root element in the content tree
if (aEditingHost.IsInclusiveDescendantOf(maybeNonEditableBlockElement)) {
return;
}
if (HTMLEditUtils::IsEmptyNode(*maybeNonEditableBlockElement)) {
aStartPoint.Set(maybeNonEditableBlockElement, 0u);
aEndPoint.SetToEndOf(maybeNonEditableBlockElement);
}
}
/**
* Get the point before the line containing aPointInLine.
*
* @return If the line starts after a `<br>` element, returns next
* sibling of the `<br>` element.
* If the line is first line of a block, returns point of
* the block.
* NOTE: The result may be point of editing host. I.e., the container may be
* outside of editing host.
*/
static EditorDOMPoint
GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock(
const EditorDOMPoint& aPointInLine, EditSubAction aEditSubAction,
const Element& aEditingHost) {
// FYI: This was moved from
if (NS_WARN_IF(!aPointInLine.IsSet())) {
return EditorDOMPoint();
}
EditorDOMPoint point(aPointInLine);
// Start scanning from the container node if aPoint is in a text node.
// XXX Perhaps, IsInDataNode() must be expected.
if (point.IsInTextNode()) {
if (!point.GetContainer()->GetParentNode()) {
// Okay, can't promote any further
// XXX Why don't we return start of the text node?
return point;
}
// If there is a preformatted linefeed in the text node, let's return
// the point after it.
EditorDOMPoint atLastPreformattedNewLine =
HTMLEditUtils::GetPreviousPreformattedNewLineInTextNode<EditorDOMPoint>(
point);
if (atLastPreformattedNewLine.IsSet()) {
return atLastPreformattedNewLine.NextPoint();
}
point.Set(point.GetContainer());
}
// Look back through any further inline nodes that aren't across a <br>
// from us, and that are enclosed in the same block.
// I.e., looking for start of current hard line.
constexpr HTMLEditUtils::WalkTreeOptions
ignoreNonEditableNodeAndStopAtBlockBoundary{
HTMLEditUtils::WalkTreeOption::IgnoreNonEditableNode,
HTMLEditUtils::WalkTreeOption::StopAtBlockBoundary};
for (nsIContent* previousEditableContent = HTMLEditUtils::GetPreviousContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost);
previousEditableContent && previousEditableContent->GetParentNode() &&
!HTMLEditUtils::IsVisibleBRElement(*previousEditableContent) &&
!HTMLEditUtils::IsBlockElement(*previousEditableContent);
previousEditableContent = HTMLEditUtils::GetPreviousContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) {
EditorDOMPoint atLastPreformattedNewLine =
HTMLEditUtils::GetPreviousPreformattedNewLineInTextNode<EditorDOMPoint>(
EditorRawDOMPoint::AtEndOf(*previousEditableContent));
if (atLastPreformattedNewLine.IsSet()) {
return atLastPreformattedNewLine.NextPoint();
}
point.Set(previousEditableContent);
}
// Finding the real start for this point unless current line starts after
// <br> element. Look up the tree for as long as we are the first node in
// the container (typically, start of nearest block ancestor), and as long
// as we haven't hit the body node.
for (nsIContent* nearContent = HTMLEditUtils::GetPreviousContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost);
!nearContent && !point.IsContainerHTMLElement(nsGkAtoms::body) &&
point.GetContainerParent();
nearContent = HTMLEditUtils::GetPreviousContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) {
// Don't keep looking up if we have found a blockquote element to act on
// when we handle outdent.
// XXX Sounds like this is hacky. If possible, it should be check in
// outdent handler for consistency between edit sub-actions.
// We should check Chromium's behavior of outdent when Selection
// starts from `<blockquote>` and starts from first child of
// `<blockquote>`.
if (aEditSubAction == EditSubAction::eOutdent &&
point.IsContainerHTMLElement(nsGkAtoms::blockquote)) {
break;
}
// Don't walk past the editable section. Note that we need to check
// before walking up to a parent because we need to return the parent
// object, so the parent itself might not be in the editable area, but
// it's OK if we're not performing a block-level action.
bool blockLevelAction =
aEditSubAction == EditSubAction::eIndent ||
aEditSubAction == EditSubAction::eOutdent ||
aEditSubAction == EditSubAction::eSetOrClearAlignment ||
aEditSubAction == EditSubAction::eCreateOrRemoveBlock;
// XXX So, does this check whether the container is removable or not? It
// seems that here can be rewritten as obviously what here tries to
// check.
if (!point.GetContainerParent()->IsInclusiveDescendantOf(&aEditingHost) &&
(blockLevelAction ||
!point.GetContainer()->IsInclusiveDescendantOf(&aEditingHost))) {
break;
}
point.Set(point.GetContainer());
}
return point;
}
/**
* Get the point after the following line break or the block which breaks the
* line containing aPointInLine.
*
* @return If the line ends with a visible `<br>` element, returns
* the point after the `<br>` element.
* If the line ends with a preformatted linefeed, returns
* the point after the linefeed unless it's an invisible
* line break immediately before a block boundary.
* If the line ends with a block boundary, returns the
* point of the block.
*/
static EditorDOMPoint GetPointAfterFollowingLineBreakOrAtFollowingBlock(
const EditorDOMPoint& aPointInLine, const Element& aEditingHost) {
// FYI: This was moved from
if (NS_WARN_IF(!aPointInLine.IsSet())) {
return EditorDOMPoint();
}
EditorDOMPoint point(aPointInLine);
// Start scanning from the container node if aPoint is in a text node.
// XXX Perhaps, IsInDataNode() must be expected.
if (point.IsInTextNode()) {
if (NS_WARN_IF(!point.GetContainer()->GetParentNode())) {
// Okay, can't promote any further
// XXX Why don't we return end of the text node?
return point;
}
EditorDOMPoint atNextPreformattedNewLine =
HTMLEditUtils::GetInclusiveNextPreformattedNewLineInTextNode<
EditorDOMPoint>(point);
if (atNextPreformattedNewLine.IsSet()) {
// If the linefeed is last character of the text node, it may be
// invisible if it's immediately before a block boundary. In such
// case, we should retrun the block boundary.
Element* maybeNonEditableBlockElement = nullptr;
if (HTMLEditUtils::IsInvisiblePreformattedNewLine(
atNextPreformattedNewLine, &maybeNonEditableBlockElement) &&
maybeNonEditableBlockElement) {
// If the block is a parent of the editing host, let's return end
// of editing host.
if (maybeNonEditableBlockElement == &aEditingHost ||
!maybeNonEditableBlockElement->IsInclusiveDescendantOf(
&aEditingHost)) {
return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement);
}
// If it's invisible because of parent block boundary, return end
// of the block. Otherwise, i.e., it's followed by a child block,
// returns the point of the child block.
if (atNextPreformattedNewLine.ContainerAsText()
->IsInclusiveDescendantOf(maybeNonEditableBlockElement)) {
return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement);
}
return EditorDOMPoint(maybeNonEditableBlockElement);
}
// Otherwise, return the point after the preformatted linefeed.
return atNextPreformattedNewLine.NextPoint();
}
// want to be after the text node
point.SetAfter(point.GetContainer());
NS_WARNING_ASSERTION(point.IsSet(), "Failed to set to after the text node");
}
// Look ahead through any further inline nodes that aren't across a <br> from
// us, and that are enclosed in the same block.
// XXX Currently, we stop block-extending when finding visible <br> element.
// This might be different from "block-extend" of execCommand spec.
// However, the spec is really unclear.
// XXX Probably, scanning only editable nodes is wrong for
// EditSubAction::eCreateOrRemoveBlock because it might be better to wrap
// existing inline elements even if it's non-editable. For example,
// following examples with insertParagraph causes different result:
// * <div contenteditable>foo[]<b contenteditable="false">bar</b></div>
// * <div contenteditable>foo[]<b>bar</b></div>
// * <div contenteditable>foo[]<b contenteditable="false">bar</b>baz</div>
// Only in the first case, after the caret position isn't wrapped with
// new <div> element.
constexpr HTMLEditUtils::WalkTreeOptions
ignoreNonEditableNodeAndStopAtBlockBoundary{
HTMLEditUtils::WalkTreeOption::IgnoreNonEditableNode,
HTMLEditUtils::WalkTreeOption::StopAtBlockBoundary};
for (nsIContent* nextEditableContent = HTMLEditUtils::GetNextContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost);
nextEditableContent &&
!HTMLEditUtils::IsBlockElement(*nextEditableContent) &&
nextEditableContent->GetParent();
nextEditableContent = HTMLEditUtils::GetNextContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) {
EditorDOMPoint atFirstPreformattedNewLine =
HTMLEditUtils::GetInclusiveNextPreformattedNewLineInTextNode<
EditorDOMPoint>(EditorRawDOMPoint(nextEditableContent, 0));
if (atFirstPreformattedNewLine.IsSet()) {
// If the linefeed is last character of the text node, it may be
// invisible if it's immediately before a block boundary. In such
// case, we should retrun the block boundary.
Element* maybeNonEditableBlockElement = nullptr;
if (HTMLEditUtils::IsInvisiblePreformattedNewLine(
atFirstPreformattedNewLine, &maybeNonEditableBlockElement) &&
maybeNonEditableBlockElement) {
// If the block is a parent of the editing host, let's return end
// of editing host.
if (maybeNonEditableBlockElement == &aEditingHost ||
!maybeNonEditableBlockElement->IsInclusiveDescendantOf(
&aEditingHost)) {
return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement);
}
// If it's invisible because of parent block boundary, return end
// of the block. Otherwise, i.e., it's followed by a child block,
// returns the point of the child block.
if (atFirstPreformattedNewLine.ContainerAsText()
->IsInclusiveDescendantOf(maybeNonEditableBlockElement)) {
return EditorDOMPoint::AtEndOf(*maybeNonEditableBlockElement);
}
return EditorDOMPoint(maybeNonEditableBlockElement);
}
// Otherwise, return the point after the preformatted linefeed.
return atFirstPreformattedNewLine.NextPoint();
}
point.SetAfter(nextEditableContent);
if (NS_WARN_IF(!point.IsSet())) {
break;
}
if (HTMLEditUtils::IsVisibleBRElement(*nextEditableContent)) {
break;
}
}
// Finding the real end for this point unless current line ends with a <br>
// element. Look up the tree for as long as we are the last node in the
// container (typically, block node), and as long as we haven't hit the body
// node.
for (nsIContent* nearContent = HTMLEditUtils::GetNextContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost);
!nearContent && !point.IsContainerHTMLElement(nsGkAtoms::body) &&
point.GetContainerParent();
nearContent = HTMLEditUtils::GetNextContent(
point, ignoreNonEditableNodeAndStopAtBlockBoundary, &aEditingHost)) {
// Don't walk past the editable section. Note that we need to check before
// walking up to a parent because we need to return the parent object, so
// the parent itself might not be in the editable area, but it's OK.
// XXX Maybe returning parent of editing host is really error prone since
// everybody need to check whether the end point is in editing host
// when they touch there.
if (!point.GetContainer()->IsInclusiveDescendantOf(&aEditingHost) &&
!point.GetContainerParent()->IsInclusiveDescendantOf(&aEditingHost)) {
break;
}
point.SetAfter(point.GetContainer());
if (NS_WARN_IF(!point.IsSet())) {
break;
}
}
return point;
}
void AutoRangeArray::ExtendRangesToWrapLinesToHandleBlockLevelEditAction(
EditSubAction aEditSubAction, const Element& aEditingHost) {
// FYI: This is originated in
bool removeSomeRanges = false;
for (OwningNonNull<nsRange>& range : mRanges) {
// Remove non-positioned ranges.
if (MOZ_UNLIKELY(!range->IsPositioned())) {
removeSomeRanges = true;
continue;
}
// If the range is native anonymous subtrees, we must meet a bug of
// `Selection` so that we need to hack here.
if (MOZ_UNLIKELY(range->GetStartContainer()->IsInNativeAnonymousSubtree() ||
range->GetEndContainer()->IsInNativeAnonymousSubtree())) {
EditorRawDOMRange rawRange(range);
if (!rawRange.EnsureNotInNativeAnonymousSubtree()) {
range->Reset();
removeSomeRanges = true;
continue;
}
if (NS_FAILED(
range->SetStartAndEnd(rawRange.StartRef().ToRawRangeBoundary(),
rawRange.EndRef().ToRawRangeBoundary())) ||
MOZ_UNLIKELY(!range->IsPositioned())) {
range->Reset();
removeSomeRanges = true;
continue;
}
}
// Finally, extend the range.
if (NS_FAILED(ExtendRangeToWrapStartAndEndLinesContainingBoundaries(
range, aEditSubAction, aEditingHost))) {
// If we failed to extend the range, we should use the original range
// as-is unless the range is broken at setting the range.
if (NS_WARN_IF(!range->IsPositioned())) {
removeSomeRanges = true;
}
}
}
if (removeSomeRanges) {
for (size_t i : Reversed(IntegerRange(mRanges.Length()))) {
if (!mRanges[i]->IsPositioned()) {
mRanges.RemoveElementAt(i);
}
}
}
}
// static
nsresult AutoRangeArray::ExtendRangeToWrapStartAndEndLinesContainingBoundaries(
nsRange& aRange, EditSubAction aEditSubAction,
const Element& aEditingHost) {
MOZ_DIAGNOSTIC_ASSERT(
!EditorRawDOMPoint(aRange.StartRef()).IsInNativeAnonymousSubtree());
MOZ_DIAGNOSTIC_ASSERT(
!EditorRawDOMPoint(aRange.EndRef()).IsInNativeAnonymousSubtree());
if (NS_WARN_IF(!aRange.IsPositioned())) {
return NS_ERROR_INVALID_ARG;
}
EditorDOMPoint startPoint(aRange.StartRef()), endPoint(aRange.EndRef());
AutoRangeArray::UpdatePointsToSelectAllChildrenIfCollapsedInEmptyBlockElement(
startPoint, endPoint, aEditingHost);
// Make a new adjusted range to represent the appropriate block content.
// This is tricky. The basic idea is to push out the range endpoints to
// truly enclose the blocks that we will affect.
// Make sure that the new range ends up to be in the editable section.
// XXX Looks like that this check wastes the time. Perhaps, we should
// implement a method which checks both two DOM points in the editor
// root.
startPoint = GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock(
startPoint, aEditSubAction, aEditingHost);
// XXX GetPointAtFirstContentOfLineOrParentBlockIfFirstContentOfBlock() may
// return point of editing host. Perhaps, we should change it and stop
// checking it here since this check may be expensive.
// XXX If the container is an element in the editing host but it points end of
// the container, this returns nullptr. Is it intentional?
if (!startPoint.GetChildOrContainerIfDataNode() ||
!startPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf(
&aEditingHost)) {
return NS_ERROR_FAILURE;
}
endPoint =
GetPointAfterFollowingLineBreakOrAtFollowingBlock(endPoint, aEditingHost);
const EditorDOMPoint lastRawPoint =
endPoint.IsStartOfContainer() ? endPoint : endPoint.PreviousPoint();
// XXX GetPointAfterFollowingLineBreakOrAtFollowingBlock() may return point of
// editing host. Perhaps, we should change it and stop checking it here
// since this check may be expensive.
// XXX If the container is an element in the editing host but it points end of
// the container, this returns nullptr. Is it intentional?
if (!lastRawPoint.GetChildOrContainerIfDataNode() ||
!lastRawPoint.GetChildOrContainerIfDataNode()->IsInclusiveDescendantOf(
&aEditingHost)) {
return NS_ERROR_FAILURE;
}
nsresult rv = aRange.SetStartAndEnd(startPoint.ToRawRangeBoundary(),
endPoint.ToRawRangeBoundary());
if (NS_FAILED(rv)) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
Result<EditorDOMPoint, nsresult> AutoRangeArray::
SplitTextNodesAtEndBoundariesAndParentInlineElementsAtBoundaries(
HTMLEditor& aHTMLEditor) {
// FYI: The following code is originated in
// Split text nodes. This is necessary, since given ranges may end in text
// nodes in case where part of a pre-formatted elements needs to be moved.
EditorDOMPoint pointToPutCaret;
IgnoredErrorResult ignoredError;
for (const OwningNonNull<nsRange>& range : mRanges) {
EditorDOMPoint atEnd(range->EndRef());
if (NS_WARN_IF(!atEnd.IsSet()) || !atEnd.IsInTextNode()) {
continue;
}
if (!atEnd.IsStartOfContainer() && !atEnd.IsEndOfContainer()) {
// Split the text node.
SplitNodeResult splitAtEndResult =
aHTMLEditor.SplitNodeWithTransaction(atEnd);
if (splitAtEndResult.isErr()) {
NS_WARNING("HTMLEditor::SplitNodeWithTransaction() failed");
return Err(splitAtEndResult.unwrapErr());
}
splitAtEndResult.MoveCaretPointTo(pointToPutCaret,
{SuggestCaret::OnlyIfHasSuggestion});
// Correct the range.
// The new end parent becomes the parent node of the text.
MOZ_ASSERT(!range->IsInSelection());
range->SetEnd(splitAtEndResult.AtNextContent<EditorRawDOMPoint>()
.ToRawRangeBoundary(),
ignoredError);
NS_WARNING_ASSERTION(!ignoredError.Failed(),
"nsRange::SetEnd() failed, but ignored");
ignoredError.SuppressException();
}
}
// FYI: The following code is originated in
nsTArray<OwningNonNull<RangeItem>> rangeItemArray;
rangeItemArray.AppendElements(mRanges.Length());
// First register ranges for special editor gravity
for (OwningNonNull<RangeItem>& rangeItem : rangeItemArray) {
rangeItem = new RangeItem();
rangeItem->StoreRange(*mRanges[0]);
aHTMLEditor.RangeUpdaterRef().RegisterRangeItem(*rangeItem);
// TODO: We should keep the array, and just update the ranges.
mRanges.RemoveElementAt(0);
}
// Now bust up inlines.
nsresult rv = NS_OK;
for (OwningNonNull<RangeItem>& item : Reversed(rangeItemArray)) {
// MOZ_KnownLive because 'rangeItemArray' is guaranteed to keep it alive.
Result<EditorDOMPoint, nsresult> splitParentsResult =
aHTMLEditor.SplitParentInlineElementsAtRangeEdges(MOZ_KnownLive(*item));
if (MOZ_UNLIKELY(splitParentsResult.isErr())) {
NS_WARNING("HTMLEditor::SplitParentInlineElementsAtRangeEdges() failed");
rv = splitParentsResult.unwrapErr();
break;
}
if (splitParentsResult.inspect().IsSet()) {
pointToPutCaret = splitParentsResult.unwrap();
}
}
// Then unregister the ranges
for (OwningNonNull<RangeItem>& item : rangeItemArray) {
aHTMLEditor.RangeUpdaterRef().DropRangeItem(item);
RefPtr<nsRange> range = item->GetRange();
if (range) {
mRanges.AppendElement(std::move(range));
}
}
// XXX Why do we ignore the other errors here??
if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED)) {
return Err(NS_ERROR_EDITOR_DESTROYED);
}
return pointToPutCaret;
}
nsresult AutoRangeArray::CollectEditTargetNodes(
const HTMLEditor& aHTMLEditor,
nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents,
EditSubAction aEditSubAction,
CollectNonEditableNodes aCollectNonEditableNodes) const {
MOZ_ASSERT(aHTMLEditor.IsEditActionDataAvailable());
// FYI: This was moved from
// Gather up a list of all the nodes
for (const OwningNonNull<nsRange>& range : mRanges) {
DOMSubtreeIterator iter;
nsresult rv = iter.Init(*range);
if (NS_FAILED(rv)) {
NS_WARNING("DOMSubtreeIterator::Init() failed");
return rv;
}
if (aOutArrayOfContents.IsEmpty()) {
iter.AppendAllNodesToArray(aOutArrayOfContents);
} else {
AutoTArray<OwningNonNull<nsIContent>, 24> arrayOfTopChildren;
iter.AppendNodesToArray(
+[](nsINode& aNode, void* aArray) -> bool {
MOZ_ASSERT(aArray);
return !static_cast<nsTArray<OwningNonNull<nsIContent>>*>(aArray)
->Contains(&aNode);
},
arrayOfTopChildren, &aOutArrayOfContents);
aOutArrayOfContents.AppendElements(std::move(arrayOfTopChildren));
}
if (aCollectNonEditableNodes == CollectNonEditableNodes::No) {
for (size_t i : Reversed(IntegerRange(aOutArrayOfContents.Length()))) {
if (!EditorUtils::IsEditableContent(aOutArrayOfContents[i],
EditorUtils::EditorType::HTML)) {
aOutArrayOfContents.RemoveElementAt(i);
}
}
}
}
switch (aEditSubAction) {
case EditSubAction::eCreateOrRemoveBlock: {
// Certain operations should not act on li's and td's, but rather inside
// them. Alter the list as needed.
CollectChildrenOptions options = {
CollectChildrenOption::CollectListChildren,
CollectChildrenOption::CollectTableChildren};
if (aCollectNonEditableNodes == CollectNonEditableNodes::No) {
options += CollectChildrenOption::IgnoreNonEditableChildren;
}
for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) {
OwningNonNull<nsIContent> content = aOutArrayOfContents[i];
if (HTMLEditUtils::IsListItem(content)) {
aOutArrayOfContents.RemoveElementAt(i);
HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i,
options);
}
}
// Empty text node shouldn't be selected if unnecessary
for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) {
if (Text* text = aOutArrayOfContents[i]->GetAsText()) {
// Don't select empty text except to empty block
if (!HTMLEditUtils::IsVisibleTextNode(*text)) {
aOutArrayOfContents.RemoveElementAt(i);
}
}
}
break;
}
case EditSubAction::eCreateOrChangeList: {
// XXX aCollectNonEditableNodes is ignored here. Maybe a bug.
CollectChildrenOptions options = {
CollectChildrenOption::CollectTableChildren};
for (size_t i = aOutArrayOfContents.Length(); i > 0; i--) {
// Scan for table elements. If we find table elements other than
// table, replace it with a list of any editable non-table content
// because if a selection range starts from end in a table-cell and
// ends at or starts from outside the `<table>`, we need to make
// lists in each selected table-cells.
OwningNonNull<nsIContent> content = aOutArrayOfContents[i - 1];
if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) {
aOutArrayOfContents.RemoveElementAt(i - 1);
HTMLEditUtils::CollectChildren(content, aOutArrayOfContents, i - 1,
options);
}
}
// If there is only one node in the array, and it is a `<div>`,
// `<blockquote>` or a list element, then look inside of it until we
// find inner list or content.
if (aOutArrayOfContents.Length() != 1) {
break;
}
Element* deepestDivBlockquoteOrListElement =
HTMLEditUtils::GetInclusiveDeepestFirstChildWhichHasOneChild(
aOutArrayOfContents[0],
{HTMLEditUtils::WalkTreeOption::IgnoreNonEditableNode},
nsGkAtoms::div, nsGkAtoms::blockquote, nsGkAtoms::ul,
nsGkAtoms::ol, nsGkAtoms::dl);
if (!deepestDivBlockquoteOrListElement) {
break;
}
if (deepestDivBlockquoteOrListElement->IsAnyOfHTMLElements(
nsGkAtoms::div, nsGkAtoms::blockquote)) {
aOutArrayOfContents.Clear();
// XXX Before we're called, non-editable nodes are ignored. However,
// we may append non-editable nodes here.
HTMLEditUtils::CollectChildren(*deepestDivBlockquoteOrListElement,
aOutArrayOfContents, 0, {});
break;
}
aOutArrayOfContents.ReplaceElementAt(
0, OwningNonNull<nsIContent>(*deepestDivBlockquoteOrListElement));
break;
}
case EditSubAction::eOutdent:
case EditSubAction::eIndent:
case EditSubAction::eSetPositionToAbsolute: {
// Indent/outdent already do something special for list items, but we
// still need to make sure we don't act on table elements
CollectChildrenOptions options = {
CollectChildrenOption::CollectListChildren,
CollectChildrenOption::CollectTableChildren};
if (aCollectNonEditableNodes == CollectNonEditableNodes::No) {
options += CollectChildrenOption::IgnoreNonEditableChildren;
}
for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) {
OwningNonNull<nsIContent> content = aOutArrayOfContents[i];
if (HTMLEditUtils::IsAnyTableElementButNotTable(content)) {
aOutArrayOfContents.RemoveElementAt(i);
HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i,
options);
}
}
break;
}
default:
break;
}
// Outdent should look inside of divs.
if (aEditSubAction == EditSubAction::eOutdent &&
!aHTMLEditor.IsCSSEnabled()) {
CollectChildrenOptions options = {};
if (aCollectNonEditableNodes == CollectNonEditableNodes::No) {
options += CollectChildrenOption::IgnoreNonEditableChildren;
}
for (int32_t i = aOutArrayOfContents.Length() - 1; i >= 0; i--) {
OwningNonNull<nsIContent> content = aOutArrayOfContents[i];
if (content->IsHTMLElement(nsGkAtoms::div)) {
aOutArrayOfContents.RemoveElementAt(i);
HTMLEditUtils::CollectChildren(*content, aOutArrayOfContents, i,
options);
}
}
}
return NS_OK;
}
/******************************************************************************
* some general purpose editor utils
*****************************************************************************/
bool EditorUtils::IsDescendantOf(const nsINode& aNode, const nsINode& aParent,
EditorRawDOMPoint* aOutPoint /* = nullptr */) {
if (aOutPoint) {
aOutPoint->Clear();
}
if (&aNode == &aParent) {
return false;
}
for (const nsINode* node = &aNode; node; node = node->GetParentNode()) {
if (node->GetParentNode() == &aParent) {
if (aOutPoint) {
MOZ_ASSERT(node->IsContent());
aOutPoint->Set(node->AsContent());
}
return true;
}
}
return false;
}
bool EditorUtils::IsDescendantOf(const nsINode& aNode, const nsINode& aParent,
EditorDOMPoint* aOutPoint) {
MOZ_ASSERT(aOutPoint);
aOutPoint->Clear();
if (&aNode == &aParent) {
return false;
}
for (const nsINode* node = &aNode; node; node = node->GetParentNode()) {
if (node->GetParentNode() == &aParent) {
MOZ_ASSERT(node->IsContent());
aOutPoint->Set(node->AsContent());
return true;
}
}
return false;
}
// static
void EditorUtils::MaskString(nsString& aString, const Text& aTextNode,
uint32_t aStartOffsetInString,
uint32_t aStartOffsetInText) {
MOZ_ASSERT(aTextNode.HasFlag(NS_MAYBE_MASKED));
MOZ_ASSERT(aStartOffsetInString == 0 || aStartOffsetInText == 0);
uint32_t unmaskStart = UINT32_MAX, unmaskLength = 0;
TextEditor* textEditor =
nsContentUtils::GetTextEditorFromAnonymousNodeWithoutCreation(&aTextNode);
if (textEditor && textEditor->UnmaskedLength() > 0) {
unmaskStart = textEditor->UnmaskedStart();
unmaskLength = textEditor->UnmaskedLength();
// If text is copied from after unmasked range, we can treat this case
// as mask all.
if (aStartOffsetInText >= unmaskStart + unmaskLength) {
unmaskLength = 0;
unmaskStart = UINT32_MAX;
} else {
// If text is copied from middle of unmasked range, reduce the length
// and adjust start offset.
if (aStartOffsetInText > unmaskStart) {
unmaskLength = unmaskStart + unmaskLength - aStartOffsetInText;
unmaskStart = 0;
}
// If text is copied from before start of unmasked range, just adjust
// the start offset.
else {
unmaskStart -= aStartOffsetInText;
}
// Make the range is in the string.
unmaskStart += aStartOffsetInString;
}
}
const char16_t kPasswordMask = TextEditor::PasswordMask();
for (uint32_t i = aStartOffsetInString; i < aString.Length(); ++i) {
bool isSurrogatePair = NS_IS_HIGH_SURROGATE(aString.CharAt(i)) &&
i < aString.Length() - 1 &&
NS_IS_LOW_SURROGATE(aString.CharAt(i + 1));
if (i < unmaskStart || i >= unmaskStart + unmaskLength) {
if (isSurrogatePair) {
aString.SetCharAt(kPasswordMask, i);
aString.SetCharAt(kPasswordMask, i + 1);
} else {
aString.SetCharAt(kPasswordMask, i);
}
}
// Skip the following low surrogate.
if (isSurrogatePair) {
++i;
}
}
}
// static
bool EditorUtils::IsWhiteSpacePreformatted(const nsIContent& aContent) {
// Look at the node (and its parent if it's not an element), and grab its
// ComputedStyle.
Element* element = aContent.GetAsElementOrParentElement();
if (!element) {
return false;
}
RefPtr<const ComputedStyle> elementStyle =
nsComputedDOMStyle::GetComputedStyleNoFlush(element);
if (!elementStyle) {
// Consider nodes without a ComputedStyle to be NOT preformatted:
// For instance, this is true of JS tags inside the body (which show
// up as #text nodes but have no ComputedStyle).
return false;
}
return elementStyle->StyleText()->WhiteSpaceIsSignificant();
}
// static
bool EditorUtils::IsNewLinePreformatted(const nsIContent& aContent) {
// Look at the node (and its parent if it's not an element), and grab its
// ComputedStyle.
Element* element = aContent.GetAsElementOrParentElement();
if (!element) {
return false;
}
RefPtr<const ComputedStyle> elementStyle =
nsComputedDOMStyle::GetComputedStyleNoFlush(element);
if (!elementStyle) {
// Consider nodes without a ComputedStyle to be NOT preformatted:
// For instance, this is true of JS tags inside the body (which show
// up as #text nodes but have no ComputedStyle).
return false;
}
return elementStyle->StyleText()->NewlineIsSignificantStyle();
}
// static
bool EditorUtils::IsOnlyNewLinePreformatted(const nsIContent& aContent) {
// Look at the node (and its parent if it's not an element), and grab its
// ComputedStyle.
Element* element = aContent.GetAsElementOrParentElement();
if (!element) {
return false;
}
RefPtr<const ComputedStyle> elementStyle =
nsComputedDOMStyle::GetComputedStyleNoFlush(element);
if (!elementStyle) {
// Consider nodes without a ComputedStyle to be NOT preformatted:
// For instance, this is true of JS tags inside the body (which show
// up as #text nodes but have no ComputedStyle).
return false;
}
return elementStyle->StyleText()->mWhiteSpace == StyleWhiteSpace::PreLine;
}
bool EditorUtils::IsPointInSelection(const Selection& aSelection,
const nsINode& aParentNode,
uint32_t aOffset) {
if (aSelection.IsCollapsed()) {
return false;
}
const uint32_t rangeCount = aSelection.RangeCount();
for (const uint32_t i : IntegerRange(rangeCount)) {
MOZ_ASSERT(aSelection.RangeCount() == rangeCount);
RefPtr<const nsRange> range = aSelection.GetRangeAt(i);
if (MOZ_UNLIKELY(NS_WARN_IF(!range))) {
// Don't bail yet, iterate through them all
continue;
}
IgnoredErrorResult ignoredError;
bool nodeIsInSelection =
range->IsPointInRange(aParentNode, aOffset, ignoredError) &&
!ignoredError.Failed();
NS_WARNING_ASSERTION(!ignoredError.Failed(),
"nsRange::IsPointInRange() failed");
// Done when we find a range that we are in
if (nodeIsInSelection) {
return true;
}
}
return false;
}
// static
Result<nsCOMPtr<nsITransferable>, nsresult>
EditorUtils::CreateTransferableForPlainText(const Document& aDocument) {
// Create generic Transferable for getting the data
nsresult rv;
nsCOMPtr<nsITransferable> transferable =
do_CreateInstance("@mozilla.org/widget/transferable;1", &rv);
if (NS_FAILED(rv)) {
NS_WARNING("do_CreateInstance() failed to create nsITransferable instance");
return Err(rv);
}
if (!transferable) {
NS_WARNING("do_CreateInstance() returned nullptr, but ignored");
return nsCOMPtr<nsITransferable>();
}
DebugOnly<nsresult> rvIgnored =
transferable->Init(aDocument.GetLoadContext());
NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
"nsITransferable::Init() failed, but ignored");
rvIgnored = transferable->AddDataFlavor(kUnicodeMime);
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rvIgnored),
"nsITransferable::AddDataFlavor(kUnicodeMime) failed, but ignored");
rvIgnored = transferable->AddDataFlavor(kMozTextInternal);
NS_WARNING_ASSERTION(
NS_SUCCEEDED(rvIgnored),
"nsITransferable::AddDataFlavor(kMozTextInternal) failed, but ignored");
return transferable;
}
/******************************************************************************
* mozilla::EditorDOMPointBase
*****************************************************************************/
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool, IsCharCollapsibleASCIISpace);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsCharCollapsibleASCIISpace() const {
if (IsCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsCharASCIISpace() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool, IsCharCollapsibleNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsCharCollapsibleNBSP() const {
// TODO: Perhaps, we should return false if neither previous char nor
// next char is collapsible white-space or NBSP.
return IsCharNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool,
IsCharCollapsibleASCIISpaceOrNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsCharCollapsibleASCIISpaceOrNBSP() const {
if (IsCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsCharASCIISpaceOrNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsPreviousCharCollapsibleASCIISpace);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsPreviousCharCollapsibleASCIISpace() const {
if (IsPreviousCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsPreviousCharASCIISpace() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool,
IsPreviousCharCollapsibleNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsPreviousCharCollapsibleNBSP() const {
return IsPreviousCharNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsPreviousCharCollapsibleASCIISpaceOrNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsPreviousCharCollapsibleASCIISpaceOrNBSP()
const {
if (IsPreviousCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsPreviousCharASCIISpaceOrNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool,
IsNextCharCollapsibleASCIISpace);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsNextCharCollapsibleASCIISpace() const {
if (IsNextCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsNextCharASCIISpace() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool, IsNextCharCollapsibleNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsNextCharCollapsibleNBSP() const {
return IsNextCharNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsNextCharCollapsibleASCIISpaceOrNBSP);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsNextCharCollapsibleASCIISpaceOrNBSP() const {
if (IsNextCharNewLine()) {
return !EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
return IsNextCharASCIISpaceOrNBSP() &&
!EditorUtils::IsWhiteSpacePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool, IsCharPreformattedNewLine);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsCharPreformattedNewLine() const {
return IsCharNewLine() &&
EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsCharPreformattedNewLineCollapsedWithWhiteSpaces);
template <typename PT, typename CT>
bool EditorDOMPointBase<
PT, CT>::IsCharPreformattedNewLineCollapsedWithWhiteSpaces() const {
return IsCharNewLine() &&
EditorUtils::IsOnlyNewLinePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool,
IsPreviousCharPreformattedNewLine);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsPreviousCharPreformattedNewLine() const {
return IsPreviousCharNewLine() &&
EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsPreviousCharPreformattedNewLineCollapsedWithWhiteSpaces);
template <typename PT, typename CT>
bool EditorDOMPointBase<
PT, CT>::IsPreviousCharPreformattedNewLineCollapsedWithWhiteSpaces() const {
return IsPreviousCharNewLine() &&
EditorUtils::IsOnlyNewLinePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(bool,
IsNextCharPreformattedNewLine);
template <typename PT, typename CT>
bool EditorDOMPointBase<PT, CT>::IsNextCharPreformattedNewLine() const {
return IsNextCharNewLine() &&
EditorUtils::IsNewLinePreformatted(*ContainerAsText());
}
NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(
bool, IsNextCharPreformattedNewLineCollapsedWithWhiteSpaces);
template <typename PT, typename CT>
bool