EditorDOMPoint.h
/* -*- 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/. */
#ifndef mozilla_EditorDOMPoint_h
#define mozilla_EditorDOMPoint_h
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/EditorForwards.h"
#include "mozilla/Maybe.h"
#include "mozilla/RangeBoundary.h"
#include "mozilla/ToString.h"
#include "mozilla/dom/AbstractRange.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Selection.h" // for Selection::InterlinePosition
#include "mozilla/dom/Text.h"
#include "nsAtom.h"
#include "nsCOMPtr.h"
#include "nsContentUtils.h"
#include "nsCRT.h"
#include "nsGkAtoms.h"
#include "nsIContent.h"
#include "nsINode.h"
#include "nsStyledElement.h"
#include <type_traits>
namespace mozilla {
/**
* EditorDOMPoint and EditorRawDOMPoint are simple classes which refers
* a point in the DOM tree at creating the instance or initializing the
* instance with calling Set().
*
* EditorDOMPoint refers container node (and child node if it's already set)
* with nsCOMPtr. EditorRawDOMPoint refers them with raw pointer.
* So, EditorRawDOMPoint is useful when you access the nodes only before
* changing DOM tree since increasing refcount may appear in micro benchmark
* if it's in a hot path. On the other hand, if you need to refer them even
* after changing DOM tree, you must use EditorDOMPoint.
*
* When initializing an instance only with child node or offset, the instance
* starts to refer the child node or offset in the container. In this case,
* the other information hasn't been initialized due to performance reason.
* When you retrieve the other information with calling Offset() or
* GetChild(), the other information is computed with the current DOM tree.
* Therefore, e.g., in the following case, the other information may be
* different:
*
* EditorDOMPoint pointA(container1, childNode1);
* EditorDOMPoint pointB(container1, childNode1);
* Unused << pointA.Offset(); // The offset is computed now.
* container1->RemoveChild(childNode1->GetPreviousSibling());
* Unused << pointB.Offset(); // Now, pointB.Offset() equals pointA.Offset() - 1
*
* similarly:
*
* EditorDOMPoint pointA(container1, 5);
* EditorDOMPoint pointB(container1, 5);
* Unused << pointA.GetChild(); // The child is computed now.
* container1->RemoveChild(childNode1->GetFirstChild());
* Unused << pointB.GetChild(); // Now, pointB.GetChild() equals
* // pointA.GetChild()->GetPreviousSibling().
*
* So, when you initialize an instance only with one information, you need to
* be careful when you access the other information after changing the DOM tree.
* When you need to lock the child node or offset and recompute the other
* information with new DOM tree, you can use
* AutoEditorDOMPointOffsetInvalidator and AutoEditorDOMPointChildInvalidator.
*/
// FYI: Don't make the following instantiating macros end with `;` because
// using them without `;`, VSCode may be confused and cause wrong red-
// wavy underlines in the following code of the macro.
#define NS_INSTANTIATE_EDITOR_DOM_POINT_METHOD(aResultType, aMethodName, ...) \
template aResultType EditorDOMPoint::aMethodName(__VA_ARGS__); \
template aResultType EditorRawDOMPoint::aMethodName(__VA_ARGS__); \
template aResultType EditorDOMPointInText::aMethodName(__VA_ARGS__); \
template aResultType EditorRawDOMPointInText::aMethodName(__VA_ARGS__)
#define NS_INSTANTIATE_EDITOR_DOM_POINT_CONST_METHOD(aResultType, aMethodName, \
...) \
template aResultType EditorDOMPoint::aMethodName(__VA_ARGS__) const; \
template aResultType EditorRawDOMPoint::aMethodName(__VA_ARGS__) const; \
template aResultType EditorDOMPointInText::aMethodName(__VA_ARGS__) const; \
template aResultType EditorRawDOMPointInText::aMethodName(__VA_ARGS__) const
#define NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(aMethodName, ...) \
template EditorDOMPoint aMethodName(__VA_ARGS__); \
template EditorRawDOMPoint aMethodName(__VA_ARGS__); \
template EditorDOMPointInText aMethodName(__VA_ARGS__); \
template EditorRawDOMPointInText aMethodName(__VA_ARGS__)
#define NS_INSTANTIATE_CONST_METHOD_RETURNING_ANY_EDITOR_DOM_POINT( \
aMethodName, ...) \
template EditorDOMPoint aMethodName(__VA_ARGS__) const; \
template EditorRawDOMPoint aMethodName(__VA_ARGS__) const; \
template EditorDOMPointInText aMethodName(__VA_ARGS__) const; \
template EditorRawDOMPointInText aMethodName(__VA_ARGS__) const
template <typename ParentType, typename ChildType>
class EditorDOMPointBase final {
using SelfType = EditorDOMPointBase<ParentType, ChildType>;
public:
using InterlinePosition = dom::Selection::InterlinePosition;
EditorDOMPointBase() = default;
template <typename ContainerType>
EditorDOMPointBase(
const ContainerType* aContainer, uint32_t aOffset,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined)
: mParent(const_cast<ContainerType*>(aContainer)),
mChild(nullptr),
mOffset(Some(aOffset)),
mInterlinePosition(aInterlinePosition) {
NS_WARNING_ASSERTION(
!mParent || mOffset.value() <= mParent->Length(),
"The offset is larger than the length of aContainer or negative");
if (!mParent) {
mOffset.reset();
}
}
template <typename ContainerType, template <typename> typename StrongPtr>
EditorDOMPointBase(
const StrongPtr<ContainerType>& aContainer, uint32_t aOffset,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined)
: EditorDOMPointBase(aContainer.get(), aOffset, aInterlinePosition) {}
template <typename ContainerType, template <typename> typename StrongPtr>
EditorDOMPointBase(
const StrongPtr<const ContainerType>& aContainer, uint32_t aOffset,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined)
: EditorDOMPointBase(aContainer.get(), aOffset, aInterlinePosition) {}
/**
* Different from RangeBoundary, aPointedNode should be a child node
* which you want to refer.
*/
explicit EditorDOMPointBase(
const nsINode* aPointedNode,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined)
: mParent(aPointedNode && aPointedNode->IsContent()
? aPointedNode->GetParentNode()
: nullptr),
mChild(aPointedNode && aPointedNode->IsContent()
? const_cast<nsIContent*>(aPointedNode->AsContent())
: nullptr),
mInterlinePosition(aInterlinePosition) {
mIsChildInitialized = aPointedNode && mChild;
NS_WARNING_ASSERTION(IsSet(),
"The child is nullptr or doesn't have its parent");
NS_WARNING_ASSERTION(mChild && mChild->GetParentNode() == mParent,
"Initializing RangeBoundary with invalid value");
}
EditorDOMPointBase(
nsINode* aContainer, nsIContent* aPointedNode, uint32_t aOffset,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined)
: mParent(aContainer),
mChild(aPointedNode),
mOffset(mozilla::Some(aOffset)),
mInterlinePosition(aInterlinePosition),
mIsChildInitialized(true) {
MOZ_DIAGNOSTIC_ASSERT(
aContainer, "This constructor shouldn't be used when pointing nowhere");
MOZ_ASSERT(mOffset.value() <= mParent->Length());
MOZ_ASSERT(mChild || mParent->Length() == mOffset.value() ||
!mParent->IsContainerNode());
MOZ_ASSERT(!mChild || mParent == mChild->GetParentNode());
MOZ_ASSERT(mParent->GetChildAt_Deprecated(mOffset.value()) == mChild);
}
template <typename PT, typename CT>
explicit EditorDOMPointBase(const RangeBoundaryBase<PT, CT>& aOther)
: mParent(aOther.mParent),
mChild(aOther.mRef ? aOther.mRef->GetNextSibling()
: (aOther.mParent ? aOther.mParent->GetFirstChild()
: nullptr)),
mOffset(aOther.mOffset),
mIsChildInitialized(aOther.mRef || (aOther.mOffset.isSome() &&
!aOther.mOffset.value())) {}
void SetInterlinePosition(InterlinePosition aInterlinePosition) {
MOZ_ASSERT(IsSet());
mInterlinePosition = aInterlinePosition;
}
InterlinePosition GetInterlinePosition() const {
return IsSet() ? mInterlinePosition : InterlinePosition::Undefined;
}
/**
* GetContainer() returns the container node at the point.
* GetContainerAs() returns the container node as specific type.
*/
nsINode* GetContainer() const { return mParent; }
template <typename ContentNodeType>
ContentNodeType* GetContainerAs() const {
return ContentNodeType::FromNodeOrNull(mParent);
}
/**
* ContainerAs() returns the container node with just casting to the specific
* type. Therefore, callers need to guarantee that the result is not nullptr
* nor wrong cast.
*/
template <typename ContentNodeType>
ContentNodeType* ContainerAs() const {
MOZ_ASSERT(mParent);
MOZ_DIAGNOSTIC_ASSERT(ContentNodeType::FromNode(mParent));
return static_cast<ContentNodeType*>(GetContainer());
}
/**
* GetContainerParent() returns parent of the container node at the point.
*/
nsINode* GetContainerParent() const {
return mParent ? mParent->GetParent() : nullptr;
}
template <typename ContentNodeType>
ContentNodeType* GetContainerParentAs() const {
return ContentNodeType::FromNodeOrNull(GetContainerParent());
}
template <typename ContentNodeType>
ContentNodeType* ContainerParentAs() const {
MOZ_DIAGNOSTIC_ASSERT(GetContainerParentAs<ContentNodeType>());
return static_cast<ContentNodeType*>(GetContainerParent());
}
dom::Element* GetContainerOrContainerParentElement() const {
if (MOZ_UNLIKELY(!mParent)) {
return nullptr;
}
return mParent->IsElement() ? ContainerAs<dom::Element>()
: GetContainerParentAs<dom::Element>();
}
/**
* CanContainerHaveChildren() returns true if the container node can have
* child nodes. Otherwise, e.g., when the container is a text node, returns
* false.
*/
bool CanContainerHaveChildren() const {
return mParent && mParent->IsContainerNode();
}
/**
* IsContainerEmpty() returns true if it has no children or its text is empty.
*/
bool IsContainerEmpty() const { return mParent && !mParent->Length(); }
/**
* IsInContentNode() returns true if the container is a subclass of
* nsIContent.
*/
bool IsInContentNode() const { return mParent && mParent->IsContent(); }
/**
* IsInDataNode() returns true if the container node is a data node including
* text node.
*/
bool IsInDataNode() const { return mParent && mParent->IsCharacterData(); }
/**
* IsInTextNode() returns true if the container node is a text node.
*/
bool IsInTextNode() const { return mParent && mParent->IsText(); }
/**
* IsInNativeAnonymousSubtree() returns true if the container is in
* native anonymous subtree.
*/
bool IsInNativeAnonymousSubtree() const {
return mParent && mParent->IsInNativeAnonymousSubtree();
}
/**
* IsContainerHTMLElement() returns true if the container node is an HTML
* element node and its node name is aTag.
*/
bool IsContainerHTMLElement(nsAtom* aTag) const {
return mParent && mParent->IsHTMLElement(aTag);
}
/**
* IsContainerAnyOfHTMLElements() returns true if the container node is an
* HTML element node and its node name is one of the arguments.
*/
template <typename First, typename... Args>
bool IsContainerAnyOfHTMLElements(First aFirst, Args... aArgs) const {
return mParent && mParent->IsAnyOfHTMLElements(aFirst, aArgs...);
}
/**
* GetChild() returns a child node which is pointed by the instance.
* If mChild hasn't been initialized yet, this computes the child node
* from mParent and mOffset with *current* DOM tree.
*/
nsIContent* GetChild() const {
if (!mParent || !mParent->IsContainerNode()) {
return nullptr;
}
if (mIsChildInitialized) {
return mChild;
}
// Fix child node now.
const_cast<SelfType*>(this)->EnsureChild();
return mChild;
}
template <typename ContentNodeType>
ContentNodeType* GetChildAs() const {
return ContentNodeType::FromNodeOrNull(GetChild());
}
template <typename ContentNodeType>
ContentNodeType* ChildAs() const {
MOZ_DIAGNOSTIC_ASSERT(GetChildAs<ContentNodeType>());
return static_cast<ContentNodeType*>(GetChild());
}
/**
* GetCurrentChildAtOffset() returns current child at mOffset.
* I.e., mOffset needs to be fixed before calling this.
*/
nsIContent* GetCurrentChildAtOffset() const {
MOZ_ASSERT(mOffset.isSome());
if (mOffset.isNothing()) {
return GetChild();
}
return mParent ? mParent->GetChildAt_Deprecated(*mOffset) : nullptr;
}
/**
* GetChildOrContainerIfDataNode() returns the child content node,
* or container content node if the container is a data node.
*/
nsIContent* GetChildOrContainerIfDataNode() const {
if (IsInDataNode()) {
return ContainerAs<nsIContent>();
}
return GetChild();
}
/**
* GetNextSiblingOfChild() returns next sibling of the child node.
* If this refers after the last child or the container cannot have children,
* this returns nullptr with warning.
* If mChild hasn't been initialized yet, this computes the child node
* from mParent and mOffset with *current* DOM tree.
*/
nsIContent* GetNextSiblingOfChild() const {
if (NS_WARN_IF(!mParent) || !mParent->IsContainerNode()) {
return nullptr;
}
if (mIsChildInitialized) {
return mChild ? mChild->GetNextSibling() : nullptr;
}
MOZ_ASSERT(mOffset.isSome());
if (NS_WARN_IF(mOffset.value() > mParent->Length())) {
// If this has been set only offset and now the offset is invalid,
// let's just return nullptr.
return nullptr;
}
// Fix child node now.
const_cast<SelfType*>(this)->EnsureChild();
return mChild ? mChild->GetNextSibling() : nullptr;
}
template <typename ContentNodeType>
ContentNodeType* GetNextSiblingOfChildAs() const {
return ContentNodeType::FromNodeOrNull(GetNextSiblingOfChild());
}
template <typename ContentNodeType>
ContentNodeType* NextSiblingOfChildAs() const {
MOZ_ASSERT(IsSet());
MOZ_DIAGNOSTIC_ASSERT(GetNextSiblingOfChildAs<ContentNodeType>());
return static_cast<ContentNodeType*>(GetNextSiblingOfChild());
}
/**
* GetPreviousSiblingOfChild() returns previous sibling of a child
* at offset. If this refers the first child or the container cannot have
* children, this returns nullptr with warning.
* If mChild hasn't been initialized yet, this computes the child node
* from mParent and mOffset with *current* DOM tree.
*/
nsIContent* GetPreviousSiblingOfChild() const {
if (NS_WARN_IF(!mParent) || !mParent->IsContainerNode()) {
return nullptr;
}
if (mIsChildInitialized) {
return mChild ? mChild->GetPreviousSibling() : mParent->GetLastChild();
}
MOZ_ASSERT(mOffset.isSome());
if (NS_WARN_IF(mOffset.value() > mParent->Length())) {
// If this has been set only offset and now the offset is invalid,
// let's just return nullptr.
return nullptr;
}
// Fix child node now.
const_cast<SelfType*>(this)->EnsureChild();
return mChild ? mChild->GetPreviousSibling() : mParent->GetLastChild();
}
template <typename ContentNodeType>
ContentNodeType* GetPreviousSiblingOfChildAs() const {
return ContentNodeType::FromNodeOrNull(GetPreviousSiblingOfChild());
}
template <typename ContentNodeType>
ContentNodeType* PreviousSiblingOfChildAs() const {
MOZ_ASSERT(IsSet());
MOZ_DIAGNOSTIC_ASSERT(GetPreviousSiblingOfChildAs<ContentNodeType>());
return static_cast<ContentNodeType*>(GetPreviousSiblingOfChild());
}
/**
* Simple accessors of the character in dom::Text so that when you call
* these methods, you need to guarantee that the container is a dom::Text.
*/
MOZ_NEVER_INLINE_DEBUG char16_t Char() const {
MOZ_ASSERT(IsSetAndValid());
MOZ_ASSERT(!IsEndOfContainer());
return ContainerAs<dom::Text>()->TextFragment().CharAt(mOffset.value());
}
MOZ_NEVER_INLINE_DEBUG bool IsCharASCIISpace() const {
return nsCRT::IsAsciiSpace(Char());
}
MOZ_NEVER_INLINE_DEBUG bool IsCharNBSP() const { return Char() == 0x00A0; }
MOZ_NEVER_INLINE_DEBUG bool IsCharASCIISpaceOrNBSP() const {
char16_t ch = Char();
return nsCRT::IsAsciiSpace(ch) || ch == 0x00A0;
}
MOZ_NEVER_INLINE_DEBUG bool IsCharNewLine() const { return Char() == '\n'; }
MOZ_NEVER_INLINE_DEBUG bool IsCharPreformattedNewLine() const;
MOZ_NEVER_INLINE_DEBUG bool
IsCharPreformattedNewLineCollapsedWithWhiteSpaces() const;
/**
* IsCharCollapsibleASCIISpace(), IsCharCollapsibleNBSP() and
* IsCharCollapsibleASCIISpaceOrNBSP() checks whether the white-space is
* preformatted or collapsible with the style of the container text node
* without flushing pending notifications.
*/
bool IsCharCollapsibleASCIISpace() const;
bool IsCharCollapsibleNBSP() const;
bool IsCharCollapsibleASCIISpaceOrNBSP() const;
MOZ_NEVER_INLINE_DEBUG bool IsCharHighSurrogateFollowedByLowSurrogate()
const {
MOZ_ASSERT(IsSetAndValid());
MOZ_ASSERT(!IsEndOfContainer());
return ContainerAs<dom::Text>()
->TextFragment()
.IsHighSurrogateFollowedByLowSurrogateAt(mOffset.value());
}
MOZ_NEVER_INLINE_DEBUG bool IsCharLowSurrogateFollowingHighSurrogate() const {
MOZ_ASSERT(IsSetAndValid());
MOZ_ASSERT(!IsEndOfContainer());
return ContainerAs<dom::Text>()
->TextFragment()
.IsLowSurrogateFollowingHighSurrogateAt(mOffset.value());
}
MOZ_NEVER_INLINE_DEBUG char16_t PreviousChar() const {
MOZ_ASSERT(IsSetAndValid());
MOZ_ASSERT(!IsStartOfContainer());
return ContainerAs<dom::Text>()->TextFragment().CharAt(mOffset.value() - 1);
}
MOZ_NEVER_INLINE_DEBUG bool IsPreviousCharASCIISpace() const {
return nsCRT::IsAsciiSpace(PreviousChar());
}
MOZ_NEVER_INLINE_DEBUG bool IsPreviousCharNBSP() const {
return PreviousChar() == 0x00A0;
}
MOZ_NEVER_INLINE_DEBUG bool IsPreviousCharASCIISpaceOrNBSP() const {
char16_t ch = PreviousChar();
return nsCRT::IsAsciiSpace(ch) || ch == 0x00A0;
}
MOZ_NEVER_INLINE_DEBUG bool IsPreviousCharNewLine() const {
return PreviousChar() == '\n';
}
MOZ_NEVER_INLINE_DEBUG bool IsPreviousCharPreformattedNewLine() const;
MOZ_NEVER_INLINE_DEBUG bool
IsPreviousCharPreformattedNewLineCollapsedWithWhiteSpaces() const;
/**
* IsPreviousCharCollapsibleASCIISpace(), IsPreviousCharCollapsibleNBSP() and
* IsPreviousCharCollapsibleASCIISpaceOrNBSP() checks whether the white-space
* is preformatted or collapsible with the style of the container text node
* without flushing pending notifications.
*/
bool IsPreviousCharCollapsibleASCIISpace() const;
bool IsPreviousCharCollapsibleNBSP() const;
bool IsPreviousCharCollapsibleASCIISpaceOrNBSP() const;
MOZ_NEVER_INLINE_DEBUG char16_t NextChar() const {
MOZ_ASSERT(IsSetAndValid());
MOZ_ASSERT(!IsAtLastContent() && !IsEndOfContainer());
return ContainerAs<dom::Text>()->TextFragment().CharAt(mOffset.value() + 1);
}
MOZ_NEVER_INLINE_DEBUG bool IsNextCharASCIISpace() const {
return nsCRT::IsAsciiSpace(NextChar());
}
MOZ_NEVER_INLINE_DEBUG bool IsNextCharNBSP() const {
return NextChar() == 0x00A0;
}
MOZ_NEVER_INLINE_DEBUG bool IsNextCharASCIISpaceOrNBSP() const {
char16_t ch = NextChar();
return nsCRT::IsAsciiSpace(ch) || ch == 0x00A0;
}
MOZ_NEVER_INLINE_DEBUG bool IsNextCharNewLine() const {
return NextChar() == '\n';
}
MOZ_NEVER_INLINE_DEBUG bool IsNextCharPreformattedNewLine() const;
MOZ_NEVER_INLINE_DEBUG bool
IsNextCharPreformattedNewLineCollapsedWithWhiteSpaces() const;
/**
* IsNextCharCollapsibleASCIISpace(), IsNextCharCollapsibleNBSP() and
* IsNextCharCollapsibleASCIISpaceOrNBSP() checks whether the white-space is
* preformatted or collapsible with the style of the container text node
* without flushing pending notifications.
*/
bool IsNextCharCollapsibleASCIISpace() const;
bool IsNextCharCollapsibleNBSP() const;
bool IsNextCharCollapsibleASCIISpaceOrNBSP() const;
[[nodiscard]] bool HasOffset() const { return mOffset.isSome(); }
uint32_t Offset() const {
if (mOffset.isSome()) {
MOZ_ASSERT(mOffset.isSome());
return mOffset.value();
}
if (MOZ_UNLIKELY(!mParent)) {
MOZ_ASSERT(!mChild);
return 0u;
}
MOZ_ASSERT(mParent->IsContainerNode(),
"If the container cannot have children, mOffset.isSome() should "
"be true");
if (!mChild) {
// We're referring after the last child. Fix offset now.
const_cast<SelfType*>(this)->mOffset = mozilla::Some(mParent->Length());
return mOffset.value();
}
MOZ_ASSERT(mChild->GetParentNode() == mParent);
// Fix offset now.
if (mChild == mParent->GetFirstChild()) {
const_cast<SelfType*>(this)->mOffset = mozilla::Some(0u);
return 0u;
}
const_cast<SelfType*>(this)->mOffset = mParent->ComputeIndexOf(mChild);
MOZ_DIAGNOSTIC_ASSERT(mOffset.isSome());
return mOffset.valueOr(0u); // Avoid crash in Release/Beta
}
/**
* Set() sets a point to aOffset or aChild.
* If it's set with aOffset, mChild is invalidated. If it's set with aChild,
* mOffset may be invalidated.
*/
template <typename ContainerType>
void Set(ContainerType* aContainer, uint32_t aOffset) {
mParent = aContainer;
mChild = nullptr;
mOffset = mozilla::Some(aOffset);
mIsChildInitialized = false;
mInterlinePosition = InterlinePosition::Undefined;
NS_ASSERTION(!mParent || mOffset.value() <= mParent->Length(),
"The offset is out of bounds");
}
template <typename ContainerType, template <typename> typename StrongPtr>
void Set(const StrongPtr<ContainerType>& aContainer, uint32_t aOffset) {
Set(aContainer.get(), aOffset);
}
void Set(const nsINode* aChild) {
MOZ_ASSERT(aChild);
if (NS_WARN_IF(!aChild->IsContent())) {
Clear();
return;
}
mParent = aChild->GetParentNode();
mChild = const_cast<nsIContent*>(aChild->AsContent());
mOffset.reset();
mIsChildInitialized = true;
mInterlinePosition = InterlinePosition::Undefined;
}
/**
* SetToEndOf() sets this to the end of aContainer. Then, mChild is always
* nullptr but marked as initialized and mOffset is always set.
*/
template <typename ContainerType>
MOZ_NEVER_INLINE_DEBUG void SetToEndOf(const ContainerType* aContainer) {
MOZ_ASSERT(aContainer);
mParent = const_cast<ContainerType*>(aContainer);
mChild = nullptr;
mOffset = mozilla::Some(mParent->Length());
mIsChildInitialized = true;
mInterlinePosition = InterlinePosition::Undefined;
}
template <typename ContainerType, template <typename> typename StrongPtr>
MOZ_NEVER_INLINE_DEBUG void SetToEndOf(
const StrongPtr<ContainerType>& aContainer) {
SetToEndOf(aContainer.get());
}
template <typename ContainerType>
MOZ_NEVER_INLINE_DEBUG static SelfType AtEndOf(
const ContainerType& aContainer,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined) {
SelfType point;
point.SetToEndOf(&aContainer);
point.mInterlinePosition = aInterlinePosition;
return point;
}
template <typename ContainerType, template <typename> typename StrongPtr>
MOZ_NEVER_INLINE_DEBUG static SelfType AtEndOf(
const StrongPtr<ContainerType>& aContainer,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined) {
MOZ_ASSERT(aContainer.get());
return AtEndOf(*aContainer.get(), aInterlinePosition);
}
/**
* SetAfter() sets mChild to next sibling of aChild.
*/
void SetAfter(const nsINode* aChild) {
MOZ_ASSERT(aChild);
nsIContent* nextSibling = aChild->GetNextSibling();
if (nextSibling) {
Set(nextSibling);
return;
}
nsINode* parentNode = aChild->GetParentNode();
if (NS_WARN_IF(!parentNode)) {
Clear();
return;
}
SetToEndOf(parentNode);
}
template <typename ContainerType>
static SelfType After(
const ContainerType& aContainer,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined) {
SelfType point;
point.SetAfter(&aContainer);
point.mInterlinePosition = aInterlinePosition;
return point;
}
template <typename ContainerType, template <typename> typename StrongPtr>
MOZ_NEVER_INLINE_DEBUG static SelfType After(
const StrongPtr<ContainerType>& aContainer,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined) {
MOZ_ASSERT(aContainer.get());
return After(*aContainer.get(), aInterlinePosition);
}
template <typename PT, typename CT>
MOZ_NEVER_INLINE_DEBUG static SelfType After(
const EditorDOMPointBase<PT, CT>& aPoint,
InterlinePosition aInterlinePosition = InterlinePosition::Undefined) {
MOZ_ASSERT(aPoint.IsSet());
if (aPoint.mChild) {
return After(*aPoint.mChild, aInterlinePosition);
}
if (NS_WARN_IF(aPoint.IsEndOfContainer())) {
return SelfType();
}
auto point = aPoint.NextPoint().template To<SelfType>();
point.mInterlinePosition = aInterlinePosition;
return point;
}
/**
* ParentPoint() returns a point whose child is the container.
*/
template <typename EditorDOMPointType = SelfType>
EditorDOMPointType ParentPoint() const {
MOZ_ASSERT(mParent);
if (MOZ_UNLIKELY(!mParent) || !mParent->IsContent()) {
return EditorDOMPointType();
}
return EditorDOMPointType(ContainerAs<nsIContent>());
}
/**
* NextPoint() and PreviousPoint() returns next/previous DOM point in
* the container.
*/
template <typename EditorDOMPointType = SelfType>
EditorDOMPointType NextPoint() const {
NS_ASSERTION(!IsEndOfContainer(), "Should not be at end of the container");
auto result = this->template To<EditorDOMPointType>();
result.AdvanceOffset();
return result;
}
template <typename EditorDOMPointType = SelfType>
EditorDOMPointType PreviousPoint() const {
NS_ASSERTION(!IsStartOfContainer(),
"Should not be at start of the container");
EditorDOMPointType result = this->template To<EditorDOMPointType>();
result.RewindOffset();
return result;
}
/**
* Clear() makes the instance not point anywhere.
*/
void Clear() {
mParent = nullptr;
mChild = nullptr;
mOffset.reset();
mIsChildInitialized = false;
mInterlinePosition = InterlinePosition::Undefined;
}
/**
* AdvanceOffset() tries to refer next sibling of mChild and/of next offset.
* If the container can have children and there is no next sibling or the
* offset reached the length of the container, this outputs warning and does
* nothing. So, callers need to check if there is next sibling which you
* need to refer.
*
* @return true if there is a next DOM point to refer.
*/
bool AdvanceOffset() {
if (NS_WARN_IF(!mParent)) {
return false;
}
// If only mOffset is available, just compute the offset.
if ((mOffset.isSome() && !mIsChildInitialized) ||
!mParent->IsContainerNode()) {
MOZ_ASSERT(mOffset.isSome());
MOZ_ASSERT(!mChild);
if (NS_WARN_IF(mOffset.value() >= mParent->Length())) {
// We're already referring the start of the container.
return false;
}
mOffset = mozilla::Some(mOffset.value() + 1);
mInterlinePosition = InterlinePosition::Undefined;
return true;
}
MOZ_ASSERT(mIsChildInitialized);
MOZ_ASSERT(!mOffset.isSome() || mOffset.isSome());
if (NS_WARN_IF(!mParent->HasChildren()) || NS_WARN_IF(!mChild) ||
NS_WARN_IF(mOffset.isSome() && mOffset.value() >= mParent->Length())) {
// We're already referring the end of the container (or outside).
return false;
}
if (mOffset.isSome()) {
MOZ_ASSERT(mOffset.isSome());
mOffset = mozilla::Some(mOffset.value() + 1);
}
mChild = mChild->GetNextSibling();
mInterlinePosition = InterlinePosition::Undefined;
return true;
}
/**
* RewindOffset() tries to refer previous sibling of mChild and/or previous
* offset. If the container can have children and there is no next previous
* or the offset is 0, this outputs warning and does nothing. So, callers
* need to check if there is previous sibling which you need to refer.
*
* @return true if there is a previous DOM point to refer.
*/
bool RewindOffset() {
if (NS_WARN_IF(!mParent)) {
return false;
}
// If only mOffset is available, just compute the offset.
if ((mOffset.isSome() && !mIsChildInitialized) ||
!mParent->IsContainerNode()) {
MOZ_ASSERT(mOffset.isSome());
MOZ_ASSERT(!mChild);
if (NS_WARN_IF(!mOffset.value()) ||
NS_WARN_IF(mOffset.value() > mParent->Length())) {
// We're already referring the start of the container or
// the offset is invalid since perhaps, the offset was set before
// the last DOM tree change.
NS_ASSERTION(false, "Failed to rewind offset");
return false;
}
mOffset = mozilla::Some(mOffset.value() - 1);
mInterlinePosition = InterlinePosition::Undefined;
return true;
}
MOZ_ASSERT(mIsChildInitialized);
MOZ_ASSERT(!mOffset.isSome() || mOffset.isSome());
if (NS_WARN_IF(!mParent->HasChildren()) ||
NS_WARN_IF(mChild && !mChild->GetPreviousSibling()) ||
NS_WARN_IF(mOffset.isSome() && !mOffset.value())) {
// We're already referring the start of the container (or the child has
// been moved from the container?).
return false;
}
nsIContent* previousSibling =
mChild ? mChild->GetPreviousSibling() : mParent->GetLastChild();
if (NS_WARN_IF(!previousSibling)) {
// We're already referring the first child of the container.
return false;
}
if (mOffset.isSome()) {
mOffset = mozilla::Some(mOffset.value() - 1);
}
mChild = previousSibling;
mInterlinePosition = InterlinePosition::Undefined;
return true;
}
/**
* GetNonAnonymousSubtreePoint() returns a DOM point which is NOT in
* native-anonymous subtree. If the instance isn't in native-anonymous
* subtree, this returns same point. Otherwise, climbs up until finding
* non-native-anonymous parent and returns the point of it. I.e.,
* container is parent of the found non-anonymous-native node.
*/
template <typename EditorDOMPointType>
EditorDOMPointType GetNonAnonymousSubtreePoint() const {
if (NS_WARN_IF(!IsSet())) {
return EditorDOMPointType();
}
if (!IsInNativeAnonymousSubtree()) {
return this->template To<EditorDOMPointType>();
}
nsINode* parent;
for (parent = mParent->GetParentNode();
parent && parent->IsInNativeAnonymousSubtree();
parent = parent->GetParentNode()) {
}
if (!parent) {
return EditorDOMPointType();
}
return EditorDOMPointType(parent);
}
[[nodiscard]] bool IsSet() const {
return mParent && (mIsChildInitialized || mOffset.isSome());
}
[[nodiscard]] bool IsSetAndValid() const {
if (!IsSet()) {
return false;
}
if (mChild &&
(mChild->GetParentNode() != mParent || mChild->IsBeingRemoved())) {
return false;
}
if (mOffset.isSome() && mOffset.value() > mParent->Length()) {
return false;
}
return true;
}
[[nodiscard]] bool IsInComposedDoc() const {
return IsSet() && mParent->IsInComposedDoc();
}
[[nodiscard]] bool IsSetAndValidInComposedDoc() const {
return IsInComposedDoc() && IsSetAndValid();
}
bool IsStartOfContainer() const {
// If we're referring the first point in the container:
// If mParent is not a container like a text node, mOffset is 0.
// If mChild is initialized and it's first child of mParent.
// If mChild isn't initialized and the offset is 0.
if (NS_WARN_IF(!mParent)) {
return false;
}
if (!mParent->IsContainerNode()) {
return !mOffset.value();
}
if (mIsChildInitialized) {
if (mParent->GetFirstChild() == mChild) {
NS_WARNING_ASSERTION(!mOffset.isSome() || !mOffset.value(),
"If mOffset was initialized, it should be 0");
return true;
}
NS_WARNING_ASSERTION(!mOffset.isSome() || mParent->GetChildAt_Deprecated(
mOffset.value()) == mChild,
"mOffset and mChild are mismatched");
return false;
}
MOZ_ASSERT(mOffset.isSome());
return !mOffset.value();
}
bool IsEndOfContainer() const {
// If we're referring after the last point of the container:
// If mParent is not a container like text node, mOffset is same as the
// length of the container.
// If mChild is initialized and it's nullptr.
// If mChild isn't initialized and mOffset is same as the length of the
// container.
if (NS_WARN_IF(!mParent)) {
return false;
}
if (!mParent->IsContainerNode()) {
return mOffset.value() == mParent->Length();
}
if (mIsChildInitialized) {
if (!mChild) {
NS_WARNING_ASSERTION(
!mOffset.isSome() || mOffset.value() == mParent->Length(),
"If mOffset was initialized, it should be length of the container");
return true;
}
NS_WARNING_ASSERTION(!mOffset.isSome() || mParent->GetChildAt_Deprecated(
mOffset.value()) == mChild,
"mOffset and mChild are mismatched");
return false;
}
MOZ_ASSERT(mOffset.isSome());
return mOffset.value() == mParent->Length();
}
/**
* IsAtLastContent() returns true when it refers last child of the container
* or last character offset of text node.
*/
bool IsAtLastContent() const {
if (NS_WARN_IF(!mParent)) {
return false;
}
if (mParent->IsContainerNode() && mOffset.isSome()) {
return mOffset.value() == mParent->Length() - 1;
}
if (mIsChildInitialized) {
if (mChild && mChild == mParent->GetLastChild()) {
NS_WARNING_ASSERTION(
!mOffset.isSome() || mOffset.value() == mParent->Length() - 1,
"If mOffset was initialized, it should be length - 1 of the "
"container");
return true;
}
NS_WARNING_ASSERTION(!mOffset.isSome() || mParent->GetChildAt_Deprecated(
mOffset.value()) == mChild,
"mOffset and mChild are mismatched");
return false;
}
MOZ_ASSERT(mOffset.isSome());
return mOffset.value() == mParent->Length() - 1;
}
bool IsBRElementAtEndOfContainer() const {
if (NS_WARN_IF(!mParent)) {
return false;
}
if (!mParent->IsContainerNode()) {
return false;
}
const_cast<SelfType*>(this)->EnsureChild();
if (!mChild || mChild->GetNextSibling()) {
return false;
}
return mChild->IsHTMLElement(nsGkAtoms::br);
}
template <typename A, typename B>
EditorDOMPointBase& operator=(const RangeBoundaryBase<A, B>& aOther) {
mParent = aOther.mParent;
mChild = aOther.mRef ? aOther.mRef->GetNextSibling()
: (aOther.mParent && aOther.mParent->IsContainerNode()
? aOther.mParent->GetFirstChild()
: nullptr);
mOffset = aOther.mOffset;
mIsChildInitialized =
aOther.mRef || (aOther.mParent && !aOther.mParent->IsContainerNode()) ||
(aOther.mOffset.isSome() && !aOther.mOffset.value());
mInterlinePosition = InterlinePosition::Undefined;
return *this;
}
template <typename EditorDOMPointType>
constexpr EditorDOMPointType To() const {
// XXX Cannot specialize this method due to implicit instantiatation caused
// by the inline CC functions below.
if (std::is_same<SelfType, EditorDOMPointType>::value) {
return reinterpret_cast<const EditorDOMPointType&>(*this);
}
EditorDOMPointType result;
result.mParent = mParent;
result.mChild = mChild;
result.mOffset = mOffset;
result.mIsChildInitialized = mIsChildInitialized;
result.mInterlinePosition = mInterlinePosition;
return result;
}
/**
* Don't compare mInterlinePosition. If it's required to check, perhaps,
* another compare operator like `===` should be created.
*/
template <typename A, typename B>
bool operator==(const EditorDOMPointBase<A, B>& aOther) const {
if (mParent != aOther.mParent) {
return false;
}
if (mOffset.isSome() && aOther.mOffset.isSome()) {
// If both mOffset are set, we need to compare both mRef too because
// the relation of mRef and mOffset have already broken by DOM tree
// changes.
if (mOffset != aOther.mOffset) {
return false;
}
if (mChild == aOther.mChild) {
return true;
}
if (NS_WARN_IF(mIsChildInitialized && aOther.mIsChildInitialized)) {
// In this case, relation between mChild and mOffset of one of or both
// of them doesn't match with current DOM tree since the DOM tree might
// have been changed after computing mChild or mOffset.
return false;
}
// If one of mChild hasn't been computed yet, we should compare them only
// with mOffset. Perhaps, we shouldn't copy mChild from non-nullptr one
// to the other since if we copy it here, it may be unexpected behavior
// for some callers.
return true;
}
MOZ_ASSERT(mIsChildInitialized || aOther.mIsChildInitialized);
if (mOffset.isSome() && !mIsChildInitialized && !aOther.mOffset.isSome() &&
aOther.mIsChildInitialized) {
// If this has only mOffset and the other has only mChild, this needs to
// compute mChild now.
const_cast<SelfType*>(this)->EnsureChild();
return mChild == aOther.mChild;
}
if (!mOffset.isSome() && mIsChildInitialized && aOther.mOffset.isSome() &&
!aOther.mIsChildInitialized) {
// If this has only mChild and the other has only mOffset, the other needs
// to compute mChild now.
const_cast<EditorDOMPointBase<A, B>&>(aOther).EnsureChild();
return mChild == aOther.mChild;
}
// If mOffset of one of them hasn't been computed from mChild yet, we should
// compare only with mChild. Perhaps, we shouldn't copy mOffset from being
// some one to not being some one since if we copy it here, it may be
// unexpected behavior for some callers.
return mChild == aOther.mChild;
}
template <typename A, typename B>
bool operator==(const RangeBoundaryBase<A, B>& aOther) const {
// TODO: Optimize this with directly comparing with RangeBoundaryBase
// members.
return *this == SelfType(aOther);
}
template <typename A, typename B>
bool operator!=(const EditorDOMPointBase<A, B>& aOther) const {
return !(*this == aOther);
}
template <typename A, typename B>
bool operator!=(const RangeBoundaryBase<A, B>& aOther) const {
return !(*this == aOther);
}
/**
* This operator should be used if API of other modules take RawRangeBoundary,
* e.g., methods of Selection and nsRange.
*/
operator const RawRangeBoundary() const { return ToRawRangeBoundary(); }
const RawRangeBoundary ToRawRangeBoundary() const {
if (!IsSet() || NS_WARN_IF(!mIsChildInitialized && !mOffset.isSome())) {
return RawRangeBoundary();
}
if (!mParent->IsContainerNode()) {
MOZ_ASSERT(mOffset.value() <= mParent->Length());
// If the container is a data node like a text node, we need to create
// RangeBoundaryBase instance only with mOffset because mChild is always
// nullptr.
return RawRangeBoundary(mParent, mOffset.value());
}
if (mIsChildInitialized && mOffset.isSome()) {
// If we've already set both child and offset, we should create
// RangeBoundary with offset after validation.
#ifdef DEBUG
if (mChild) {
MOZ_ASSERT(mParent == mChild->GetParentNode());
MOZ_ASSERT(mParent->GetChildAt_Deprecated(mOffset.value()) == mChild);
} else {
MOZ_ASSERT(mParent->Length() == mOffset.value());
}
#endif // #ifdef DEBUG
return RawRangeBoundary(mParent, mOffset.value());
}
// Otherwise, we should create RangeBoundaryBase only with available
// information.
if (mOffset.isSome()) {
return RawRangeBoundary(mParent, mOffset.value());
}
if (mChild) {
return RawRangeBoundary(mParent, mChild->GetPreviousSibling());
}
return RawRangeBoundary(mParent, mParent->GetLastChild());
}
already_AddRefed<nsRange> CreateCollapsedRange(ErrorResult& aRv) const {
const RawRangeBoundary boundary = ToRawRangeBoundary();
RefPtr<nsRange> range = nsRange::Create(boundary, boundary, aRv);
if (MOZ_UNLIKELY(aRv.Failed() || !range)) {
return nullptr;
}
return range.forget();
}
EditorDOMPointInText GetAsInText() const {
return IsInTextNode() ? EditorDOMPointInText(ContainerAs<dom::Text>(),
Offset(), mInterlinePosition)
: EditorDOMPointInText();
}
MOZ_NEVER_INLINE_DEBUG EditorDOMPointInText AsInText() const {
MOZ_ASSERT(IsInTextNode());
return EditorDOMPointInText(ContainerAs<dom::Text>(), Offset(),
mInterlinePosition);
}
template <typename A, typename B>
bool IsBefore(const EditorDOMPointBase<A, B>& aOther) const {
if (!IsSetAndValid() || !aOther.IsSetAndValid()) {
return false;
}
Maybe<int32_t> comp = nsContentUtils::ComparePoints(
ToRawRangeBoundary(), aOther.ToRawRangeBoundary());
return comp.isSome() && comp.value() == -1;
}
template <typename A, typename B>
bool EqualsOrIsBefore(const EditorDOMPointBase<A, B>& aOther) const {
if (!IsSetAndValid() || !aOther.IsSetAndValid()) {
return false;
}
Maybe<int32_t> comp = nsContentUtils::ComparePoints(
ToRawRangeBoundary(), aOther.ToRawRangeBoundary());
return comp.isSome() && comp.value() <= 0;
}
friend std::ostream& operator<<(std::ostream& aStream,
const SelfType& aDOMPoint) {
aStream << "{ mParent=" << aDOMPoint.GetContainer();
if (aDOMPoint.mParent) {
aStream << " (" << *aDOMPoint.mParent
<< ", Length()=" << aDOMPoint.mParent->Length() << ")";
}
aStream << ", mChild=" << static_cast<nsIContent*>(aDOMPoint.mChild);
if (aDOMPoint.mChild) {
aStream << " (" << *aDOMPoint.mChild << ")";
}
aStream << ", mOffset=" << aDOMPoint.mOffset << ", mIsChildInitialized="
<< (aDOMPoint.mIsChildInitialized ? "true" : "false")
<< ", mInterlinePosition=" << aDOMPoint.mInterlinePosition << " }";
return aStream;
}
private:
void EnsureChild() {
if (mIsChildInitialized) {
return;
}
if (!mParent) {
MOZ_ASSERT(!mOffset.isSome());
return;
}
MOZ_ASSERT(mOffset.isSome());
MOZ_ASSERT(mOffset.value() <= mParent->Length());
mIsChildInitialized = true;
if (!mParent->IsContainerNode()) {
return;
}
mChild = mParent->GetChildAt_Deprecated(mOffset.value());
MOZ_ASSERT(mChild || mOffset.value() == mParent->Length());
}
ParentType mParent = nullptr;
ChildType mChild = nullptr;
Maybe<uint32_t> mOffset;
InterlinePosition mInterlinePosition = InterlinePosition::Undefined;
bool mIsChildInitialized = false;
template <typename PT, typename CT>
friend class EditorDOMPointBase;
friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
EditorDOMPoint&, const char*,
uint32_t);
friend void ImplCycleCollectionUnlink(EditorDOMPoint&);
};
inline void ImplCycleCollectionUnlink(EditorDOMPoint& aField) {
ImplCycleCollectionUnlink(aField.mParent);
ImplCycleCollectionUnlink(aField.mChild);
}
inline void ImplCycleCollectionTraverse(
nsCycleCollectionTraversalCallback& aCallback, EditorDOMPoint& aField,
const char* aName, uint32_t aFlags) {
ImplCycleCollectionTraverse(aCallback, aField.mParent, "mParent", 0);
ImplCycleCollectionTraverse(aCallback, aField.mChild, "mChild", 0);
}
/**
* EditorDOMRangeBase class stores a pair of same EditorDOMPointBase type.
* The instance must be created with valid DOM points and start must be
* before or same as end.
*/
#define NS_INSTANTIATE_EDITOR_DOM_RANGE_METHOD(aResultType, aMethodName, ...) \
template aResultType EditorDOMRange::aMethodName(__VA_ARGS__); \
template aResultType EditorRawDOMRange::aMethodName(__VA_ARGS__); \
template aResultType EditorDOMRangeInTexts::aMethodName(__VA_ARGS__); \
template aResultType EditorRawDOMRangeInTexts::aMethodName(__VA_ARGS__)
#define NS_INSTANTIATE_EDITOR_DOM_RANGE_CONST_METHOD(aResultType, aMethodName, \
...) \
template aResultType EditorDOMRange::aMethodName(__VA_ARGS__) const; \
template aResultType EditorRawDOMRange::aMethodName(__VA_ARGS__) const; \
template aResultType EditorDOMRangeInTexts::aMethodName(__VA_ARGS__) const; \
template aResultType EditorRawDOMRangeInTexts::aMethodName(__VA_ARGS__) const
template <typename EditorDOMPointType>
class EditorDOMRangeBase final {
public:
using PointType = EditorDOMPointType;
EditorDOMRangeBase() = default;
template <typename PT, typename CT>
explicit EditorDOMRangeBase(const EditorDOMPointBase<PT, CT>& aStart)
: mStart(aStart), mEnd(aStart) {
MOZ_ASSERT(!mStart.IsSet() || mStart.IsSetAndValid());
}
template <typename StartPointType, typename EndPointType>
explicit EditorDOMRangeBase(const StartPointType& aStart,
const EndPointType& aEnd)
: mStart(aStart.template To<PointType>()),
mEnd(aEnd.template To<PointType>()) {
MOZ_ASSERT_IF(mStart.IsSet(), mStart.IsSetAndValid());
MOZ_ASSERT_IF(mEnd.IsSet(), mEnd.IsSetAndValid());
MOZ_ASSERT_IF(mStart.IsSet() && mEnd.IsSet(),
mStart.EqualsOrIsBefore(mEnd));
}
explicit EditorDOMRangeBase(EditorDOMPointType&& aStart,
EditorDOMPointType&& aEnd)
: mStart(std::move(aStart)), mEnd(std::move(aEnd)) {
MOZ_ASSERT_IF(mStart.IsSet(), mStart.IsSetAndValid());
MOZ_ASSERT_IF(mEnd.IsSet(), mEnd.IsSetAndValid());
MOZ_ASSERT_IF(mStart.IsSet() && mEnd.IsSet(),
mStart.EqualsOrIsBefore(mEnd));
}
template <typename OtherPointType>
explicit EditorDOMRangeBase(const EditorDOMRangeBase<OtherPointType>& aOther)
: mStart(aOther.StartRef().template To<PointType>()),
mEnd(aOther.EndRef().template To<PointType>()) {
MOZ_ASSERT_IF(mStart.IsSet(), mStart.IsSetAndValid());
MOZ_ASSERT_IF(mEnd.IsSet(), mEnd.IsSetAndValid());
MOZ_ASSERT(mStart.IsSet() == mEnd.IsSet());
}
explicit EditorDOMRangeBase(const dom::AbstractRange& aRange)
: mStart(aRange.StartRef()), mEnd(aRange.EndRef()) {
MOZ_ASSERT_IF(mStart.IsSet(), mStart.IsSetAndValid());
MOZ_ASSERT_IF(mEnd.IsSet(), mEnd.IsSetAndValid());
MOZ_ASSERT_IF(mStart.IsSet() && mEnd.IsSet(),
mStart.EqualsOrIsBefore(mEnd));
}
template <typename MaybeOtherPointType>
void SetStart(const MaybeOtherPointType& aStart) {
mStart = aStart.template To<PointType>();
}
void SetStart(PointType&& aStart) { mStart = std::move(aStart); }
template <typename MaybeOtherPointType>
void SetEnd(const MaybeOtherPointType& aEnd) {
mEnd = aEnd.template To<PointType>();
}
void SetEnd(PointType&& aEnd) { mEnd = std::move(aEnd); }
template <typename StartPointType, typename EndPointType>
void SetStartAndEnd(const StartPointType& aStart, const EndPointType& aEnd) {
MOZ_ASSERT_IF(aStart.IsSet() && aEnd.IsSet(),
aStart.EqualsOrIsBefore(aEnd));
mStart = aStart.template To<PointType>();
mEnd = aEnd.template To<PointType>();
}
template <typename StartPointType>
void SetStartAndEnd(const StartPointType& aStart, PointType&& aEnd) {
MOZ_ASSERT_IF(aStart.IsSet() && aEnd.IsSet(),
aStart.EqualsOrIsBefore(aEnd));
mStart = aStart.template To<PointType>();
mEnd = std::move(aEnd);
}
template <typename EndPointType>
void SetStartAndEnd(PointType&& aStart, const EndPointType& aEnd) {
MOZ_ASSERT_IF(aStart.IsSet() && aEnd.IsSet(),
aStart.EqualsOrIsBefore(aEnd));
mStart = std::move(aStart);
mEnd = aEnd.template To<PointType>();
}
void SetStartAndEnd(PointType&& aStart, PointType&& aEnd) {
MOZ_ASSERT_IF(aStart.IsSet() && aEnd.IsSet(),
aStart.EqualsOrIsBefore(aEnd));
mStart = std::move(aStart);
mEnd = std::move(aEnd);
}
void Clear() {
mStart.Clear();
mEnd.Clear();
}
const PointType& StartRef() const { return mStart; }
const PointType& EndRef() const { return mEnd; }
bool Collapsed() const {
MOZ_ASSERT(IsPositioned());
return mStart == mEnd;
}
bool IsPositioned() const { return mStart.IsSet() && mEnd.IsSet(); }
bool IsPositionedAndValid() const {
return mStart.IsSetAndValid() && mEnd.IsSetAndValid() &&
mStart.EqualsOrIsBefore(mEnd);
}
template <typename OtherPointType>
MOZ_NEVER_INLINE_DEBUG bool Contains(const OtherPointType& aPoint) const {
MOZ_ASSERT(aPoint.IsSetAndValid());
return IsPositioned() && aPoint.IsSet() &&
mStart.EqualsOrIsBefore(aPoint) && aPoint.IsBefore(mEnd);
}
[[nodiscard]] nsINode* GetClosestCommonInclusiveAncestor() const;
bool InSameContainer() const {
MOZ_ASSERT(IsPositioned());
return IsPositioned() && mStart.GetContainer() == mEnd.GetContainer();
}
bool InAdjacentSiblings() const {
MOZ_ASSERT(IsPositioned());
return IsPositioned() &&
mStart.GetContainer()->GetNextSibling() == mEnd.GetContainer();
}
bool IsInContentNodes() const {
MOZ_ASSERT(IsPositioned());
return IsPositioned() && mStart.IsInContentNode() && mEnd.IsInContentNode();
}
bool IsInTextNodes() const {
MOZ_ASSERT(IsPositioned());
return IsPositioned() && mStart.IsInTextNode() && mEnd.IsInTextNode();
}
template <typename OtherRangeType>
bool operator==(const OtherRangeType& aOther) const {
return (!IsPositioned() && !aOther.IsPositioned()) ||
(mStart == aOther.mStart && mEnd == aOther.mEnd);
}
template <typename OtherRangeType>
bool operator!=(const OtherRangeType& aOther) const {
return !(*this == aOther);
}
EditorDOMRangeInTexts GetAsInTexts() const {
return IsInTextNodes()
? EditorDOMRangeInTexts(mStart.AsInText(), mEnd.AsInText())
: EditorDOMRangeInTexts();
}
MOZ_NEVER_INLINE_DEBUG EditorDOMRangeInTexts AsInTexts() const {
MOZ_ASSERT(IsInTextNodes());
return EditorDOMRangeInTexts(mStart.AsInText(), mEnd.AsInText());
}
bool EnsureNotInNativeAnonymousSubtree() {
if (mStart.IsInNativeAnonymousSubtree()) {
nsIContent* parent = nullptr;
for (parent = mStart.template ContainerAs<nsIContent>()
->GetClosestNativeAnonymousSubtreeRootParentOrHost();
parent && parent->IsInNativeAnonymousSubtree();
parent =
parent->GetClosestNativeAnonymousSubtreeRootParentOrHost()) {
}
if (MOZ_UNLIKELY(!parent)) {
return false;
}
mStart.Set(parent);
}
if (mEnd.IsInNativeAnonymousSubtree()) {
nsIContent* parent = nullptr;
for (parent = mEnd.template ContainerAs<nsIContent>()
->GetClosestNativeAnonymousSubtreeRootParentOrHost();
parent && parent->IsInNativeAnonymousSubtree();
parent =
parent->GetClosestNativeAnonymousSubtreeRootParentOrHost()) {
}
if (MOZ_UNLIKELY(!parent)) {
return false;
}
mEnd.SetAfter(parent);
}
return true;
}
already_AddRefed<nsRange> CreateRange(ErrorResult& aRv) const {
RefPtr<nsRange> range = nsRange::Create(mStart.ToRawRangeBoundary(),
mEnd.ToRawRangeBoundary(), aRv);
if (MOZ_UNLIKELY(aRv.Failed() || !range)) {
return nullptr;
}
return range.forget();
}
private:
EditorDOMPointType mStart;
EditorDOMPointType mEnd;
friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
EditorDOMRange&, const char*,
uint32_t);
friend void ImplCycleCollectionUnlink(EditorDOMRange&);
};
inline void ImplCycleCollectionUnlink(EditorDOMRange& aField) {
ImplCycleCollectionUnlink(aField.mStart);
ImplCycleCollectionUnlink(aField.mEnd);
}
inline void ImplCycleCollectionTraverse(
nsCycleCollectionTraversalCallback& aCallback, EditorDOMRange& aField,
const char* aName, uint32_t aFlags) {
ImplCycleCollectionTraverse(aCallback, aField.mStart, "mStart", 0);
ImplCycleCollectionTraverse(aCallback, aField.mEnd, "mEnd", 0);
}
/**
* AutoEditorDOMPointOffsetInvalidator is useful if DOM tree will be changed
* when EditorDOMPoint instance is available and keeps referring same child
* node.
*
* This class automatically guarantees that given EditorDOMPoint instance
* stores the child node and invalidates its offset when the instance is
* destroyed. Additionally, users of this class can invalidate the offset
* manually when they need.
*/
class MOZ_STACK_CLASS AutoEditorDOMPointOffsetInvalidator final {
public:
AutoEditorDOMPointOffsetInvalidator() = delete;
AutoEditorDOMPointOffsetInvalidator(
const AutoEditorDOMPointOffsetInvalidator&) = delete;
AutoEditorDOMPointOffsetInvalidator(AutoEditorDOMPointOffsetInvalidator&&) =
delete;
const AutoEditorDOMPointOffsetInvalidator& operator=(
const AutoEditorDOMPointOffsetInvalidator&) = delete;
explicit AutoEditorDOMPointOffsetInvalidator(EditorDOMPoint& aPoint)
: mPoint(aPoint), mCanceled(false) {
MOZ_ASSERT(aPoint.IsSetAndValid());
MOZ_ASSERT(mPoint.CanContainerHaveChildren());
mChild = mPoint.GetChild();
}
~AutoEditorDOMPointOffsetInvalidator() {
if (!mCanceled) {
InvalidateOffset();
}
}
/**
* Manually, invalidate offset of the given point.
*/
void InvalidateOffset() {
if (mChild) {
mPoint.Set(mChild);
} else {
// If the point referred after the last child, let's keep referring
// after current last node of the old container.
mPoint.SetToEndOf(mPoint.GetContainer());
}
}
/**
* After calling Cancel(), mPoint won't be modified by the destructor.
*/
void Cancel() { mCanceled = true; }
private:
EditorDOMPoint& mPoint;
// Needs to store child node by ourselves because EditorDOMPoint stores
// child node with mRef which is previous sibling of current child node.
// Therefore, we cannot keep referring it if it's first child.
nsCOMPtr<nsIContent> mChild;
bool mCanceled;
};
class MOZ_STACK_CLASS AutoEditorDOMRangeOffsetsInvalidator final {
public:
explicit AutoEditorDOMRangeOffsetsInvalidator(EditorDOMRange& aRange)
: mStartInvalidator(const_cast<EditorDOMPoint&>(aRange.StartRef())),
mEndInvalidator(const_cast<EditorDOMPoint&>(aRange.EndRef())) {}
void InvalidateOffsets() {
mStartInvalidator.InvalidateOffset();
mEndInvalidator.InvalidateOffset();
}
void Cancel() {
mStartInvalidator.Cancel();
mEndInvalidator.Cancel();
}
private:
AutoEditorDOMPointOffsetInvalidator mStartInvalidator;
AutoEditorDOMPointOffsetInvalidator mEndInvalidator;
};
/**
* AutoEditorDOMPointChildInvalidator is useful if DOM tree will be changed
* when EditorDOMPoint instance is available and keeps referring same container
* and offset in it.
*
* This class automatically guarantees that given EditorDOMPoint instance
* stores offset and invalidates its child node when the instance is destroyed.
* Additionally, users of this class can invalidate the child manually when
* they need.
*/
class MOZ_STACK_CLASS AutoEditorDOMPointChildInvalidator final {
public:
AutoEditorDOMPointChildInvalidator() = delete;
AutoEditorDOMPointChildInvalidator(
const AutoEditorDOMPointChildInvalidator&) = delete;
AutoEditorDOMPointChildInvalidator(AutoEditorDOMPointChildInvalidator&&) =
delete;
const AutoEditorDOMPointChildInvalidator& operator=(
const AutoEditorDOMPointChildInvalidator&) = delete;
explicit AutoEditorDOMPointChildInvalidator(EditorDOMPoint& aPoint)
: mPoint(aPoint), mCanceled(false) {
MOZ_ASSERT(aPoint.IsSetAndValid());
Unused << mPoint.Offset();
}
~AutoEditorDOMPointChildInvalidator() {
if (!mCanceled) {
InvalidateChild();
}
}
/**
* Manually, invalidate child of the given point.
*/
void InvalidateChild() { mPoint.Set(mPoint.GetContainer(), mPoint.Offset()); }
/**
* After calling Cancel(), mPoint won't be modified by the destructor.
*/
void Cancel() { mCanceled = true; }
private:
EditorDOMPoint& mPoint;
bool mCanceled;
};
class MOZ_STACK_CLASS AutoEditorDOMRangeChildrenInvalidator final {
public:
explicit AutoEditorDOMRangeChildrenInvalidator(EditorDOMRange& aRange)
: mStartInvalidator(const_cast<EditorDOMPoint&>(aRange.StartRef())),
mEndInvalidator(const_cast<EditorDOMPoint&>(aRange.EndRef())) {}
void InvalidateChildren() {
mStartInvalidator.InvalidateChild();
mEndInvalidator.InvalidateChild();
}
void Cancel() {
mStartInvalidator.Cancel();
mEndInvalidator.Cancel();
}
private:
AutoEditorDOMPointChildInvalidator mStartInvalidator;
AutoEditorDOMPointChildInvalidator mEndInvalidator;
};
} // namespace mozilla
#endif // #ifndef mozilla_EditorDOMPoint_h
