summaryrefslogtreecommitdiffstats
path: root/editor/libeditor/HTMLEditUtils.h
diff options
context:
space:
mode:
Diffstat (limited to 'editor/libeditor/HTMLEditUtils.h')
-rw-r--r--editor/libeditor/HTMLEditUtils.h2559
1 files changed, 2559 insertions, 0 deletions
diff --git a/editor/libeditor/HTMLEditUtils.h b/editor/libeditor/HTMLEditUtils.h
new file mode 100644
index 0000000000..e07fa79095
--- /dev/null
+++ b/editor/libeditor/HTMLEditUtils.h
@@ -0,0 +1,2559 @@
+/* -*- 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 HTMLEditUtils_h
+#define HTMLEditUtils_h
+
+/**
+ * This header declares/defines static helper methods as members of
+ * HTMLEditUtils. If you want to create or look for helper trivial classes for
+ * HTMLEditor, see HTMLEditHelpers.h.
+ */
+
+#include "EditorBase.h"
+#include "EditorDOMPoint.h"
+#include "EditorForwards.h"
+#include "EditorUtils.h"
+
+#include "mozilla/Attributes.h"
+#include "mozilla/EnumSet.h"
+#include "mozilla/IntegerRange.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Result.h"
+#include "mozilla/dom/AbstractRange.h"
+#include "mozilla/dom/AncestorIterator.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/HTMLBRElement.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/dom/Text.h"
+
+#include "nsContentUtils.h"
+#include "nsCRT.h"
+#include "nsGkAtoms.h"
+#include "nsHTMLTags.h"
+#include "nsTArray.h"
+
+class nsAtom;
+class nsPresContext;
+
+namespace mozilla {
+
+enum class CollectChildrenOption {
+ // Ignore non-editable nodes
+ IgnoreNonEditableChildren,
+ // Ignore invisible text nodes
+ IgnoreInvisibleTextNodes,
+ // Collect list children too.
+ CollectListChildren,
+ // Collect table children too.
+ CollectTableChildren,
+};
+
+class HTMLEditUtils final {
+ using AbstractRange = dom::AbstractRange;
+ using Element = dom::Element;
+ using Selection = dom::Selection;
+ using Text = dom::Text;
+
+ public:
+ static constexpr char16_t kNewLine = '\n';
+ static constexpr char16_t kCarriageReturn = '\r';
+ static constexpr char16_t kTab = '\t';
+ static constexpr char16_t kSpace = ' ';
+ static constexpr char16_t kNBSP = 0x00A0;
+ static constexpr char16_t kGreaterThan = '>';
+
+ /**
+ * IsSimplyEditableNode() returns true when aNode is simply editable.
+ * This does NOT means that aNode can be removed from current parent nor
+ * aNode's data is editable.
+ */
+ static bool IsSimplyEditableNode(const nsINode& aNode) {
+ return aNode.IsEditable();
+ }
+
+ /**
+ * Return true if inclusive flat tree ancestor has `inert` state.
+ */
+ static bool ContentIsInert(const nsIContent& aContent);
+
+ /**
+ * IsNeverContentEditableElementByUser() returns true if the element's content
+ * is never editable by user. E.g., the content is always replaced by
+ * native anonymous node or something.
+ */
+ static bool IsNeverElementContentsEditableByUser(const nsIContent& aContent) {
+ return aContent.IsElement() &&
+ (!HTMLEditUtils::IsContainerNode(aContent) ||
+ aContent.IsAnyOfHTMLElements(
+ nsGkAtoms::applet, nsGkAtoms::colgroup, nsGkAtoms::frameset,
+ nsGkAtoms::head, nsGkAtoms::html, nsGkAtoms::iframe,
+ nsGkAtoms::meter, nsGkAtoms::picture, nsGkAtoms::progress,
+ nsGkAtoms::select, nsGkAtoms::textarea));
+ }
+
+ /**
+ * IsNonEditableReplacedContent() returns true when aContent is an inclusive
+ * descendant of a replaced element whose content shouldn't be editable by
+ * user's operation.
+ */
+ static bool IsNonEditableReplacedContent(const nsIContent& aContent) {
+ for (Element* element : aContent.InclusiveAncestorsOfType<Element>()) {
+ if (element->IsAnyOfHTMLElements(nsGkAtoms::select, nsGkAtoms::option,
+ nsGkAtoms::optgroup)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /*
+ * IsRemovalNode() returns true when parent of aContent is editable even
+ * if aContent isn't editable.
+ * This is a valid method to check it if you find the content from point
+ * of view of siblings or parents of aContent.
+ * Note that padding `<br>` element for empty editor and manual native
+ * anonymous content should be deletable even after `HTMLEditor` is destroyed
+ * because they are owned/managed by `HTMLEditor`.
+ */
+ static bool IsRemovableNode(const nsIContent& aContent) {
+ return EditorUtils::IsPaddingBRElementForEmptyEditor(aContent) ||
+ aContent.IsRootOfNativeAnonymousSubtree() ||
+ (aContent.GetParentNode() &&
+ aContent.GetParentNode()->IsEditable() &&
+ &aContent != aContent.OwnerDoc()->GetBody() &&
+ &aContent != aContent.OwnerDoc()->GetDocumentElement());
+ }
+
+ /**
+ * IsRemovableFromParentNode() returns true when aContent is editable, has a
+ * parent node and the parent node is also editable.
+ * This is a valid method to check it if you find the content from point
+ * of view of descendants of aContent.
+ * Note that padding `<br>` element for empty editor and manual native
+ * anonymous content should be deletable even after `HTMLEditor` is destroyed
+ * because they are owned/managed by `HTMLEditor`.
+ */
+ static bool IsRemovableFromParentNode(const nsIContent& aContent) {
+ return EditorUtils::IsPaddingBRElementForEmptyEditor(aContent) ||
+ aContent.IsRootOfNativeAnonymousSubtree() ||
+ (aContent.IsEditable() && aContent.GetParentNode() &&
+ aContent.GetParentNode()->IsEditable() &&
+ &aContent != aContent.OwnerDoc()->GetBody() &&
+ &aContent != aContent.OwnerDoc()->GetDocumentElement());
+ }
+
+ /**
+ * CanContentsBeJoined() returns true if aLeftContent and aRightContent can be
+ * joined.
+ */
+ static bool CanContentsBeJoined(const nsIContent& aLeftContent,
+ const nsIContent& aRightContent);
+
+ /**
+ * IsBlockElement() returns true if aContent is an element and it should
+ * be treated as a block. (This does not refer style information.)
+ */
+ static bool IsBlockElement(const nsIContent& aContent);
+ /**
+ * IsInlineElement() returns true if aElement is an element node but
+ * shouldn't be treated as a block or aElement is not an element.
+ * XXX This name is wrong. Must be renamed to IsInlineContent() or something.
+ */
+ static bool IsInlineElement(const nsIContent& aContent) {
+ return !IsBlockElement(aContent);
+ }
+
+ /**
+ * IsVisibleElementEvenIfLeafNode() returns true if aContent is an empty block
+ * element, a visible replaced element such as a form control. This does not
+ * check the layout information.
+ */
+ static bool IsVisibleElementEvenIfLeafNode(const nsIContent& aContent);
+
+ static bool IsInlineStyle(nsINode* aNode);
+
+ /**
+ * IsDisplayOutsideInline() returns true if display-outside value is
+ * "inside". This does NOT flush the layout.
+ */
+ [[nodiscard]] static bool IsDisplayOutsideInline(const Element& aElement);
+
+ /**
+ * IsDisplayInsideFlowRoot() returns true if display-inline value of aElement
+ * is "flow-root". This does NOT flush the layout.
+ */
+ [[nodiscard]] static bool IsDisplayInsideFlowRoot(const Element& aElement);
+
+ /**
+ * IsRemovableInlineStyleElement() returns true if aElement is an inline
+ * element and can be removed or split to in order to modifying inline
+ * styles.
+ */
+ static bool IsRemovableInlineStyleElement(Element& aElement);
+ static bool IsFormatNode(const nsINode* aNode);
+ static bool IsNodeThatCanOutdent(nsINode* aNode);
+ static bool IsHeader(nsINode& aNode);
+ static bool IsListItem(const nsINode* aNode);
+ static bool IsTable(nsINode* aNode);
+ static bool IsTableRow(nsINode* aNode);
+ static bool IsAnyTableElement(const nsINode* aNode);
+ static bool IsAnyTableElementButNotTable(nsINode* aNode);
+ static bool IsTableCell(const nsINode* aNode);
+ static bool IsTableCellOrCaption(nsINode& aNode);
+ static bool IsAnyListElement(const nsINode* aNode);
+ static bool IsPre(const nsINode* aNode);
+ static bool IsImage(nsINode* aNode);
+ static bool IsLink(const nsINode* aNode);
+ static bool IsNamedAnchor(const nsINode* aNode);
+ static bool IsMozDiv(nsINode* aNode);
+ static bool IsMailCite(const Element& aElement);
+ static bool IsFormWidget(const nsINode* aNode);
+ static bool SupportsAlignAttr(nsINode& aNode);
+
+ static bool CanNodeContain(const nsINode& aParent, const nsIContent& aChild) {
+ switch (aParent.NodeType()) {
+ case nsINode::ELEMENT_NODE:
+ case nsINode::DOCUMENT_FRAGMENT_NODE:
+ return HTMLEditUtils::CanNodeContain(*aParent.NodeInfo()->NameAtom(),
+ aChild);
+ }
+ return false;
+ }
+
+ static bool CanNodeContain(const nsINode& aParent, nsAtom& aChildNodeName) {
+ switch (aParent.NodeType()) {
+ case nsINode::ELEMENT_NODE:
+ case nsINode::DOCUMENT_FRAGMENT_NODE:
+ return HTMLEditUtils::CanNodeContain(*aParent.NodeInfo()->NameAtom(),
+ aChildNodeName);
+ }
+ return false;
+ }
+
+ static bool CanNodeContain(nsAtom& aParentNodeName,
+ const nsIContent& aChild) {
+ switch (aChild.NodeType()) {
+ case nsINode::TEXT_NODE:
+ case nsINode::COMMENT_NODE:
+ case nsINode::CDATA_SECTION_NODE:
+ case nsINode::ELEMENT_NODE:
+ case nsINode::DOCUMENT_FRAGMENT_NODE:
+ return HTMLEditUtils::CanNodeContain(aParentNodeName,
+ *aChild.NodeInfo()->NameAtom());
+ }
+ return false;
+ }
+
+ // XXX Only this overload does not check the node type. Therefore, only this
+ // handle Document and ProcessingInstructionTagName.
+ static bool CanNodeContain(nsAtom& aParentNodeName, nsAtom& aChildNodeName) {
+ nsHTMLTag childTagEnum;
+ if (&aChildNodeName == nsGkAtoms::textTagName) {
+ childTagEnum = eHTMLTag_text;
+ } else if (&aChildNodeName == nsGkAtoms::commentTagName ||
+ &aChildNodeName == nsGkAtoms::cdataTagName) {
+ childTagEnum = eHTMLTag_comment;
+ } else {
+ childTagEnum = nsHTMLTags::AtomTagToId(&aChildNodeName);
+ }
+
+ nsHTMLTag parentTagEnum = nsHTMLTags::AtomTagToId(&aParentNodeName);
+ return HTMLEditUtils::CanNodeContain(parentTagEnum, childTagEnum);
+ }
+
+ /**
+ * CanElementContainParagraph() returns true if aElement can have a <p>
+ * element as its child or its descendant.
+ */
+ static bool CanElementContainParagraph(const Element& aElement) {
+ if (HTMLEditUtils::CanNodeContain(aElement, *nsGkAtoms::p)) {
+ return true;
+ }
+
+ // Even if the element cannot have a <p> element as a child, it can contain
+ // <p> element as a descendant if it's one of the following elements.
+ if (aElement.IsAnyOfHTMLElements(nsGkAtoms::ol, nsGkAtoms::ul,
+ nsGkAtoms::dl, nsGkAtoms::table,
+ nsGkAtoms::thead, nsGkAtoms::tbody,
+ nsGkAtoms::tfoot, nsGkAtoms::tr)) {
+ return true;
+ }
+
+ // XXX Otherwise, Chromium checks the CSS box is a block, but we don't do it
+ // for now.
+ return false;
+ }
+
+ /**
+ * IsContainerNode() returns true if aContent is a container node.
+ */
+ static bool IsContainerNode(const nsIContent& aContent) {
+ nsHTMLTag tagEnum;
+ // XXX Should this handle #cdata-section too?
+ if (aContent.IsText()) {
+ tagEnum = eHTMLTag_text;
+ } else {
+ // XXX Why don't we use nsHTMLTags::AtomTagToId? Are there some
+ // difference?
+ tagEnum = nsHTMLTags::StringTagToId(aContent.NodeName());
+ }
+ return HTMLEditUtils::IsContainerNode(tagEnum);
+ }
+
+ /**
+ * IsSplittableNode() returns true if aContent can split.
+ */
+ static bool IsSplittableNode(const nsIContent& aContent) {
+ if (!EditorUtils::IsEditableContent(aContent,
+ EditorUtils::EditorType::HTML) ||
+ !HTMLEditUtils::IsRemovableFromParentNode(aContent)) {
+ return false;
+ }
+ if (aContent.IsElement()) {
+ // XXX Perhaps, instead of using container, we should have "splittable"
+ // information in the DB. E.g., `<template>`, `<script>` elements
+ // can have children, but shouldn't be split.
+ return HTMLEditUtils::IsContainerNode(aContent) &&
+ !aContent.IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::button,
+ nsGkAtoms::caption, nsGkAtoms::table,
+ nsGkAtoms::tbody, nsGkAtoms::tfoot,
+ nsGkAtoms::thead, nsGkAtoms::tr) &&
+ !HTMLEditUtils::IsNeverElementContentsEditableByUser(aContent) &&
+ !HTMLEditUtils::IsNonEditableReplacedContent(aContent);
+ }
+ return aContent.IsText() && aContent.Length() > 0;
+ }
+
+ /**
+ * See execCommand spec:
+ * https://w3c.github.io/editing/execCommand.html#non-list-single-line-container
+ * https://w3c.github.io/editing/execCommand.html#single-line-container
+ */
+ static bool IsNonListSingleLineContainer(const nsINode& aNode);
+ static bool IsSingleLineContainer(const nsINode& aNode);
+
+ /**
+ * IsVisibleTextNode() returns true if aText has visible text. If it has
+ * only white-spaces and they are collapsed, returns false.
+ */
+ [[nodiscard]] static bool IsVisibleTextNode(const Text& aText);
+
+ /**
+ * IsInVisibleTextFrames() returns true if any text in aText is in visible
+ * text frames. Callers have to guarantee that there is no pending reflow.
+ */
+ static bool IsInVisibleTextFrames(nsPresContext* aPresContext,
+ const Text& aText);
+
+ /**
+ * IsVisibleBRElement() and IsInvisibleBRElement() return true if aContent is
+ * a visible HTML <br> element, i.e., not a padding <br> element for making
+ * last line in a block element visible, or an invisible <br> element.
+ */
+ static bool IsVisibleBRElement(const nsIContent& aContent) {
+ if (const dom::HTMLBRElement* brElement =
+ dom::HTMLBRElement::FromNode(&aContent)) {
+ return IsVisibleBRElement(*brElement);
+ }
+ return false;
+ }
+ static bool IsVisibleBRElement(const dom::HTMLBRElement& aBRElement) {
+ // If followed by a block boundary without visible content, it's invisible
+ // <br> element.
+ return !HTMLEditUtils::GetElementOfImmediateBlockBoundary(
+ aBRElement, WalkTreeDirection::Forward);
+ }
+ static bool IsInvisibleBRElement(const nsIContent& aContent) {
+ if (const dom::HTMLBRElement* brElement =
+ dom::HTMLBRElement::FromNode(&aContent)) {
+ return IsInvisibleBRElement(*brElement);
+ }
+ return false;
+ }
+ static bool IsInvisibleBRElement(const dom::HTMLBRElement& aBRElement) {
+ return !HTMLEditUtils::IsVisibleBRElement(aBRElement);
+ }
+
+ /**
+ * IsVisiblePreformattedNewLine() and IsInvisiblePreformattedNewLine() return
+ * true if the point is preformatted linefeed and it's visible or invisible.
+ * If linefeed is immediately before a block boundary, it's invisible.
+ *
+ * @param aFollowingBlockElement [out] If the node is followed by a block
+ * boundary, this is set to the element
+ * creating the block boundary.
+ */
+ template <typename EditorDOMPointType>
+ static bool IsVisiblePreformattedNewLine(
+ const EditorDOMPointType& aPoint,
+ Element** aFollowingBlockElement = nullptr) {
+ if (aFollowingBlockElement) {
+ *aFollowingBlockElement = nullptr;
+ }
+ if (!aPoint.IsInTextNode() || aPoint.IsEndOfContainer() ||
+ !aPoint.IsCharPreformattedNewLine()) {
+ return false;
+ }
+ // If there are some other characters in the text node, it's a visible
+ // linefeed.
+ if (!aPoint.IsAtLastContent()) {
+ if (EditorUtils::IsWhiteSpacePreformatted(
+ *aPoint.template ContainerAs<Text>())) {
+ return true;
+ }
+ const nsTextFragment& textFragment =
+ aPoint.template ContainerAs<Text>()->TextFragment();
+ for (uint32_t offset = aPoint.Offset() + 1;
+ offset < textFragment.GetLength(); ++offset) {
+ char16_t ch = textFragment.CharAt(AssertedCast<int32_t>(offset));
+ if (nsCRT::IsAsciiSpace(ch) && ch != HTMLEditUtils::kNewLine) {
+ continue; // ASCII white-space which is collapsed into the linefeed.
+ }
+ return true; // There is a visible character after it.
+ }
+ }
+ // If followed by a block boundary without visible content, it's invisible
+ // linefeed.
+ Element* followingBlockElement =
+ HTMLEditUtils::GetElementOfImmediateBlockBoundary(
+ *aPoint.template ContainerAs<Text>(), WalkTreeDirection::Forward);
+ if (aFollowingBlockElement) {
+ *aFollowingBlockElement = followingBlockElement;
+ }
+ return !followingBlockElement;
+ }
+ template <typename EditorDOMPointType>
+ static bool IsInvisiblePreformattedNewLine(
+ const EditorDOMPointType& aPoint,
+ Element** aFollowingBlockElement = nullptr) {
+ if (!aPoint.IsInTextNode() || aPoint.IsEndOfContainer() ||
+ !aPoint.IsCharPreformattedNewLine()) {
+ if (aFollowingBlockElement) {
+ *aFollowingBlockElement = nullptr;
+ }
+ return false;
+ }
+ return !IsVisiblePreformattedNewLine(aPoint, aFollowingBlockElement);
+ }
+
+ /**
+ * ShouldInsertLinefeedCharacter() returns true if the caller should insert
+ * a linefeed character instead of <br> element.
+ */
+ static bool ShouldInsertLinefeedCharacter(
+ const EditorDOMPoint& aPointToInsert, const Element& aEditingHost);
+
+ /**
+ * IsEmptyNode() returns false if aNode has some visible content nodes,
+ * list elements or table elements.
+ *
+ * @param aPresContext Must not be nullptr if
+ * EmptyCheckOption::SafeToAskLayout is set.
+ * @param aNode The node to check whether it's empty.
+ * @param aOptions You can specify which type of elements are visible
+ * and/or whether this can access layout information.
+ * @param aSeenBR [Out] Set to true if this meets an <br> element
+ * before meething visible things.
+ */
+ enum class EmptyCheckOption {
+ TreatSingleBRElementAsVisible,
+ TreatListItemAsVisible,
+ TreatTableCellAsVisible,
+ IgnoreEditableState, // TODO: Change to "TreatNonEditableContentAsVisible"
+ SafeToAskLayout,
+ };
+ using EmptyCheckOptions = EnumSet<EmptyCheckOption, uint32_t>;
+ static bool IsEmptyNode(nsPresContext* aPresContext, const nsINode& aNode,
+ const EmptyCheckOptions& aOptions = {},
+ bool* aSeenBR = nullptr);
+ static bool IsEmptyNode(const nsINode& aNode,
+ const EmptyCheckOptions& aOptions = {},
+ bool* aSeenBR = nullptr) {
+ MOZ_ASSERT(!aOptions.contains(EmptyCheckOption::SafeToAskLayout));
+ return IsEmptyNode(nullptr, aNode, aOptions, aSeenBR);
+ }
+
+ /**
+ * IsEmptyInlineContainer() returns true if aContent is an inline element
+ * which can have children and does not have meaningful content.
+ */
+ static bool IsEmptyInlineContainer(const nsIContent& aContent,
+ const EmptyCheckOptions& aOptions) {
+ return HTMLEditUtils::IsInlineElement(aContent) &&
+ HTMLEditUtils::IsContainerNode(aContent) &&
+ HTMLEditUtils::IsEmptyNode(aContent, aOptions);
+ }
+
+ /**
+ * IsEmptyBlockElement() returns true if aElement is a block level element
+ * and it doesn't have any visible content.
+ */
+ static bool IsEmptyBlockElement(const Element& aElement,
+ const EmptyCheckOptions& aOptions) {
+ return HTMLEditUtils::IsBlockElement(aElement) &&
+ HTMLEditUtils::IsEmptyNode(aElement, aOptions);
+ }
+
+ /**
+ * Return true if aListElement is completely empty or it has only one list
+ * item element which is empty.
+ */
+ [[nodiscard]] static bool IsEmptyAnyListElement(const Element& aListElement) {
+ MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+ bool foundListItem = false;
+ for (nsIContent* child = aListElement.GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (HTMLEditUtils::IsListItem(child)) {
+ if (foundListItem) {
+ return false; // 2 list items found.
+ }
+ if (!IsEmptyNode(*child, {EmptyCheckOption::IgnoreEditableState})) {
+ return false; // found non-empty list item.
+ }
+ foundListItem = true;
+ continue;
+ }
+ if (child->IsElement()) {
+ return false; // found sublist or illegal child.
+ }
+ if (child->IsText() &&
+ HTMLEditUtils::IsVisibleTextNode(*child->AsText())) {
+ return false; // found illegal visible text node.
+ }
+ }
+ return true;
+ }
+
+ /**
+ * Return true if aListElement does not have invalid child.
+ */
+ enum class TreatSubListElementAs { Invalid, Valid };
+ [[nodiscard]] static bool IsValidListElement(
+ const Element& aListElement,
+ TreatSubListElementAs aTreatSubListElementAs) {
+ MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+ for (nsIContent* child = aListElement.GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (HTMLEditUtils::IsAnyListElement(child)) {
+ if (aTreatSubListElementAs == TreatSubListElementAs::Invalid) {
+ return false;
+ }
+ continue;
+ }
+ if (child->IsHTMLElement(nsGkAtoms::li)) {
+ if (MOZ_UNLIKELY(!aListElement.IsAnyOfHTMLElements(nsGkAtoms::ol,
+ nsGkAtoms::ul))) {
+ return false;
+ }
+ continue;
+ }
+ if (child->IsAnyOfHTMLElements(nsGkAtoms::dt, nsGkAtoms::dd)) {
+ if (MOZ_UNLIKELY(!aListElement.IsAnyOfHTMLElements(nsGkAtoms::dl))) {
+ return false;
+ }
+ continue;
+ }
+ if (MOZ_UNLIKELY(child->IsElement())) {
+ return false;
+ }
+ if (MOZ_LIKELY(child->IsText())) {
+ if (MOZ_UNLIKELY(HTMLEditUtils::IsVisibleTextNode(*child->AsText()))) {
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+
+ /**
+ * IsEmptyOneHardLine() returns true if aArrayOfContents does not represent
+ * 2 or more lines and have meaningful content.
+ */
+ static bool IsEmptyOneHardLine(
+ nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents) {
+ if (NS_WARN_IF(aArrayOfContents.IsEmpty())) {
+ return true;
+ }
+
+ bool brElementHasFound = false;
+ for (OwningNonNull<nsIContent>& content : aArrayOfContents) {
+ if (!EditorUtils::IsEditableContent(content,
+ EditorUtils::EditorType::HTML)) {
+ continue;
+ }
+ if (content->IsHTMLElement(nsGkAtoms::br)) {
+ // If there are 2 or more `<br>` elements, it's not empty line since
+ // there may be only one `<br>` element in a hard line.
+ if (brElementHasFound) {
+ return false;
+ }
+ brElementHasFound = true;
+ continue;
+ }
+ if (!HTMLEditUtils::IsEmptyInlineContainer(
+ content, {EmptyCheckOption::TreatSingleBRElementAsVisible})) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * IsPointAtEdgeOfLink() returns true if aPoint is at start or end of a
+ * link.
+ */
+ template <typename PT, typename CT>
+ static bool IsPointAtEdgeOfLink(const EditorDOMPointBase<PT, CT>& aPoint,
+ Element** aFoundLinkElement = nullptr) {
+ if (aFoundLinkElement) {
+ *aFoundLinkElement = nullptr;
+ }
+ if (!aPoint.IsInContentNode()) {
+ return false;
+ }
+ if (!aPoint.IsStartOfContainer() && !aPoint.IsEndOfContainer()) {
+ return false;
+ }
+ // XXX Assuming it's not in an empty text node because it's unrealistic edge
+ // case.
+ bool maybeStartOfAnchor = aPoint.IsStartOfContainer();
+ for (EditorRawDOMPoint point(aPoint.template ContainerAs<nsIContent>());
+ point.IsSet() && (maybeStartOfAnchor ? point.IsStartOfContainer()
+ : point.IsAtLastContent());
+ point = point.ParentPoint()) {
+ if (HTMLEditUtils::IsLink(point.GetContainer())) {
+ // Now, we're at start or end of <a href>.
+ if (aFoundLinkElement) {
+ *aFoundLinkElement =
+ do_AddRef(point.template ContainerAs<Element>()).take();
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * IsContentInclusiveDescendantOfLink() returns true if aContent is a
+ * descendant of a link element.
+ * Note that this returns true even if editing host of aContent is in a link
+ * element.
+ */
+ static bool IsContentInclusiveDescendantOfLink(
+ nsIContent& aContent, Element** aFoundLinkElement = nullptr) {
+ if (aFoundLinkElement) {
+ *aFoundLinkElement = nullptr;
+ }
+ for (Element* element : aContent.InclusiveAncestorsOfType<Element>()) {
+ if (HTMLEditUtils::IsLink(element)) {
+ if (aFoundLinkElement) {
+ *aFoundLinkElement = do_AddRef(element).take();
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * IsRangeEntirelyInLink() returns true if aRange is entirely in a link
+ * element.
+ * Note that this returns true even if editing host of the range is in a link
+ * element.
+ */
+ template <typename EditorDOMRangeType>
+ static bool IsRangeEntirelyInLink(const EditorDOMRangeType& aRange,
+ Element** aFoundLinkElement = nullptr) {
+ MOZ_ASSERT(aRange.IsPositionedAndValid());
+ if (aFoundLinkElement) {
+ *aFoundLinkElement = nullptr;
+ }
+ nsINode* commonAncestorNode =
+ nsContentUtils::GetClosestCommonInclusiveAncestor(
+ aRange.StartRef().GetContainer(), aRange.EndRef().GetContainer());
+ if (NS_WARN_IF(!commonAncestorNode) || !commonAncestorNode->IsContent()) {
+ return false;
+ }
+ return IsContentInclusiveDescendantOfLink(*commonAncestorNode->AsContent(),
+ aFoundLinkElement);
+ }
+
+ /**
+ * Get adjacent content node of aNode if there is (even if one is in different
+ * parent element).
+ *
+ * @param aNode The node from which we start to walk the DOM
+ * tree.
+ * @param aOptions See WalkTreeOption for the detail.
+ * @param aAncestorLimiter Ancestor limiter element which these methods
+ * never cross its boundary. This is typically
+ * the editing host.
+ */
+ enum class WalkTreeOption {
+ IgnoreNonEditableNode, // Ignore non-editable nodes and their children.
+ IgnoreDataNodeExceptText, // Ignore data nodes which are not text node.
+ IgnoreWhiteSpaceOnlyText, // Ignore text nodes having only white-spaces.
+ StopAtBlockBoundary, // Stop waking the tree at a block boundary.
+ };
+ using WalkTreeOptions = EnumSet<WalkTreeOption>;
+ static nsIContent* GetPreviousContent(
+ const nsINode& aNode, const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr) {
+ if (&aNode == aAncestorLimiter ||
+ (aAncestorLimiter &&
+ !aNode.IsInclusiveDescendantOf(aAncestorLimiter))) {
+ return nullptr;
+ }
+ return HTMLEditUtils::GetAdjacentContent(aNode, WalkTreeDirection::Backward,
+ aOptions, aAncestorLimiter);
+ }
+ static nsIContent* GetNextContent(const nsINode& aNode,
+ const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr) {
+ if (&aNode == aAncestorLimiter ||
+ (aAncestorLimiter &&
+ !aNode.IsInclusiveDescendantOf(aAncestorLimiter))) {
+ return nullptr;
+ }
+ return HTMLEditUtils::GetAdjacentContent(aNode, WalkTreeDirection::Forward,
+ aOptions, aAncestorLimiter);
+ }
+
+ /**
+ * And another version that takes a point in DOM tree rather than a node.
+ */
+ template <typename PT, typename CT>
+ static nsIContent* GetPreviousContent(
+ const EditorDOMPointBase<PT, CT>& aPoint, const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr);
+
+ /**
+ * And another version that takes a point in DOM tree rather than a node.
+ *
+ * Note that this may return the child at the offset. E.g., following code
+ * causes infinite loop.
+ *
+ * EditorRawDOMPoint point(aEditableNode);
+ * while (nsIContent* content =
+ * GetNextContent(point, {WalkTreeOption::IgnoreNonEditableNode})) {
+ * // Do something...
+ * point.Set(content);
+ * }
+ *
+ * Following code must be you expected:
+ *
+ * while (nsIContent* content =
+ * GetNextContent(point, {WalkTreeOption::IgnoreNonEditableNode}) {
+ * // Do something...
+ * DebugOnly<bool> advanced = point.Advanced();
+ * MOZ_ASSERT(advanced);
+ * point.Set(point.GetChild());
+ * }
+ */
+ template <typename PT, typename CT>
+ static nsIContent* GetNextContent(const EditorDOMPointBase<PT, CT>& aPoint,
+ const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr);
+
+ /**
+ * GetPreviousSibling() and GetNextSibling() return the nearest sibling of
+ * aContent which does not match with aOption.
+ */
+ static nsIContent* GetPreviousSibling(const nsIContent& aContent,
+ const WalkTreeOptions& aOptions) {
+ for (nsIContent* sibling = aContent.GetPreviousSibling(); sibling;
+ sibling = sibling->GetPreviousSibling()) {
+ if (HTMLEditUtils::IsContentIgnored(*sibling, aOptions)) {
+ continue;
+ }
+ if (aOptions.contains(WalkTreeOption::StopAtBlockBoundary) &&
+ HTMLEditUtils::IsBlockElement(*sibling)) {
+ return nullptr;
+ }
+ return sibling;
+ }
+ return nullptr;
+ }
+
+ static nsIContent* GetNextSibling(const nsIContent& aContent,
+ const WalkTreeOptions& aOptions) {
+ for (nsIContent* sibling = aContent.GetNextSibling(); sibling;
+ sibling = sibling->GetNextSibling()) {
+ if (HTMLEditUtils::IsContentIgnored(*sibling, aOptions)) {
+ continue;
+ }
+ if (aOptions.contains(WalkTreeOption::StopAtBlockBoundary) &&
+ HTMLEditUtils::IsBlockElement(*sibling)) {
+ return nullptr;
+ }
+ return sibling;
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetLastChild() and GetFirstChild() return the first or last child of aNode
+ * which does not match with aOption.
+ */
+ static nsIContent* GetLastChild(const nsINode& aNode,
+ const WalkTreeOptions& aOptions) {
+ for (nsIContent* child = aNode.GetLastChild(); child;
+ child = child->GetPreviousSibling()) {
+ if (HTMLEditUtils::IsContentIgnored(*child, aOptions)) {
+ continue;
+ }
+ if (aOptions.contains(WalkTreeOption::StopAtBlockBoundary) &&
+ HTMLEditUtils::IsBlockElement(*child)) {
+ return nullptr;
+ }
+ return child;
+ }
+ return nullptr;
+ }
+
+ static nsIContent* GetFirstChild(const nsINode& aNode,
+ const WalkTreeOptions& aOptions) {
+ for (nsIContent* child = aNode.GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (HTMLEditUtils::IsContentIgnored(*child, aOptions)) {
+ continue;
+ }
+ if (aOptions.contains(WalkTreeOption::StopAtBlockBoundary) &&
+ HTMLEditUtils::IsBlockElement(*child)) {
+ return nullptr;
+ }
+ return child;
+ }
+ return nullptr;
+ }
+
+ static bool IsLastChild(const nsIContent& aContent,
+ const WalkTreeOptions& aOptions) {
+ nsINode* parentNode = aContent.GetParentNode();
+ if (!parentNode) {
+ return false;
+ }
+ return HTMLEditUtils::GetLastChild(*parentNode, aOptions) == &aContent;
+ }
+
+ static bool IsFirstChild(const nsIContent& aContent,
+ const WalkTreeOptions& aOptions) {
+ nsINode* parentNode = aContent.GetParentNode();
+ if (!parentNode) {
+ return false;
+ }
+ return HTMLEditUtils::GetFirstChild(*parentNode, aOptions) == &aContent;
+ }
+
+ /**
+ * GetAdjacentContentToPutCaret() walks the DOM tree to find an editable node
+ * near aPoint where may be a good point to put caret and keep typing or
+ * deleting.
+ *
+ * @param aPoint The DOM point where to start to search from.
+ * @return If found, returns non-nullptr. Otherwise, nullptr.
+ * Note that if found node is in different table structure
+ * element, this returns nullptr.
+ */
+ enum class WalkTreeDirection { Forward, Backward };
+ template <typename PT, typename CT>
+ static nsIContent* GetAdjacentContentToPutCaret(
+ const EditorDOMPointBase<PT, CT>& aPoint,
+ WalkTreeDirection aWalkTreeDirection, const Element& aEditingHost) {
+ MOZ_ASSERT(aPoint.IsSetAndValid());
+
+ nsIContent* editableContent = nullptr;
+ if (aWalkTreeDirection == WalkTreeDirection::Backward) {
+ editableContent = HTMLEditUtils::GetPreviousContent(
+ aPoint, {WalkTreeOption::IgnoreNonEditableNode}, &aEditingHost);
+ if (!editableContent) {
+ return nullptr; // Not illegal.
+ }
+ } else {
+ editableContent = HTMLEditUtils::GetNextContent(
+ aPoint, {WalkTreeOption::IgnoreNonEditableNode}, &aEditingHost);
+ if (NS_WARN_IF(!editableContent)) {
+ // Perhaps, illegal because the node pointed by aPoint isn't editable
+ // and nobody of previous nodes is editable.
+ return nullptr;
+ }
+ }
+
+ // scan in the right direction until we find an eligible text node,
+ // but don't cross any breaks, images, or table elements.
+ // XXX This comment sounds odd. editableContent may have already crossed
+ // breaks and/or images if they are non-editable.
+ while (editableContent && !editableContent->IsText() &&
+ !editableContent->IsHTMLElement(nsGkAtoms::br) &&
+ !HTMLEditUtils::IsImage(editableContent)) {
+ if (aWalkTreeDirection == WalkTreeDirection::Backward) {
+ editableContent = HTMLEditUtils::GetPreviousContent(
+ *editableContent, {WalkTreeOption::IgnoreNonEditableNode},
+ &aEditingHost);
+ if (NS_WARN_IF(!editableContent)) {
+ return nullptr;
+ }
+ } else {
+ editableContent = HTMLEditUtils::GetNextContent(
+ *editableContent, {WalkTreeOption::IgnoreNonEditableNode},
+ &aEditingHost);
+ if (NS_WARN_IF(!editableContent)) {
+ return nullptr;
+ }
+ }
+ }
+
+ // don't cross any table elements
+ if ((!aPoint.IsInContentNode() &&
+ !!HTMLEditUtils::GetInclusiveAncestorAnyTableElement(
+ *editableContent)) ||
+ (HTMLEditUtils::GetInclusiveAncestorAnyTableElement(*editableContent) !=
+ HTMLEditUtils::GetInclusiveAncestorAnyTableElement(
+ *aPoint.template ContainerAs<nsIContent>()))) {
+ return nullptr;
+ }
+
+ // otherwise, ok, we have found a good spot to put the selection
+ return editableContent;
+ }
+
+ /**
+ * GetLastLeafContent() returns rightmost leaf content in aNode. It depends
+ * on aLeafNodeTypes whether this which types of nodes are treated as leaf
+ * nodes.
+ */
+ enum class LeafNodeType {
+ // Even if there is a child block, keep scanning a leaf content in it.
+ OnlyLeafNode,
+ // If there is a child block, return it too. Note that this does not
+ // mean that block siblings are not treated as leaf nodes.
+ LeafNodeOrChildBlock,
+ // If there is a non-editable element if and only if scanning from editable
+ // node, return it too.
+ LeafNodeOrNonEditableNode,
+ // Ignore non-editable content at walking the tree.
+ OnlyEditableLeafNode,
+ };
+ using LeafNodeTypes = EnumSet<LeafNodeType>;
+ static nsIContent* GetLastLeafContent(
+ const nsINode& aNode, const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+ // editor shouldn't touch child nodes which are replaced with native
+ // anonymous nodes.
+ if (aNode.IsElement() &&
+ HTMLEditUtils::IsNeverElementContentsEditableByUser(
+ *aNode.AsElement())) {
+ return nullptr;
+ }
+ for (nsIContent* content = aNode.GetLastChild(); content;) {
+ if (aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode) &&
+ !EditorUtils::IsEditableContent(*content,
+ EditorUtils::EditorType::HTML)) {
+ content = HTMLEditUtils::GetPreviousContent(
+ *content, {WalkTreeOption::IgnoreNonEditableNode},
+ aAncestorLimiter);
+ continue;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrChildBlock) &&
+ HTMLEditUtils::IsBlockElement(*content)) {
+ return content;
+ }
+ if (!content->HasChildren() ||
+ HTMLEditUtils::IsNeverElementContentsEditableByUser(*content)) {
+ return content;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aNode.IsEditable() && !content->IsEditable()) {
+ return content;
+ }
+ content = content->GetLastChild();
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetFirstLeafContent() returns leftmost leaf content in aNode. It depends
+ * on aLeafNodeTypes whether this scans into a block child or treat block as a
+ * leaf.
+ */
+ static nsIContent* GetFirstLeafContent(
+ const nsINode& aNode, const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+ // editor shouldn't touch child nodes which are replaced with native
+ // anonymous nodes.
+ if (aNode.IsElement() &&
+ HTMLEditUtils::IsNeverElementContentsEditableByUser(
+ *aNode.AsElement())) {
+ return nullptr;
+ }
+ for (nsIContent* content = aNode.GetFirstChild(); content;) {
+ if (aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode) &&
+ !EditorUtils::IsEditableContent(*content,
+ EditorUtils::EditorType::HTML)) {
+ content = HTMLEditUtils::GetNextContent(
+ *content, {WalkTreeOption::IgnoreNonEditableNode},
+ aAncestorLimiter);
+ continue;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrChildBlock) &&
+ HTMLEditUtils::IsBlockElement(*content)) {
+ return content;
+ }
+ if (!content->HasChildren() ||
+ HTMLEditUtils::IsNeverElementContentsEditableByUser(*content)) {
+ return content;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aNode.IsEditable() && !content->IsEditable()) {
+ return content;
+ }
+ content = content->GetFirstChild();
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetNextLeafContentOrNextBlockElement() returns next leaf content or
+ * next block element of aStartContent inside aAncestorLimiter.
+ * Note that the result may be a contet outside aCurrentBlock if
+ * aStartContent equals aCurrentBlock.
+ *
+ * @param aStartContent The start content to scan next content.
+ * @param aCurrentBlock Must be ancestor of aStartContent. Dispite
+ * the name, inline content is allowed if
+ * aStartContent is in an inline editing host.
+ * @param aLeafNodeTypes See LeafNodeType.
+ * @param aAncestorLimiter Optional, setting this guarantees the
+ * result is in aAncestorLimiter unless
+ * aStartContent is not a descendant of this.
+ */
+ static nsIContent* GetNextLeafContentOrNextBlockElement(
+ const nsIContent& aStartContent, const nsIContent& aCurrentBlock,
+ const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+
+ if (&aStartContent == aAncestorLimiter) {
+ return nullptr;
+ }
+
+ nsIContent* nextContent = aStartContent.GetNextSibling();
+ if (!nextContent) {
+ if (!aStartContent.GetParentElement()) {
+ NS_WARNING("Reached orphan node while climbing up the DOM tree");
+ return nullptr;
+ }
+ for (Element* parentElement : aStartContent.AncestorsOfType<Element>()) {
+ if (parentElement == &aCurrentBlock) {
+ return nullptr;
+ }
+ if (parentElement == aAncestorLimiter) {
+ NS_WARNING("Reached editing host while climbing up the DOM tree");
+ return nullptr;
+ }
+ nextContent = parentElement->GetNextSibling();
+ if (nextContent) {
+ break;
+ }
+ if (!parentElement->GetParentElement()) {
+ NS_WARNING("Reached orphan node while climbing up the DOM tree");
+ return nullptr;
+ }
+ }
+ MOZ_ASSERT(nextContent);
+ }
+
+ // We have a next content. If it's a block, return it.
+ if (HTMLEditUtils::IsBlockElement(*nextContent)) {
+ return nextContent;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aStartContent.IsEditable() && !nextContent->IsEditable()) {
+ return nextContent;
+ }
+ if (HTMLEditUtils::IsContainerNode(*nextContent)) {
+ // Else if it's a container, get deep leftmost child
+ if (nsIContent* child = HTMLEditUtils::GetFirstLeafContent(
+ *nextContent, aLeafNodeTypes)) {
+ return child;
+ }
+ }
+ // Else return the next content itself.
+ return nextContent;
+ }
+
+ /**
+ * Similar to the above method, but take a DOM point to specify scan start
+ * point.
+ */
+ template <typename PT, typename CT>
+ static nsIContent* GetNextLeafContentOrNextBlockElement(
+ const EditorDOMPointBase<PT, CT>& aStartPoint,
+ const nsIContent& aCurrentBlock, const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT(aStartPoint.IsSet());
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+ NS_ASSERTION(!aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ "Not implemented yet");
+
+ if (!aStartPoint.IsInContentNode()) {
+ return nullptr;
+ }
+ if (aStartPoint.IsInTextNode()) {
+ return HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
+ *aStartPoint.template ContainerAs<Text>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+ if (!HTMLEditUtils::IsContainerNode(
+ *aStartPoint.template ContainerAs<nsIContent>())) {
+ return HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
+ *aStartPoint.template ContainerAs<nsIContent>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+
+ nsCOMPtr<nsIContent> nextContent = aStartPoint.GetChild();
+ if (!nextContent) {
+ if (aStartPoint.GetContainer() == &aCurrentBlock) {
+ // We are at end of the block.
+ return nullptr;
+ }
+
+ // We are at end of non-block container
+ return HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
+ *aStartPoint.template ContainerAs<nsIContent>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+
+ // We have a next node. If it's a block, return it.
+ if (HTMLEditUtils::IsBlockElement(*nextContent)) {
+ return nextContent;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aStartPoint.GetContainer()->IsEditable() &&
+ !nextContent->IsEditable()) {
+ return nextContent;
+ }
+ if (HTMLEditUtils::IsContainerNode(*nextContent)) {
+ // else if it's a container, get deep leftmost child
+ if (nsIContent* child = HTMLEditUtils::GetFirstLeafContent(
+ *nextContent, aLeafNodeTypes)) {
+ return child;
+ }
+ }
+ // Else return the node itself
+ return nextContent;
+ }
+
+ /**
+ * GetPreviousLeafContentOrPreviousBlockElement() returns previous leaf
+ * content or previous block element of aStartContent inside
+ * aAncestorLimiter.
+ * Note that the result may be a contet outside aCurrentBlock if
+ * aStartContent equals aCurrentBlock.
+ *
+ * @param aStartContent The start content to scan previous content.
+ * @param aCurrentBlock Must be ancestor of aStartContent. Dispite
+ * the name, inline content is allowed if
+ * aStartContent is in an inline editing host.
+ * @param aLeafNodeTypes See LeafNodeType.
+ * @param aAncestorLimiter Optional, setting this guarantees the
+ * result is in aAncestorLimiter unless
+ * aStartContent is not a descendant of this.
+ */
+ static nsIContent* GetPreviousLeafContentOrPreviousBlockElement(
+ const nsIContent& aStartContent, const nsIContent& aCurrentBlock,
+ const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+ NS_ASSERTION(!aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ "Not implemented yet");
+
+ if (&aStartContent == aAncestorLimiter) {
+ return nullptr;
+ }
+
+ nsIContent* previousContent = aStartContent.GetPreviousSibling();
+ if (!previousContent) {
+ if (!aStartContent.GetParentElement()) {
+ NS_WARNING("Reached orphan node while climbing up the DOM tree");
+ return nullptr;
+ }
+ for (Element* parentElement : aStartContent.AncestorsOfType<Element>()) {
+ if (parentElement == &aCurrentBlock) {
+ return nullptr;
+ }
+ if (parentElement == aAncestorLimiter) {
+ NS_WARNING("Reached editing host while climbing up the DOM tree");
+ return nullptr;
+ }
+ previousContent = parentElement->GetPreviousSibling();
+ if (previousContent) {
+ break;
+ }
+ if (!parentElement->GetParentElement()) {
+ NS_WARNING("Reached orphan node while climbing up the DOM tree");
+ return nullptr;
+ }
+ }
+ MOZ_ASSERT(previousContent);
+ }
+
+ // We have a next content. If it's a block, return it.
+ if (HTMLEditUtils::IsBlockElement(*previousContent)) {
+ return previousContent;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aStartContent.IsEditable() && !previousContent->IsEditable()) {
+ return previousContent;
+ }
+ if (HTMLEditUtils::IsContainerNode(*previousContent)) {
+ // Else if it's a container, get deep rightmost child
+ if (nsIContent* child = HTMLEditUtils::GetLastLeafContent(
+ *previousContent, aLeafNodeTypes)) {
+ return child;
+ }
+ }
+ // Else return the next content itself.
+ return previousContent;
+ }
+
+ /**
+ * Similar to the above method, but take a DOM point to specify scan start
+ * point.
+ */
+ template <typename PT, typename CT>
+ static nsIContent* GetPreviousLeafContentOrPreviousBlockElement(
+ const EditorDOMPointBase<PT, CT>& aStartPoint,
+ const nsIContent& aCurrentBlock, const LeafNodeTypes& aLeafNodeTypes,
+ const Element* aAncestorLimiter = nullptr) {
+ MOZ_ASSERT(aStartPoint.IsSet());
+ MOZ_ASSERT_IF(
+ aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ !aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode));
+ NS_ASSERTION(!aLeafNodeTypes.contains(LeafNodeType::OnlyEditableLeafNode),
+ "Not implemented yet");
+
+ if (!aStartPoint.IsInContentNode()) {
+ return nullptr;
+ }
+ if (aStartPoint.IsInTextNode()) {
+ return HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
+ *aStartPoint.template ContainerAs<Text>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+ if (!HTMLEditUtils::IsContainerNode(
+ *aStartPoint.template ContainerAs<nsIContent>())) {
+ return HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
+ *aStartPoint.template ContainerAs<nsIContent>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+
+ if (aStartPoint.IsStartOfContainer()) {
+ if (aStartPoint.GetContainer() == &aCurrentBlock) {
+ // We are at start of the block.
+ return nullptr;
+ }
+
+ // We are at start of non-block container
+ return HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
+ *aStartPoint.template ContainerAs<nsIContent>(), aCurrentBlock,
+ aLeafNodeTypes, aAncestorLimiter);
+ }
+
+ nsCOMPtr<nsIContent> previousContent =
+ aStartPoint.GetPreviousSiblingOfChild();
+ if (NS_WARN_IF(!previousContent)) {
+ return nullptr;
+ }
+
+ // We have a prior node. If it's a block, return it.
+ if (HTMLEditUtils::IsBlockElement(*previousContent)) {
+ return previousContent;
+ }
+ if (aLeafNodeTypes.contains(LeafNodeType::LeafNodeOrNonEditableNode) &&
+ aStartPoint.GetContainer()->IsEditable() &&
+ !previousContent->IsEditable()) {
+ return previousContent;
+ }
+ if (HTMLEditUtils::IsContainerNode(*previousContent)) {
+ // Else if it's a container, get deep rightmost child
+ if (nsIContent* child = HTMLEditUtils::GetLastLeafContent(
+ *previousContent, aLeafNodeTypes)) {
+ return child;
+ }
+ }
+ // Else return the node itself
+ return previousContent;
+ }
+
+ /**
+ * Returns a content node whose inline styles should be preserved after
+ * deleting content in a range. Typically, you should set aPoint to start
+ * boundary of the range to delete.
+ */
+ template <typename EditorDOMPointType>
+ static nsIContent* GetContentToPreserveInlineStyles(
+ const EditorDOMPointType& aPoint, const Element& aEditingHost);
+
+ /**
+ * Get previous/next editable point from start or end of aContent.
+ */
+ enum class InvisibleWhiteSpaces {
+ Ignore, // Ignore invisible white-spaces, i.e., don't return middle of
+ // them.
+ Preserve, // Preserve invisible white-spaces, i.e., result may be start or
+ // end of a text node even if it begins or ends with invisible
+ // white-spaces.
+ };
+ enum class TableBoundary {
+ Ignore, // May cross any table element boundary.
+ NoCrossTableElement, // Won't cross `<table>` element boundary.
+ NoCrossAnyTableElement, // Won't cross any table element boundary.
+ };
+ template <typename EditorDOMPointType>
+ static EditorDOMPointType GetPreviousEditablePoint(
+ nsIContent& aContent, const Element* aAncestorLimiter,
+ InvisibleWhiteSpaces aInvisibleWhiteSpaces,
+ TableBoundary aHowToTreatTableBoundary);
+ template <typename EditorDOMPointType>
+ static EditorDOMPointType GetNextEditablePoint(
+ nsIContent& aContent, const Element* aAncestorLimiter,
+ InvisibleWhiteSpaces aInvisibleWhiteSpaces,
+ TableBoundary aHowToTreatTableBoundary);
+
+ /**
+ * GetAncestorElement() and GetInclusiveAncestorElement() return
+ * (inclusive) block ancestor element of aContent whose time matches
+ * aAncestorTypes.
+ */
+ enum class AncestorType {
+ ClosestBlockElement,
+ MostDistantInlineElementInBlock,
+ EditableElement,
+ IgnoreHRElement, // Ignore ancestor <hr> element since invalid structure
+ ButtonElement,
+ };
+ using AncestorTypes = EnumSet<AncestorType>;
+ constexpr static AncestorTypes
+ ClosestEditableBlockElementOrInlineEditingHost = {
+ AncestorType::ClosestBlockElement,
+ AncestorType::MostDistantInlineElementInBlock,
+ AncestorType::EditableElement};
+ constexpr static AncestorTypes ClosestBlockElement = {
+ AncestorType::ClosestBlockElement};
+ constexpr static AncestorTypes ClosestEditableBlockElement = {
+ AncestorType::ClosestBlockElement, AncestorType::EditableElement};
+ constexpr static AncestorTypes ClosestEditableBlockElementExceptHRElement = {
+ AncestorType::ClosestBlockElement, AncestorType::IgnoreHRElement,
+ AncestorType::EditableElement};
+ constexpr static AncestorTypes ClosestEditableBlockElementOrButtonElement = {
+ AncestorType::ClosestBlockElement, AncestorType::EditableElement,
+ AncestorType::ButtonElement};
+ static Element* GetAncestorElement(const nsIContent& aContent,
+ const AncestorTypes& aAncestorTypes,
+ const Element* aAncestorLimiter = nullptr);
+ static Element* GetInclusiveAncestorElement(
+ const nsIContent& aContent, const AncestorTypes& aAncestorTypes,
+ const Element* aAncestorLimiter = nullptr);
+
+ /**
+ * GetClosestAncestorTableElement() returns the nearest inclusive ancestor
+ * <table> element of aContent.
+ */
+ static Element* GetClosestAncestorTableElement(const nsIContent& aContent) {
+ // TODO: the method name and its documentation clash with the
+ // implementation. Split this method into
+ // `GetClosestAncestorTableElement` and
+ // `GetClosestInclusiveAncestorTableElement`.
+ if (!aContent.GetParent()) {
+ return nullptr;
+ }
+ for (Element* element : aContent.InclusiveAncestorsOfType<Element>()) {
+ if (HTMLEditUtils::IsTable(element)) {
+ return element;
+ }
+ }
+ return nullptr;
+ }
+
+ static Element* GetInclusiveAncestorAnyTableElement(
+ const nsIContent& aContent) {
+ for (Element* parent : aContent.InclusiveAncestorsOfType<Element>()) {
+ if (HTMLEditUtils::IsAnyTableElement(parent)) {
+ return parent;
+ }
+ }
+ return nullptr;
+ }
+
+ [[nodiscard]] static Element* GetClosestAncestorAnyListElement(
+ const nsIContent& aContent);
+ [[nodiscard]] static Element* GetClosestInclusiveAncestorAnyListElement(
+ const nsIContent& aContent);
+
+ /**
+ * GetClosestAncestorListItemElement() returns a list item element if
+ * aContent or its ancestor in editing host is one. However, this won't
+ * cross table related element.
+ */
+ static Element* GetClosestAncestorListItemElement(
+ const nsIContent& aContent, const Element* aAncestorLimit = nullptr) {
+ MOZ_ASSERT_IF(aAncestorLimit,
+ aContent.IsInclusiveDescendantOf(aAncestorLimit));
+
+ if (HTMLEditUtils::IsListItem(&aContent)) {
+ return const_cast<Element*>(aContent.AsElement());
+ }
+
+ for (Element* parentElement : aContent.AncestorsOfType<Element>()) {
+ if (HTMLEditUtils::IsAnyTableElement(parentElement)) {
+ return nullptr;
+ }
+ if (HTMLEditUtils::IsListItem(parentElement)) {
+ return parentElement;
+ }
+ if (parentElement == aAncestorLimit) {
+ return nullptr;
+ }
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetRangeSelectingAllContentInAllListItems() returns a range which selects
+ * from start of the first list item to end of the last list item of
+ * aListElement. Note that the result may be in different list element if
+ * aListElement has child list element(s) directly.
+ */
+ template <typename EditorDOMRangeType>
+ static EditorDOMRangeType GetRangeSelectingAllContentInAllListItems(
+ const Element& aListElement) {
+ MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+ Element* firstListItem =
+ HTMLEditUtils::GetFirstListItemElement(aListElement);
+ Element* lastListItem = HTMLEditUtils::GetLastListItemElement(aListElement);
+ MOZ_ASSERT_IF(firstListItem, lastListItem);
+ MOZ_ASSERT_IF(!firstListItem, !lastListItem);
+ if (!firstListItem || !lastListItem) {
+ return EditorDOMRangeType();
+ }
+ return EditorDOMRangeType(
+ typename EditorDOMRangeType::PointType(firstListItem, 0u),
+ EditorDOMRangeType::PointType::AtEndOf(*lastListItem));
+ }
+
+ /**
+ * GetFirstListItemElement() returns the first list item element in the
+ * pre-order tree traversal of the DOM.
+ */
+ static Element* GetFirstListItemElement(const Element& aListElement) {
+ MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+ for (nsIContent* maybeFirstListItem = aListElement.GetFirstChild();
+ maybeFirstListItem;
+ maybeFirstListItem = maybeFirstListItem->GetNextNode(&aListElement)) {
+ if (HTMLEditUtils::IsListItem(maybeFirstListItem)) {
+ return maybeFirstListItem->AsElement();
+ }
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetLastListItemElement() returns the last list item element in the
+ * post-order tree traversal of the DOM. I.e., returns the last list
+ * element whose close tag appears at last.
+ */
+ static Element* GetLastListItemElement(const Element& aListElement) {
+ MOZ_ASSERT(HTMLEditUtils::IsAnyListElement(&aListElement));
+ for (nsIContent* maybeLastListItem = aListElement.GetLastChild();
+ maybeLastListItem;) {
+ if (HTMLEditUtils::IsListItem(maybeLastListItem)) {
+ return maybeLastListItem->AsElement();
+ }
+ if (maybeLastListItem->HasChildren()) {
+ maybeLastListItem = maybeLastListItem->GetLastChild();
+ continue;
+ }
+ if (maybeLastListItem->GetPreviousSibling()) {
+ maybeLastListItem = maybeLastListItem->GetPreviousSibling();
+ continue;
+ }
+ for (Element* parent = maybeLastListItem->GetParentElement(); parent;
+ parent = parent->GetParentElement()) {
+ maybeLastListItem = nullptr;
+ if (parent == &aListElement) {
+ return nullptr;
+ }
+ if (parent->GetPreviousSibling()) {
+ maybeLastListItem = parent->GetPreviousSibling();
+ break;
+ }
+ }
+ }
+ return nullptr;
+ }
+
+ /**
+ * GetFirstTableCellElementChild() and GetLastTableCellElementChild()
+ * return the first/last element child of <tr> element if it's a table
+ * cell element.
+ */
+ static Element* GetFirstTableCellElementChild(
+ const Element& aTableRowElement) {
+ MOZ_ASSERT(aTableRowElement.IsHTMLElement(nsGkAtoms::tr));
+ Element* firstElementChild = aTableRowElement.GetFirstElementChild();
+ return firstElementChild && HTMLEditUtils::IsTableCell(firstElementChild)
+ ? firstElementChild
+ : nullptr;
+ }
+ static Element* GetLastTableCellElementChild(
+ const Element& aTableRowElement) {
+ MOZ_ASSERT(aTableRowElement.IsHTMLElement(nsGkAtoms::tr));
+ Element* lastElementChild = aTableRowElement.GetLastElementChild();
+ return lastElementChild && HTMLEditUtils::IsTableCell(lastElementChild)
+ ? lastElementChild
+ : nullptr;
+ }
+
+ /**
+ * GetPreviousTableCellElementSibling() and GetNextTableCellElementSibling()
+ * return a table cell element of previous/next element sibling of given
+ * content node if and only if the element sibling is a table cell element.
+ */
+ static Element* GetPreviousTableCellElementSibling(
+ const nsIContent& aChildOfTableRow) {
+ MOZ_ASSERT(aChildOfTableRow.GetParentNode());
+ MOZ_ASSERT(aChildOfTableRow.GetParentNode()->IsHTMLElement(nsGkAtoms::tr));
+ Element* previousElementSibling =
+ aChildOfTableRow.GetPreviousElementSibling();
+ return previousElementSibling &&
+ HTMLEditUtils::IsTableCell(previousElementSibling)
+ ? previousElementSibling
+ : nullptr;
+ }
+ static Element* GetNextTableCellElementSibling(
+ const nsIContent& aChildOfTableRow) {
+ MOZ_ASSERT(aChildOfTableRow.GetParentNode());
+ MOZ_ASSERT(aChildOfTableRow.GetParentNode()->IsHTMLElement(nsGkAtoms::tr));
+ Element* nextElementSibling = aChildOfTableRow.GetNextElementSibling();
+ return nextElementSibling && HTMLEditUtils::IsTableCell(nextElementSibling)
+ ? nextElementSibling
+ : nullptr;
+ }
+
+ /**
+ * GetMostDistantAncestorInlineElement() returns the most distant ancestor
+ * inline element between aContent and the aEditingHost. Even if aEditingHost
+ * is an inline element, this method never returns aEditingHost as the result.
+ * Optionally, you can specify ancestor limiter content node. This guarantees
+ * that the result is a descendant of aAncestorLimiter if aContent is a
+ * descendant of aAncestorLimiter.
+ */
+ static nsIContent* GetMostDistantAncestorInlineElement(
+ const nsIContent& aContent, const Element* aEditingHost = nullptr,
+ const nsIContent* aAncestorLimiter = nullptr) {
+ if (HTMLEditUtils::IsBlockElement(aContent)) {
+ return nullptr;
+ }
+
+ // If aNode is the editing host itself, there is no modifiable inline
+ // parent.
+ if (&aContent == aEditingHost || &aContent == aAncestorLimiter) {
+ return nullptr;
+ }
+
+ // If aNode is outside of the <body> element, we don't support to edit
+ // such elements for now.
+ // XXX This should be MOZ_ASSERT after fixing bug 1413131 for avoiding
+ // calling this expensive method.
+ if (aEditingHost && !aContent.IsInclusiveDescendantOf(aEditingHost)) {
+ return nullptr;
+ }
+
+ if (!aContent.GetParent()) {
+ return const_cast<nsIContent*>(&aContent);
+ }
+
+ // Looks for the highest inline parent in the editing host.
+ nsIContent* topMostInlineContent = const_cast<nsIContent*>(&aContent);
+ for (Element* element : aContent.AncestorsOfType<Element>()) {
+ if (element == aEditingHost || element == aAncestorLimiter ||
+ !HTMLEditUtils::IsInlineElement(*element)) {
+ break;
+ }
+ topMostInlineContent = element;
+ }
+ return topMostInlineContent;
+ }
+
+ /**
+ * GetMostDistantAncestorEditableEmptyInlineElement() returns most distant
+ * ancestor which only has aEmptyContent or its ancestor, editable and
+ * inline element.
+ */
+ static Element* GetMostDistantAncestorEditableEmptyInlineElement(
+ const nsIContent& aEmptyContent, const Element* aEditingHost = nullptr,
+ const nsIContent* aAncestorLimiter = nullptr) {
+ if (&aEmptyContent == aEditingHost || &aEmptyContent == aAncestorLimiter) {
+ return nullptr;
+ }
+ nsIContent* lastEmptyContent = const_cast<nsIContent*>(&aEmptyContent);
+ for (Element* element : aEmptyContent.AncestorsOfType<Element>()) {
+ if (element == aEditingHost || element == aAncestorLimiter) {
+ break;
+ }
+ if (!HTMLEditUtils::IsInlineElement(*element) ||
+ !HTMLEditUtils::IsSimplyEditableNode(*element)) {
+ break;
+ }
+ if (element->GetChildCount() > 1) {
+ for (const nsIContent* child = element->GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (child == lastEmptyContent || child->IsComment()) {
+ continue;
+ }
+ return lastEmptyContent != &aEmptyContent
+ ? lastEmptyContent->AsElement()
+ : nullptr;
+ }
+ }
+ lastEmptyContent = element;
+ }
+ return lastEmptyContent != &aEmptyContent ? lastEmptyContent->AsElement()
+ : nullptr;
+ }
+
+ /**
+ * GetElementIfOnlyOneSelected() returns an element if aRange selects only
+ * the element node (and its descendants).
+ */
+ static Element* GetElementIfOnlyOneSelected(const AbstractRange& aRange) {
+ return GetElementIfOnlyOneSelected(EditorRawDOMRange(aRange));
+ }
+ template <typename EditorDOMPointType>
+ static Element* GetElementIfOnlyOneSelected(
+ const EditorDOMRangeBase<EditorDOMPointType>& aRange) {
+ if (!aRange.IsPositioned() || aRange.Collapsed()) {
+ return nullptr;
+ }
+ const auto& start = aRange.StartRef();
+ const auto& end = aRange.EndRef();
+ if (NS_WARN_IF(!start.IsSetAndValid()) ||
+ NS_WARN_IF(!end.IsSetAndValid()) ||
+ start.GetContainer() != end.GetContainer()) {
+ return nullptr;
+ }
+ nsIContent* childAtStart = start.GetChild();
+ if (!childAtStart || !childAtStart->IsElement()) {
+ return nullptr;
+ }
+ // If start child is not the last sibling and only if end child is its
+ // next sibling, the start child is selected.
+ if (childAtStart->GetNextSibling()) {
+ return childAtStart->GetNextSibling() == end.GetChild()
+ ? childAtStart->AsElement()
+ : nullptr;
+ }
+ // If start child is the last sibling and only if no child at the end,
+ // the start child is selected.
+ return !end.GetChild() ? childAtStart->AsElement() : nullptr;
+ }
+
+ static Element* GetTableCellElementIfOnlyOneSelected(
+ const AbstractRange& aRange) {
+ Element* element = HTMLEditUtils::GetElementIfOnlyOneSelected(aRange);
+ return element && HTMLEditUtils::IsTableCell(element) ? element : nullptr;
+ }
+
+ /**
+ * GetFirstSelectedTableCellElement() returns a table cell element (i.e.,
+ * `<td>` or `<th>` if and only if first selection range selects only a
+ * table cell element.
+ */
+ static Element* GetFirstSelectedTableCellElement(
+ const Selection& aSelection) {
+ if (!aSelection.RangeCount()) {
+ return nullptr;
+ }
+ const nsRange* firstRange = aSelection.GetRangeAt(0);
+ if (NS_WARN_IF(!firstRange) || NS_WARN_IF(!firstRange->IsPositioned())) {
+ return nullptr;
+ }
+ return GetTableCellElementIfOnlyOneSelected(*firstRange);
+ }
+
+ /**
+ * GetInclusiveFirstChildWhichHasOneChild() returns the deepest element whose
+ * tag name is one of `aFirstElementName` and `aOtherElementNames...` if and
+ * only if the elements have only one child node. In other words, when
+ * this method meets an element which does not matches any of the tag name
+ * or it has no children or 2+ children.
+ *
+ * XXX This method must be implemented without treating edge cases. So, the
+ * behavior is odd. E.g., why can we ignore non-editable node at counting
+ * each children? Why do we dig non-editable aNode or first child of its
+ * descendants?
+ */
+ template <typename FirstElementName, typename... OtherElementNames>
+ static Element* GetInclusiveDeepestFirstChildWhichHasOneChild(
+ const nsINode& aNode, const WalkTreeOptions& aOptions,
+ FirstElementName aFirstElementName,
+ OtherElementNames... aOtherElementNames) {
+ if (!aNode.IsElement()) {
+ return nullptr;
+ }
+ Element* parentElement = nullptr;
+ for (nsIContent* content = const_cast<nsIContent*>(aNode.AsContent());
+ content && content->IsElement() &&
+ content->IsAnyOfHTMLElements(aFirstElementName, aOtherElementNames...);
+ // XXX Why do we scan only the first child of every element? If it's
+ // not editable, why do we ignore it when aOptions specifies so.
+ content = content->GetFirstChild()) {
+ if (HTMLEditUtils::CountChildren(*content, aOptions) != 1) {
+ return content->AsElement();
+ }
+ parentElement = content->AsElement();
+ }
+ return parentElement;
+ }
+
+ /**
+ * Get the first <br> element in aElement. This scans only leaf nodes so
+ * if a <br> element has children illegally, it'll be ignored.
+ *
+ * @param aElement The element which may have a <br> element.
+ * @return First <br> element node in aElement if there is.
+ */
+ static dom::HTMLBRElement* GetFirstBRElement(const dom::Element& aElement) {
+ for (nsIContent* content = HTMLEditUtils::GetFirstLeafContent(
+ aElement, {LeafNodeType::OnlyLeafNode});
+ content; content = HTMLEditUtils::GetNextContent(
+ *content,
+ {WalkTreeOption::IgnoreDataNodeExceptText,
+ WalkTreeOption::IgnoreWhiteSpaceOnlyText},
+ &aElement)) {
+ if (auto* brElement = dom::HTMLBRElement::FromNode(*content)) {
+ return brElement;
+ }
+ }
+ return nullptr;
+ }
+
+ /**
+ * Return last <br> element or last text node ending with a preserved line
+ * break of/before aBlockElement.
+ */
+ enum ScanLineBreak {
+ AtEndOfBlock,
+ BeforeBlock,
+ };
+ static nsIContent* GetUnnecessaryLineBreakContent(
+ const Element& aBlockElement, ScanLineBreak aScanLineBreak);
+
+ /**
+ * IsInTableCellSelectionMode() returns true when Gecko's editor thinks that
+ * selection is in a table cell selection mode.
+ * Note that Gecko's editor traditionally treats selection as in table cell
+ * selection mode when first range selects a table cell element. I.e., even
+ * if `nsFrameSelection` is not in table cell selection mode, this may return
+ * true.
+ */
+ static bool IsInTableCellSelectionMode(const Selection& aSelection) {
+ return GetFirstSelectedTableCellElement(aSelection) != nullptr;
+ }
+
+ static EditAction GetEditActionForInsert(const nsAtom& aTagName);
+ static EditAction GetEditActionForRemoveList(const nsAtom& aTagName);
+ static EditAction GetEditActionForInsert(const Element& aElement);
+ static EditAction GetEditActionForFormatText(const nsAtom& aProperty,
+ const nsAtom* aAttribute,
+ bool aToSetStyle);
+ static EditAction GetEditActionForAlignment(const nsAString& aAlignType);
+
+ /**
+ * GetPreviousNonCollapsibleCharOffset() returns offset of previous
+ * character which is not collapsible white-space characters.
+ */
+ enum class WalkTextOption {
+ TreatNBSPsCollapsible,
+ };
+ using WalkTextOptions = EnumSet<WalkTextOption>;
+ static Maybe<uint32_t> GetPreviousNonCollapsibleCharOffset(
+ const EditorDOMPointInText& aPoint,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ MOZ_ASSERT(aPoint.IsSetAndValid());
+ return GetPreviousNonCollapsibleCharOffset(
+ *aPoint.ContainerAs<Text>(), aPoint.Offset(), aWalkTextOptions);
+ }
+ static Maybe<uint32_t> GetPreviousNonCollapsibleCharOffset(
+ const Text& aTextNode, uint32_t aOffset,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ const bool isWhiteSpaceCollapsible =
+ !EditorUtils::IsWhiteSpacePreformatted(aTextNode);
+ const bool isNewLineCollapsible =
+ !EditorUtils::IsNewLinePreformatted(aTextNode);
+ const bool isNBSPCollapsible =
+ isWhiteSpaceCollapsible &&
+ aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible);
+ const nsTextFragment& textFragment = aTextNode.TextFragment();
+ MOZ_ASSERT(aOffset <= textFragment.GetLength());
+ for (uint32_t i = aOffset; i; i--) {
+ // TODO: Perhaps, nsTextFragment should have scanner methods because
+ // the text may be in per-one-byte storage or per-two-byte storage,
+ // and `CharAt` needs to check it everytime.
+ switch (textFragment.CharAt(i - 1)) {
+ case HTMLEditUtils::kSpace:
+ case HTMLEditUtils::kCarriageReturn:
+ case HTMLEditUtils::kTab:
+ if (!isWhiteSpaceCollapsible) {
+ return Some(i - 1);
+ }
+ break;
+ case HTMLEditUtils::kNewLine:
+ if (!isNewLineCollapsible) {
+ return Some(i - 1);
+ }
+ break;
+ case HTMLEditUtils::kNBSP:
+ if (!isNBSPCollapsible) {
+ return Some(i - 1);
+ }
+ break;
+ default:
+ MOZ_ASSERT(!nsCRT::IsAsciiSpace(textFragment.CharAt(i - 1)));
+ return Some(i - 1);
+ }
+ }
+ return Nothing();
+ }
+
+ /**
+ * GetNextNonCollapsibleCharOffset() returns offset of next character which is
+ * not collapsible white-space characters.
+ */
+ static Maybe<uint32_t> GetNextNonCollapsibleCharOffset(
+ const EditorDOMPointInText& aPoint,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ MOZ_ASSERT(aPoint.IsSetAndValid());
+ return GetNextNonCollapsibleCharOffset(*aPoint.ContainerAs<Text>(),
+ aPoint.Offset(), aWalkTextOptions);
+ }
+ static Maybe<uint32_t> GetNextNonCollapsibleCharOffset(
+ const Text& aTextNode, uint32_t aOffset,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ return GetInclusiveNextNonCollapsibleCharOffset(aTextNode, aOffset + 1,
+ aWalkTextOptions);
+ }
+
+ /**
+ * GetInclusiveNextNonCollapsibleCharOffset() returns offset of inclusive next
+ * character which is not collapsible white-space characters.
+ */
+ static Maybe<uint32_t> GetInclusiveNextNonCollapsibleCharOffset(
+ const EditorDOMPointInText& aPoint,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ MOZ_ASSERT(aPoint.IsSetAndValid());
+ return GetInclusiveNextNonCollapsibleCharOffset(
+ *aPoint.ContainerAs<Text>(), aPoint.Offset(), aWalkTextOptions);
+ }
+ static Maybe<uint32_t> GetInclusiveNextNonCollapsibleCharOffset(
+ const Text& aTextNode, uint32_t aOffset,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ const bool isWhiteSpaceCollapsible =
+ !EditorUtils::IsWhiteSpacePreformatted(aTextNode);
+ const bool isNewLineCollapsible =
+ !EditorUtils::IsNewLinePreformatted(aTextNode);
+ const bool isNBSPCollapsible =
+ isWhiteSpaceCollapsible &&
+ aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible);
+ const nsTextFragment& textFragment = aTextNode.TextFragment();
+ MOZ_ASSERT(aOffset <= textFragment.GetLength());
+ for (uint32_t i = aOffset; i < textFragment.GetLength(); i++) {
+ // TODO: Perhaps, nsTextFragment should have scanner methods because
+ // the text may be in per-one-byte storage or per-two-byte storage,
+ // and `CharAt` needs to check it everytime.
+ switch (textFragment.CharAt(i)) {
+ case HTMLEditUtils::kSpace:
+ case HTMLEditUtils::kCarriageReturn:
+ case HTMLEditUtils::kTab:
+ if (!isWhiteSpaceCollapsible) {
+ return Some(i);
+ }
+ break;
+ case HTMLEditUtils::kNewLine:
+ if (!isNewLineCollapsible) {
+ return Some(i);
+ }
+ break;
+ case HTMLEditUtils::kNBSP:
+ if (!isNBSPCollapsible) {
+ return Some(i);
+ }
+ break;
+ default:
+ MOZ_ASSERT(!nsCRT::IsAsciiSpace(textFragment.CharAt(i)));
+ return Some(i);
+ }
+ }
+ return Nothing();
+ }
+
+ /**
+ * GetFirstWhiteSpaceOffsetCollapsedWith() returns first collapsible
+ * white-space offset which is collapsed with a white-space at the given
+ * position. I.e., the character at the position must be a collapsible
+ * white-space.
+ */
+ static uint32_t GetFirstWhiteSpaceOffsetCollapsedWith(
+ const EditorDOMPointInText& aPoint,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ MOZ_ASSERT(aPoint.IsSetAndValid());
+ MOZ_ASSERT(!aPoint.IsEndOfContainer());
+ MOZ_ASSERT_IF(
+ aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible),
+ aPoint.IsCharCollapsibleASCIISpaceOrNBSP());
+ MOZ_ASSERT_IF(
+ !aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible),
+ aPoint.IsCharCollapsibleASCIISpace());
+ return GetFirstWhiteSpaceOffsetCollapsedWith(
+ *aPoint.ContainerAs<Text>(), aPoint.Offset(), aWalkTextOptions);
+ }
+ static uint32_t GetFirstWhiteSpaceOffsetCollapsedWith(
+ const Text& aTextNode, uint32_t aOffset,
+ const WalkTextOptions& aWalkTextOptions = {}) {
+ MOZ_ASSERT(aOffset < aTextNode.TextLength());
+ MOZ_ASSERT_IF(
+ aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible),
+ EditorRawDOMPoint(&aTextNode, aOffset)
+ .IsCharCollapsibleASCIISpaceOrNBSP());
+ MOZ_ASSERT_IF(
+ !aWalkTextOptions.contains(WalkTextOption::TreatNBSPsCollapsible),
+ EditorRawDOMPoint(&aTextNode, aOffset).IsCharCollapsibleASCIISpace());
+ if (!aOffset) {
+ return 0;
+ }
+ Maybe<uint32_t> previousVisibleCharOffset =
+ GetPreviousNonCollapsibleCharOffset(aTextNode, aOffset,
+ aWalkTextOptions);
+ return previousVisibleCharOffset.isSome()
+ ? previousVisibleCharOffset.value() + 1
+ : 0;
+ }
+
+ /**
+ * GetPreviousPreformattedNewLineInTextNode() returns a point which points
+ * previous preformatted linefeed if there is and aPoint is in a text node.
+ * If the node's linefeed characters are not preformatted or aPoint is not
+ * in a text node, this returns unset DOM point.
+ */
+ template <typename EditorDOMPointType, typename ArgEditorDOMPointType>
+ static EditorDOMPointType GetPreviousPreformattedNewLineInTextNode(
+ const ArgEditorDOMPointType& aPoint) {
+ if (!aPoint.IsInTextNode() || aPoint.IsStartOfContainer() ||
+ !EditorUtils::IsNewLinePreformatted(
+ *aPoint.template ContainerAs<Text>())) {
+ return EditorDOMPointType();
+ }
+ Text* textNode = aPoint.template ContainerAs<Text>();
+ const nsTextFragment& textFragment = textNode->TextFragment();
+ MOZ_ASSERT(aPoint.Offset() <= textFragment.GetLength());
+ for (uint32_t offset = aPoint.Offset(); offset; --offset) {
+ if (textFragment.CharAt(offset - 1) == HTMLEditUtils::kNewLine) {
+ return EditorDOMPointType(textNode, offset - 1);
+ }
+ }
+ return EditorDOMPointType();
+ }
+
+ /**
+ * GetInclusiveNextPreformattedNewLineInTextNode() returns a point which
+ * points inclusive next preformatted linefeed if there is and aPoint is in a
+ * text node. If the node's linefeed characters are not preformatted or aPoint
+ * is not in a text node, this returns unset DOM point.
+ */
+ template <typename EditorDOMPointType, typename ArgEditorDOMPointType>
+ static EditorDOMPointType GetInclusiveNextPreformattedNewLineInTextNode(
+ const ArgEditorDOMPointType& aPoint) {
+ if (!aPoint.IsInTextNode() || aPoint.IsEndOfContainer() ||
+ !EditorUtils::IsNewLinePreformatted(
+ *aPoint.template ContainerAs<Text>())) {
+ return EditorDOMPointType();
+ }
+ Text* textNode = aPoint.template ContainerAs<Text>();
+ const nsTextFragment& textFragment = textNode->TextFragment();
+ for (uint32_t offset = aPoint.Offset(); offset < textFragment.GetLength();
+ ++offset) {
+ if (textFragment.CharAt(offset) == HTMLEditUtils::kNewLine) {
+ return EditorDOMPointType(textNode, offset);
+ }
+ }
+ return EditorDOMPointType();
+ }
+
+ /**
+ * GetGoodCaretPointFor() returns a good point to collapse `Selection`
+ * after handling edit action with aDirectionAndAmount.
+ *
+ * @param aContent The content where you want to put caret
+ * around.
+ * @param aDirectionAndAmount Muse be one of eNext, eNextWord, eToEndOfLine,
+ * ePrevious, ePreviousWord and eToBeggingOfLine.
+ * Set the direction of handled edit action.
+ */
+ template <typename EditorDOMPointType>
+ static EditorDOMPointType GetGoodCaretPointFor(
+ nsIContent& aContent, nsIEditor::EDirection aDirectionAndAmount) {
+ MOZ_ASSERT(nsIEditor::EDirectionIsValidExceptNone(aDirectionAndAmount));
+
+ // XXX Why don't we check whether the candidate position is enable or not?
+ // When the result is not editable point, caret will be enclosed in
+ // the non-editable content.
+
+ // If we can put caret in aContent, return start or end in it.
+ if (aContent.IsText() || HTMLEditUtils::IsContainerNode(aContent) ||
+ NS_WARN_IF(!aContent.GetParentNode())) {
+ return EditorDOMPointType(
+ &aContent, nsIEditor::DirectionIsDelete(aDirectionAndAmount)
+ ? 0
+ : aContent.Length());
+ }
+
+ // If we are going forward, put caret at aContent itself.
+ if (nsIEditor::DirectionIsDelete(aDirectionAndAmount)) {
+ return EditorDOMPointType(&aContent);
+ }
+
+ // If we are going backward, put caret to next node unless aContent is an
+ // invisible `<br>` element.
+ // XXX Shouldn't we put caret to first leaf of the next node?
+ if (!HTMLEditUtils::IsInvisibleBRElement(aContent)) {
+ EditorDOMPointType ret(EditorDOMPointType::After(aContent));
+ NS_WARNING_ASSERTION(ret.IsSet(), "Failed to set after aContent");
+ return ret;
+ }
+
+ // Otherwise, we should put caret at the invisible `<br>` element.
+ return EditorDOMPointType(&aContent);
+ }
+
+ /**
+ * GetBetterInsertionPointFor() returns better insertion point to insert
+ * aContentToInsert.
+ *
+ * @param aContentToInsert The content to insert.
+ * @param aPointToInsert A candidate point to insert the node.
+ * @param aEditingHost The editing host containing aPointToInsert.
+ * @return Better insertion point if next visible node
+ * is a <br> element and previous visible node
+ * is neither none, another <br> element nor
+ * different block level element.
+ */
+ template <typename EditorDOMPointType, typename EditorDOMPointTypeInput>
+ static EditorDOMPointType GetBetterInsertionPointFor(
+ const nsIContent& aContentToInsert,
+ const EditorDOMPointTypeInput& aPointToInsert,
+ const Element& aEditingHost);
+
+ /**
+ * GetBetterCaretPositionToInsertText() returns better point to put caret
+ * if aPoint is near a text node or in non-container node.
+ */
+ template <typename EditorDOMPointType, typename EditorDOMPointTypeInput>
+ static EditorDOMPointType GetBetterCaretPositionToInsertText(
+ const EditorDOMPointTypeInput& aPoint, const Element& aEditingHost);
+
+ /**
+ * ComputePointToPutCaretInElementIfOutside() returns a good point in aElement
+ * to put caret if aCurrentPoint is outside of aElement.
+ *
+ * @param aElement The result is a point in aElement.
+ * @param aCurrentPoint The current (candidate) caret point. Only if this
+ * is outside aElement, returns a point in aElement.
+ */
+ template <typename EditorDOMPointType, typename EditorDOMPointTypeInput>
+ static Result<EditorDOMPointType, nsresult>
+ ComputePointToPutCaretInElementIfOutside(
+ const Element& aElement, const EditorDOMPointTypeInput& aCurrentPoint);
+
+ /**
+ * Content-based query returns true if
+ * <mHTMLProperty mAttribute=mAttributeValue> effects aContent. If there is
+ * such a element, but another element whose attribute value does not match
+ * with mAttributeValue is closer ancestor of aContent, then the distant
+ * ancestor does not effect aContent.
+ *
+ * @param aContent The target of the query
+ * @param aStyle The style which queries a representing element.
+ * @param aValue Optional, the value of aStyle.mAttribute, example: blue
+ * in <font color="blue"> May be null. Ignored if
+ * aStyle.mAttribute is null.
+ * @param aOutValue [OUT] the value of the attribute, if returns true
+ * @return true if <mHTMLProperty mAttribute=mAttributeValue>
+ * effects aContent.
+ */
+ [[nodiscard]] static bool IsInlineStyleSetByElement(
+ const nsIContent& aContent, const EditorInlineStyle& aStyle,
+ const nsAString* aValue, nsAString* aOutValue = nullptr);
+
+ /**
+ * CollectAllChildren() collects all child nodes of aParentNode.
+ */
+ static void CollectAllChildren(
+ const nsINode& aParentNode,
+ nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents) {
+ MOZ_ASSERT(aOutArrayOfContents.IsEmpty());
+ aOutArrayOfContents.SetCapacity(aParentNode.GetChildCount());
+ for (nsIContent* childContent = aParentNode.GetFirstChild(); childContent;
+ childContent = childContent->GetNextSibling()) {
+ aOutArrayOfContents.AppendElement(*childContent);
+ }
+ }
+
+ /**
+ * CollectChildren() collects child nodes of aNode (starting from
+ * first editable child, but may return non-editable children after it).
+ *
+ * @param aNode Parent node of retrieving children.
+ * @param aOutArrayOfContents [out] This method will inserts found children
+ * into this array.
+ * @param aIndexToInsertChildren Starting from this index, found
+ * children will be inserted to the array.
+ * @param aOptions Options to scan the children.
+ * @return Number of found children.
+ */
+ static size_t CollectChildren(
+ const nsINode& aNode,
+ nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents,
+ const CollectChildrenOptions& aOptions) {
+ return HTMLEditUtils::CollectChildren(aNode, aOutArrayOfContents, 0u,
+ aOptions);
+ }
+ static size_t CollectChildren(
+ const nsINode& aNode,
+ nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents,
+ size_t aIndexToInsertChildren, const CollectChildrenOptions& aOptions);
+
+ /**
+ * CollectEmptyInlineContainerDescendants() appends empty inline elements in
+ * aNode to aOutArrayOfContents. Although it's array of nsIContent, the
+ * instance will be elements.
+ *
+ * @param aNode The node whose descendants may have empty inline
+ * elements.
+ * @param aOutArrayOfContents [out] This method will append found descendants
+ * into this array.
+ * @param aOptions The option which element should be treated as
+ * empty.
+ * @return Number of found elements.
+ */
+ static size_t CollectEmptyInlineContainerDescendants(
+ const nsINode& aNode,
+ nsTArray<OwningNonNull<nsIContent>>& aOutArrayOfContents,
+ const EmptyCheckOptions& aOptions);
+
+ /**
+ * Check whether aElement has attributes except the name aAttribute and
+ * "_moz_*" attributes.
+ */
+ [[nodiscard]] static bool ElementHasAttribute(const Element& aElement) {
+ return ElementHasAttributeExcept(aElement, *nsGkAtoms::_empty,
+ *nsGkAtoms::empty, *nsGkAtoms::_empty);
+ }
+ [[nodiscard]] static bool ElementHasAttributeExcept(
+ const Element& aElement, const nsAtom& aAttribute) {
+ return ElementHasAttributeExcept(aElement, aAttribute, *nsGkAtoms::_empty,
+ *nsGkAtoms::empty);
+ }
+ [[nodiscard]] static bool ElementHasAttributeExcept(
+ const Element& aElement, const nsAtom& aAttribute1,
+ const nsAtom& aAttribute2) {
+ return ElementHasAttributeExcept(aElement, aAttribute1, aAttribute2,
+ *nsGkAtoms::empty);
+ }
+ [[nodiscard]] static bool ElementHasAttributeExcept(
+ const Element& aElement, const nsAtom& aAttribute1,
+ const nsAtom& aAttribute2, const nsAtom& aAttribute3);
+
+ /**
+ * Returns EditorDOMPoint which points deepest editable start/end point of
+ * aNode. If a node is a container node and first/last child is editable,
+ * returns the child's start or last point recursively.
+ */
+ enum class InvisibleText { Recognize, Skip };
+ template <typename EditorDOMPointType>
+ [[nodiscard]] static EditorDOMPointType GetDeepestEditableStartPointOf(
+ const nsIContent& aContent,
+ InvisibleText aInvisibleText = InvisibleText::Recognize) {
+ if (NS_WARN_IF(!EditorUtils::IsEditableContent(
+ aContent, EditorBase::EditorType::HTML))) {
+ return EditorDOMPointType();
+ }
+ EditorDOMPointType result(&aContent, 0u);
+ while (true) {
+ nsIContent* firstChild = result.GetContainer()->GetFirstChild();
+ if (!firstChild) {
+ break;
+ }
+ // If the caller wants to skip invisible white-spaces, we should skip
+ // invisible text nodes.
+ if (aInvisibleText == InvisibleText::Skip && firstChild->IsText() &&
+ EditorUtils::IsEditableContent(*firstChild,
+ EditorBase::EditorType::HTML) &&
+ !HTMLEditUtils::IsVisibleTextNode(*firstChild->AsText())) {
+ for (nsIContent* nextSibling = firstChild->GetNextSibling();
+ nextSibling; nextSibling = nextSibling->GetNextSibling()) {
+ if (!nextSibling->IsText() ||
+ // We know its previous sibling is very start of a block.
+ // Therefore, we only need to scan the text here.
+ HTMLEditUtils::GetInclusiveNextNonCollapsibleCharOffset(
+ *firstChild->AsText(), 0u)
+ .isSome()) {
+ firstChild = nextSibling;
+ break;
+ }
+ }
+ }
+ if ((!firstChild->IsText() &&
+ !HTMLEditUtils::IsContainerNode(*firstChild)) ||
+ !EditorUtils::IsEditableContent(*firstChild,
+ EditorBase::EditorType::HTML)) {
+ break;
+ }
+ if (aInvisibleText == InvisibleText::Skip && firstChild->IsText()) {
+ result.Set(firstChild,
+ HTMLEditUtils::GetInclusiveNextNonCollapsibleCharOffset(
+ *firstChild->AsText(), 0u)
+ .valueOr(0u));
+ break;
+ }
+ result.Set(firstChild, 0u);
+ }
+ return result;
+ }
+ template <typename EditorDOMPointType>
+ [[nodiscard]] static EditorDOMPointType GetDeepestEditableEndPointOf(
+ const nsIContent& aContent,
+ InvisibleText aInvisibleText = InvisibleText::Recognize) {
+ if (NS_WARN_IF(!EditorUtils::IsEditableContent(
+ aContent, EditorBase::EditorType::HTML))) {
+ return EditorDOMPointType();
+ }
+ auto result = EditorDOMPointType::AtEndOf(aContent);
+ while (true) {
+ nsIContent* lastChild = result.GetContainer()->GetLastChild();
+ if (!lastChild) {
+ break;
+ }
+ // If the caller wants to skip invisible white-spaces, we should skip
+ // invisible text nodes.
+ if (aInvisibleText == InvisibleText::Skip && lastChild->IsText() &&
+ EditorUtils::IsEditableContent(*lastChild,
+ EditorBase::EditorType::HTML) &&
+ !HTMLEditUtils::IsVisibleTextNode(*lastChild->AsText())) {
+ for (nsIContent* nextSibling = lastChild->GetPreviousSibling();
+ nextSibling; nextSibling = nextSibling->GetPreviousSibling()) {
+ if (!nextSibling->IsText() ||
+ // We know its previous sibling is very start of a block.
+ // Therefore, we only need to scan the text here.
+ HTMLEditUtils::GetPreviousNonCollapsibleCharOffset(
+ *lastChild->AsText(), lastChild->AsText()->TextDataLength())
+ .isSome()) {
+ lastChild = nextSibling;
+ break;
+ }
+ }
+ }
+ if ((!lastChild->IsText() &&
+ !HTMLEditUtils::IsContainerNode(*lastChild)) ||
+ !EditorUtils::IsEditableContent(*lastChild,
+ EditorBase::EditorType::HTML)) {
+ break;
+ }
+ if (aInvisibleText == InvisibleText::Skip && lastChild->IsText()) {
+ Maybe<uint32_t> visibleCharOffset =
+ HTMLEditUtils::GetPreviousNonCollapsibleCharOffset(
+ *lastChild->AsText(), lastChild->AsText()->TextDataLength());
+ if (visibleCharOffset.isNothing()) {
+ result = EditorDOMPointType::AtEndOf(*lastChild);
+ break;
+ }
+ result.Set(lastChild, visibleCharOffset.value() + 1u);
+ break;
+ }
+ result = EditorDOMPointType::AtEndOf(*lastChild);
+ }
+ return result;
+ }
+
+ /**
+ * Get `#[0-9a-f]{6}` style HTML color value if aColorValue is valid value
+ * for color-specifying attribute. The result is useful to set attributes
+ * of HTML elements which take a color value.
+ *
+ * @param aColorValue [in] Should be one of `#[0-9a-fA-Z]{3}`,
+ * `#[0-9a-fA-Z]{3}` or a color name.
+ * @param aNormalizedValue [out] Set to `#[0-9a-f]{6}` style color code
+ * if this returns true. Otherwise, returns
+ * aColorValue as-is.
+ * @return true if aColorValue is valid. Otherwise, false.
+ */
+ static bool GetNormalizedHTMLColorValue(const nsAString& aColorValue,
+ nsAString& aNormalizedValue);
+
+ /**
+ * Return true if aColorValue may be a CSS specific color value or general
+ * keywords of CSS.
+ */
+ [[nodiscard]] static bool MaybeCSSSpecificColorValue(
+ const nsAString& aColorValue);
+
+ /**
+ * Return true if aColorValue can be specified to `color` value of <font>.
+ */
+ [[nodiscard]] static bool CanConvertToHTMLColorValue(
+ const nsAString& aColorValue);
+
+ /**
+ * Convert aColorValue to `#[0-9a-f]{6}` style HTML color value.
+ */
+ static bool ConvertToNormalizedHTMLColorValue(const nsAString& aColorValue,
+ nsAString& aNormalizedValue);
+
+ /**
+ * Get serialized color value (`rgb(...)` or `rgba(...)`) or "currentcolor"
+ * if aColorValue is valid. The result is useful to set CSS color property.
+ *
+ * @param aColorValue [in] Should be valid CSS color value.
+ * @param aZeroAlphaColor [in] If TransparentKeyword, aNormalizedValue is
+ * set to "transparent" if the alpha value is 0.
+ * Otherwise, `rgba(...)` value is set.
+ * @param aNormalizedValue [out] Serialized color value or "currentcolor".
+ * @return true if aColorValue is valid. Otherwise, false.
+ */
+ enum class ZeroAlphaColor { RGBAValue, TransparentKeyword };
+ static bool GetNormalizedCSSColorValue(const nsAString& aColorValue,
+ ZeroAlphaColor aZeroAlphaColor,
+ nsAString& aNormalizedValue);
+
+ /**
+ * Check whether aColorA and aColorB are same color.
+ *
+ * @param aTransparentKeyword Whether allow to treat "transparent" keyword
+ * as a valid value or an invalid value.
+ * @return If aColorA and aColorB are valid values and
+ * mean same color, returns true.
+ */
+ enum class TransparentKeyword { Invalid, Allowed };
+ static bool IsSameHTMLColorValue(const nsAString& aColorA,
+ const nsAString& aColorB,
+ TransparentKeyword aTransparentKeyword);
+
+ /**
+ * Check whether aColorA and aColorB are same color.
+ *
+ * @return If aColorA and aColorB are valid values and
+ * mean same color, returns true.
+ */
+ template <typename CharType>
+ static bool IsSameCSSColorValue(const nsTSubstring<CharType>& aColorA,
+ const nsTSubstring<CharType>& aColorB);
+
+ private:
+ static bool CanNodeContain(nsHTMLTag aParentTagId, nsHTMLTag aChildTagId);
+ static bool IsContainerNode(nsHTMLTag aTagId);
+
+ static bool CanCrossContentBoundary(nsIContent& aContent,
+ TableBoundary aHowToTreatTableBoundary) {
+ const bool cannotCrossBoundary =
+ (aHowToTreatTableBoundary == TableBoundary::NoCrossAnyTableElement &&
+ HTMLEditUtils::IsAnyTableElement(&aContent)) ||
+ (aHowToTreatTableBoundary == TableBoundary::NoCrossTableElement &&
+ aContent.IsHTMLElement(nsGkAtoms::table));
+ return !cannotCrossBoundary;
+ }
+
+ static bool IsContentIgnored(const nsIContent& aContent,
+ const WalkTreeOptions& aOptions) {
+ if (aOptions.contains(WalkTreeOption::IgnoreNonEditableNode) &&
+ !EditorUtils::IsEditableContent(aContent,
+ EditorUtils::EditorType::HTML)) {
+ return true;
+ }
+ if (aOptions.contains(WalkTreeOption::IgnoreDataNodeExceptText) &&
+ !EditorUtils::IsElementOrText(aContent)) {
+ return true;
+ }
+ if (aOptions.contains(WalkTreeOption::IgnoreWhiteSpaceOnlyText) &&
+ aContent.IsText() &&
+ const_cast<Text*>(aContent.AsText())->TextIsOnlyWhitespace()) {
+ return true;
+ }
+ return false;
+ }
+
+ static uint32_t CountChildren(const nsINode& aNode,
+ const WalkTreeOptions& aOptions) {
+ uint32_t count = 0;
+ for (nsIContent* child = aNode.GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (HTMLEditUtils::IsContentIgnored(*child, aOptions)) {
+ continue;
+ }
+ if (aOptions.contains(WalkTreeOption::StopAtBlockBoundary) &&
+ HTMLEditUtils::IsBlockElement(*child)) {
+ break;
+ }
+ ++count;
+ }
+ return count;
+ }
+
+ /**
+ * Helper for GetPreviousContent() and GetNextContent().
+ */
+ static nsIContent* GetAdjacentLeafContent(
+ const nsINode& aNode, WalkTreeDirection aWalkTreeDirection,
+ const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr);
+ static nsIContent* GetAdjacentContent(
+ const nsINode& aNode, WalkTreeDirection aWalkTreeDirection,
+ const WalkTreeOptions& aOptions,
+ const Element* aAncestorLimiter = nullptr);
+
+ /**
+ * GetElementOfImmediateBlockBoundary() returns a block element if its
+ * block boundary and aContent may be first visible thing before/after the
+ * boundary. And it may return a <br> element only when aContent is a
+ * text node and follows a <br> element because only in this case, the
+ * start white-spaces are invisible. So the <br> element works same as
+ * a block boundary.
+ */
+ static Element* GetElementOfImmediateBlockBoundary(
+ const nsIContent& aContent, const WalkTreeDirection aDirection);
+};
+
+/**
+ * DefinitionListItemScanner() scans given `<dl>` element's children.
+ * Then, you can check whether `<dt>` and/or `<dd>` elements are in it.
+ */
+class MOZ_STACK_CLASS DefinitionListItemScanner final {
+ using Element = dom::Element;
+
+ public:
+ DefinitionListItemScanner() = delete;
+ explicit DefinitionListItemScanner(Element& aDLElement) {
+ MOZ_ASSERT(aDLElement.IsHTMLElement(nsGkAtoms::dl));
+ for (nsIContent* child = aDLElement.GetFirstChild(); child;
+ child = child->GetNextSibling()) {
+ if (child->IsHTMLElement(nsGkAtoms::dt)) {
+ mDTFound = true;
+ if (mDDFound) {
+ break;
+ }
+ continue;
+ }
+ if (child->IsHTMLElement(nsGkAtoms::dd)) {
+ mDDFound = true;
+ if (mDTFound) {
+ break;
+ }
+ continue;
+ }
+ }
+ }
+
+ bool DTElementFound() const { return mDTFound; }
+ bool DDElementFound() const { return mDDFound; }
+
+ private:
+ bool mDTFound = false;
+ bool mDDFound = false;
+};
+
+/**
+ * SelectedTableCellScanner() scans all table cell elements which are selected
+ * by each selection range. Note that if 2nd or later ranges do not select
+ * only one table cell element, the ranges are just ignored.
+ */
+class MOZ_STACK_CLASS SelectedTableCellScanner final {
+ using Element = dom::Element;
+ using Selection = dom::Selection;
+
+ public:
+ SelectedTableCellScanner() = delete;
+ explicit SelectedTableCellScanner(const Selection& aSelection) {
+ Element* firstSelectedCellElement =
+ HTMLEditUtils::GetFirstSelectedTableCellElement(aSelection);
+ if (!firstSelectedCellElement) {
+ return; // We're not in table cell selection mode.
+ }
+ mSelectedCellElements.SetCapacity(aSelection.RangeCount());
+ mSelectedCellElements.AppendElement(*firstSelectedCellElement);
+ const uint32_t rangeCount = aSelection.RangeCount();
+ for (const uint32_t i : IntegerRange(1u, rangeCount)) {
+ MOZ_ASSERT(aSelection.RangeCount() == rangeCount);
+ nsRange* range = aSelection.GetRangeAt(i);
+ if (MOZ_UNLIKELY(NS_WARN_IF(!range)) ||
+ MOZ_UNLIKELY(NS_WARN_IF(!range->IsPositioned()))) {
+ continue; // Shouldn't occur in normal conditions.
+ }
+ // Just ignore selection ranges which do not select only one table
+ // cell element. This is possible case if web apps sets multiple
+ // selections and first range selects a table cell element.
+ if (Element* selectedCellElement =
+ HTMLEditUtils::GetTableCellElementIfOnlyOneSelected(*range)) {
+ mSelectedCellElements.AppendElement(*selectedCellElement);
+ }
+ }
+ }
+
+ explicit SelectedTableCellScanner(const AutoRangeArray& aRanges);
+
+ bool IsInTableCellSelectionMode() const {
+ return !mSelectedCellElements.IsEmpty();
+ }
+
+ const nsTArray<OwningNonNull<Element>>& ElementsRef() const {
+ return mSelectedCellElements;
+ }
+
+ /**
+ * GetFirstElement() and GetNextElement() are stateful iterator methods.
+ * This is useful to port legacy code which used old `nsITableEditor` API.
+ */
+ Element* GetFirstElement() const {
+ MOZ_ASSERT(!mSelectedCellElements.IsEmpty());
+ mIndex = 0;
+ return !mSelectedCellElements.IsEmpty() ? mSelectedCellElements[0].get()
+ : nullptr;
+ }
+ Element* GetNextElement() const {
+ MOZ_ASSERT(mIndex < mSelectedCellElements.Length());
+ return ++mIndex < mSelectedCellElements.Length()
+ ? mSelectedCellElements[mIndex].get()
+ : nullptr;
+ }
+
+ private:
+ AutoTArray<OwningNonNull<Element>, 16> mSelectedCellElements;
+ mutable size_t mIndex = 0;
+};
+
+} // namespace mozilla
+
+#endif // #ifndef HTMLEditUtils_h