/* 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 "EditorLineBreak.h" #include "EditorUtils.h" #include "HTMLEditHelpers.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/CharacterDataBuffer.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; using WhitespaceOption = dom::CharacterDataBuffer::WhitespaceOption; using WhitespaceOptions = dom::CharacterDataBuffer::WhitespaceOptions; 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 aNode is editable or not in a composed doc. This is useful * if the caller may modify document fragment before inserting it into a * Document. */ static bool NodeIsEditableOrNotInComposedDoc(const nsINode& aNode) { return MOZ_UNLIKELY(!aNode.IsInComposedDoc()) || aNode.IsEditable(); } /** * Return true if aElement is an editing host which is either: * - the root element * - parent is not editable * - the element of the document */ [[nodiscard]] static bool ElementIsEditableRoot(const Element& aElement); /** * 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() && !aContent.IsHTMLElement(nsGkAtoms::button) && (!HTMLEditUtils::IsContainerNode(aContent) || HTMLEditUtils::IsReplacedElement(*aContent.AsElement()) || aContent.IsAnyOfHTMLElements(nsGkAtoms::applet, nsGkAtoms::colgroup, nsGkAtoms::frameset, nsGkAtoms::head, nsGkAtoms::html)); } enum class ReplaceOrVoidElementOption { LookForOnlyVoidElement, LookForOnlyReplaceElement, LookForOnlyNonVoidReplacedElement, LookForReplacedOrVoidElement, }; /** * Return an inclusive ancestor replaced element or void element of aContent. * I.e., if this returns non-nullptr, aContent is in a replaced element or a * void element. */ [[nodiscard]] static Element* GetInclusiveAncestorReplacedOrVoidElement( const nsIContent& aContent, ReplaceOrVoidElementOption aOption) { const bool lookForAnyReplaceElement = aOption == ReplaceOrVoidElementOption::LookForOnlyReplaceElement || aOption == ReplaceOrVoidElementOption::LookForReplacedOrVoidElement; const bool lookForNonVoidReplacedElement = aOption == ReplaceOrVoidElementOption::LookForOnlyNonVoidReplacedElement; const bool lookForVoidElement = aOption == ReplaceOrVoidElementOption::LookForOnlyVoidElement || aOption == ReplaceOrVoidElementOption::LookForReplacedOrVoidElement; Element* lastReplacedOrVoidElement = nullptr; for (Element* const element : aContent.InclusiveAncestorsOfType()) { // XXX I think we should not treat