element when it's in plaintext editor * mode or an element with which calling HTMLEditUtils::IsMailCite() returns * true. * * @param aNode The start node to look for parent mail cite elements. */ Element* GetMostDistantAncestorMailCiteElement(const nsINode& aNode) const; /** * Splits inclusive inline ancestors at both start and end of aRangeItem. If * this splits at every point, this modifies aRangeItem to point each split * point (typically, at right node). * * @param aRangeItem [in/out] One or two DOM points where should be * split. Will be modified to split point if * they're split. * @param aBlockInlineCheck [in] Whether this method considers block vs. * inline with computed style or the default style. * @param aEditingHost [in] The editing host. * @param aAncestorLimiter [in/optional] If specified, this stops splitting * ancestors when meets this node. * @return A suggest point to put caret if succeeded, but * it may be unset. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SplitInlineAncestorsAtRangeBoundaries( RangeItem& aRangeItem, BlockInlineCheck aBlockInlineCheck, const Element& aEditingHost, const nsIContent* aAncestorLimiter = nullptr); /** * SplitElementsAtEveryBRElement() splits before all
elements in * aMostAncestorToBeSplit. All
nodes will be moved before right node * at splitting its parent. Finally, this returns left node, first
* element, next left node, second
element... and right-most node. * * @param aMostAncestorToBeSplit Most-ancestor element which should * be split. * @param aOutArrayOfNodes First left node, first
element, * Second left node, second
element, * ...right-most node. So, all nodes * in this list should be siblings (may be * broken the relation by mutation event * listener though). If first
element * is first leaf node of * aMostAncestorToBeSplit, starting from * the first
element. * @return A suggest point to put caret if * succeeded, but it may unset. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SplitElementsAtEveryBRElement( nsIContent& aMostAncestorToBeSplit, nsTArray>& aOutArrayOfContents); /** * MaybeSplitElementsAtEveryBRElement() calls SplitElementsAtEveryBRElement() * for each given node when this needs to do that for aEditSubAction. * If split a node, it in aArrayOfContents is replaced with split nodes and *
elements. * * @return A suggest point to put caret if * succeeded, but it may unset. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MaybeSplitElementsAtEveryBRElement( nsTArray>& aArrayOfContents, EditSubAction aEditSubAction); /** * CreateRangeIncludingAdjuscentWhiteSpaces() creates an nsRange instance * which may be expanded from the given range to include adjuscent * white-spaces. If this fails handling something, returns nullptr. */ template already_AddRefed CreateRangeIncludingAdjuscentWhiteSpaces( const EditorDOMRangeType& aRange); template already_AddRefed CreateRangeIncludingAdjuscentWhiteSpaces( const EditorDOMPointType1& aStartPoint, const EditorDOMPointType2& aEndPoint); /** * GetRangeExtendedToHardLineEdgesForBlockEditAction() returns an extended * range if aRange should be extended before handling a block level editing. * If aRange start and/or end point
or something non-editable point, they * should be moved to nearest text node or something where the other methods * easier to handle edit action. */ [[nodiscard]] Result GetRangeExtendedToHardLineEdgesForBlockEditAction( const nsRange* aRange, const Element& aEditingHost) const; /** * InitializeInsertingElement is a callback type of methods which inserts * an element into the DOM tree. This is called immediately before inserting * aNewElement into the DOM tree. * * @param aHTMLEditor The HTML editor which modifies the DOM tree. * @param aNewElement The new element which will be or was inserted into * the DOM tree. * @param aPointToInsert The position aNewElement will be or was inserted. */ using InitializeInsertingElement = std::function; static InitializeInsertingElement DoNothingForNewElement; static InitializeInsertingElement InsertNewBRElement; /** * Helper methods to implement InitializeInsertingElement. */ MOZ_CAN_RUN_SCRIPT static Result AppendNewElementToInsertingElement( HTMLEditor& aHTMLEditor, const nsStaticAtom& aTagName, Element& aNewElement, const InitializeInsertingElement& aInitializer = DoNothingForNewElement); MOZ_CAN_RUN_SCRIPT static Result AppendNewElementWithBRToInsertingElement(HTMLEditor& aHTMLEditor, const nsStaticAtom& aTagName, Element& aNewElement); /** * Create an element node whose name is aTag at before aPointToInsert. When * this succeed to create an element node, this inserts the element to * aPointToInsert. * * @param aWithTransaction Whether the inserting is new element is undoable * or not. WithTransaction::No is useful only when * the new element is inserted into a new element * which has not been connected yet. * @param aTagName The element name to create. * @param aPointToInsert The insertion point of new element. * If this refers end of the container or after, * the transaction will append the element to the * container. * Otherwise, will insert the element before the * child node referred by this. * Note that this point will be invalid once this * method inserts the new element. * @param aInitializer A function to initialize the new element before * connecting the element into the DOM tree. Note * that this should not touch outside given element * because doing it would break range updater's * result. * @return The created new element node and candidate caret * position. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result CreateAndInsertElement( WithTransaction aWithTransaction, const nsAtom& aTagName, const EditorDOMPoint& aPointToInsert, const InitializeInsertingElement& aInitializer = DoNothingForNewElement); /** * Callback of CopyAttributes(). * * @param aHTMLEditor The HTML editor. * @param aSrcElement The element which have the attribute. * @param aDestElement The element which will have the attribute. * @param aNamespaceID [in] The namespace ID of aAttrName. * @param aAttrName [in] The attribute name which will be copied. * @param aValue [in/out] The attribute value which will be copied. * Once updated, the new value is used. * @return true if the attribute should be copied, otherwise, * false. */ using AttributeFilter = std::function; static AttributeFilter CopyAllAttributes; static AttributeFilter CopyAllAttributesExceptId; static AttributeFilter CopyAllAttributesExceptDir; static AttributeFilter CopyAllAttributesExceptIdAndDir; /** * Copy all attributes of aSrcElement to aDestElement as-is. Different from * EditorBase::CloneAttributesWithTransaction(), this does not use * SetAttributeOrEquivalent() nor does not clear existing attributes of * aDestElement. * * @param aWithTransaction Whether recoding with transactions or not. * @param aDestElement The element will have attributes. * @param aSrcElement The element whose attributes will be copied. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CopyAttributes( WithTransaction aWithTransaction, Element& aDestElement, Element& aSrcElement, const AttributeFilter& = CopyAllAttributes); /** * MaybeSplitAncestorsForInsertWithTransaction() does nothing if container of * aStartOfDeepestRightNode can have an element whose tag name is aTag. * Otherwise, looks for an ancestor node which is or is in active editing * host and can have an element whose name is aTag. If there is such * ancestor, its descendants are split. * * Note that this may create empty elements while splitting ancestors. * * @param aTag The name of element to be inserted * after calling this method. * @param aStartOfDeepestRightNode The start point of deepest right node. * This point must be in aEditingHost. * @param aEditingHost The editing host. * @return When succeeded, SplitPoint() returns * the point to insert the element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MaybeSplitAncestorsForInsertWithTransaction( const nsAtom& aTag, const EditorDOMPoint& aStartOfDeepestRightNode, const Element& aEditingHost); /** * InsertElementWithSplittingAncestorsWithTransaction() is a wrapper of * MaybeSplitAncestorsForInsertWithTransaction() and CreateAndInsertElement(). * I.e., will create an element whose tag name is aTagName and split ancestors * if it's necessary, then, insert it. * * @param aTagName The tag name which you want to insert new * element at aPointToInsert. * @param aPointToInsert The insertion point. New element will be * inserted before here. * @param aBRElementNextToSplitPoint * Whether
element should be deleted or * kept if and only if a
element follows * split point. * @param aEditingHost The editing host with which we're handling it. * @param aInitializer A function to initialize the new element before * connecting the element into the DOM tree. Note * that this should not touch outside given element * because doing it would break range updater's * result. * @return If succeeded, returns the new element node and * suggesting point to put caret. */ enum class BRElementNextToSplitPoint { Keep, Delete }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertElementWithSplittingAncestorsWithTransaction( const nsAtom& aTagName, const EditorDOMPoint& aPointToInsert, BRElementNextToSplitPoint aBRElementNextToSplitPoint, const Element& aEditingHost, const InitializeInsertingElement& aInitializer = DoNothingForNewElement); /** * Split aElementToSplit at two points, before aStartOfMiddleElement and after * aEndOfMiddleElement. If they are very start or very end of aBlockElement, * this won't create empty block. * * @param aElementToSplit An element which will be split. * @param aStartOfMiddleElement Start node of middle block element. * @param aEndOfMiddleElement End node of middle block element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SplitRangeOffFromElement(Element& aElementToSplit, nsIContent& aStartOfMiddleElement, nsIContent& aEndOfMiddleElement); /** * RemoveBlockContainerElementWithTransactionBetween() splits the nodes * at aStartOfRange and aEndOfRange, then, removes the middle element which * was split off from aBlockContainerElement and moves the ex-children to * where the middle element was. I.e., all nodes between aStartOfRange and * aEndOfRange (including themselves) will be unwrapped from * aBlockContainerElement. * * @param aBlockContainerElement The node which will be split. * @param aStartOfRange The first node which will be unwrapped * from aBlockContainerElement. * @param aEndOfRange The last node which will be unwrapped from * aBlockContainerElement. * @param aBlockInlineCheck Whether this method considers block vs. * inline with computed style or the default * style. * @return The left content is new created left * element of aBlockContainerElement. * The right content is split element, * i.e., must be aBlockContainerElement. * The middle content is nullptr since * removing it is the job of this method. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result RemoveBlockContainerElementWithTransactionBetween( Element& aBlockContainerElement, nsIContent& aStartOfRange, nsIContent& aEndOfRange, BlockInlineCheck aBlockInlineCheck); /** * WrapContentsInBlockquoteElementsWithTransaction() inserts at least one *

element and moves nodes in aArrayOfContents into new *
elements. If aArrayOfContents includes a table related element * except , this calls itself recursively to insert
into * the cell. * * @param aArrayOfContents Nodes which will be moved into created *
elements. * @param aEditingHost The editing host. * @return A blockquote element which is created at last * and a suggest of caret position if succeeded. * The caret suggestion may be unset if there is * no suggestion. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result WrapContentsInBlockquoteElementsWithTransaction( const nsTArray>& aArrayOfContents, const Element& aEditingHost); /** * Our traditional formatBlock was same as XUL cmd_paragraphState command. * However, the behavior is pretty different from the others and aligning * the XUL command behavior may break Thunderbird a lot because it handles *
in a special path and
(generic block element) is not * treated as a format node and these things may be used for designing * current roles of the elements in the email composer of Thunderbird. * Therefore, we create a new mode for HTMLFormatBlockCommand to align * the behavior to the others but does not harm Thunderbird. */ enum class FormatBlockMode { // Document.execCommand("formatBlock"). Cannot set new format to "normal" // nor "". So, the paths to handle these ones are not used in this mode. HTMLFormatBlockCommand, // cmd_paragraphState. Can set new format to "normal" or "" to remove // ancestor format blocks. XULParagraphStateCommand, }; /** * RemoveBlockContainerElementsWithTransaction() removes all format blocks, * table related element, etc in aArrayOfContents from the DOM tree. If * aArrayOfContents has a format node, it will be removed and its contents * will be moved to where it was. * If aArrayOfContents has a table related element,
,
or *
, it will be removed and its contents will be moved to where it was. * * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. * * @return A suggest point to put caret if succeeded, but it may be * unset if there is no suggestion. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result RemoveBlockContainerElementsWithTransaction( const nsTArray>& aArrayOfContents, FormatBlockMode aFormatBlockMode, BlockInlineCheck aBlockInlineCheck); /** * CreateOrChangeFormatContainerElement() formats all nodes in * aArrayOfContents with block elements whose name is aNewFormatTagName. * * If aArrayOfContents has an inline element, a block element is created and * the inline element and following inline elements are moved into the new * block element. * If aArrayOfContents has
elements, they'll be removed from the DOM tree * and new block element will be created when there are some remaining inline * elements. * If aArrayOfContents has a block element, this calls itself with children of * the block element. Then, new block element will be created when there are * some remaining inline elements. * * @param aArrayOfContents Must be descendants of a node. * @param aNewFormatTagName The element name of new block elements. * @param aFormatBlockMode The replacing block element target type is for * whether HTML formatBLock command or XUL * paragraphState command. * @param aEditingHost The editing host. * @return The latest created new block element and a * suggest point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result CreateOrChangeFormatContainerElement( nsTArray>& aArrayOfContents, const nsStaticAtom& aNewFormatTagName, FormatBlockMode aFormatBlockMode, const Element& aEditingHost); /** * FormatBlockContainerWithTransaction() is implementation of "formatBlock" * command of `Document.execCommand()`. This applies block style or removes * it. * * @param aSelectionRanges The ranges which are cloned by selection or * updated from it with doing something before * calling this. * @param aNewFormatTagName New block tag name. * If nsGkAtoms::normal or nsGkAtoms::_empty, * RemoveBlockContainerElementsWithTransaction() * will be called. * If nsGkAtoms::blockquote, * WrapContentsInBlockquoteElementsWithTransaction() * will be called. * Otherwise, CreateOrChangeBlockContainerElement() * will be called. * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. * @param aEditingHost The editing host. * @return If selection should be finally collapsed in a * created block element, this returns the element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result, nsresult> FormatBlockContainerWithTransaction( AutoClonedSelectionRangeArray& aSelectionRanges, const nsStaticAtom& aNewFormatTagName, FormatBlockMode aFormatBlockMode, const Element& aEditingHost); /** * Retrun true if the specified line break can be inserted around aContent. * If aContent is an Element, this checks whether the element can have the * line break. * If aContent is a Text, this check whether its container element can have * the line break. */ [[nodiscard]] static bool CanInsertLineBreak(LineBreakType aLineBreakType, const nsIContent& aContent); /** * If aPointToInsert is between line breaks or block boundaries, this * puts a
element to make an empty line between them. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertPaddingBRElementToMakeEmptyLineVisibleIfNeeded( const EditorDOMPoint& aPointToInsert, const Element& aEditingHost); /** * Insert a padding
if aPoint is in an empty block. * * @param aPoint The place where you want to put a padding line * break. * @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes empty inlines * before inserting a line break from the inserting * point. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertPaddingBRElementIfInEmptyBlock( const EditorDOMPoint& aPoint, nsIEditor::EStripWrappers aDeleteEmptyInlines); /** * Insert a padding
element for making preceding collapsible white-spaces * visible or the point is empty between block boundaries. * * @param aPoint Where you want to check. A padding
may be * inserted different from this point. * @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes empty inlines * before inserting
from the inserting point. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertPaddingBRElementIfNeeded(const EditorDOMPoint& aPoint, nsIEditor::EStripWrappers aDeleteEmptyInlines, const Element& aEditingHost); [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result DeleteRangesWithTransaction(nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers, AutoClonedRangeArray& aRangesToDelete) override; class AutoInsertParagraphHandler; class AutoInsertLineBreakHandler; /** * InsertParagraphSeparatorAsSubAction() handles insertParagraph command * (i.e., handling Enter key press) with the above helper methods. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertParagraphSeparatorAsSubAction(const Element& aEditingHost); /** * InsertLineBreakAsSubAction() inserts a new
element or a linefeed * character at selection. If there is non-collapsed selection ranges, the * selected ranges is deleted first. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertLineBreakAsSubAction(); /** * ChangeListElementType() replaces child list items of aListElement with * new list item element whose tag name is aNewListItemTag. * Note that if there are other list elements as children of aListElement, * this calls itself recursively even though it's invalid structure. * * @param aListElement The list element whose list items will be * replaced. * @param aNewListTag New list tag name. * @param aNewListItemTag New list item tag name. * @return New list element or an error code if it fails. * New list element may be aListElement if its * tag name is same as aNewListTag. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result ChangeListElementType(Element& aListElement, nsAtom& aListType, nsAtom& aItemType); class AutoListElementCreator; [[nodiscard]] static bool IsFormatElement(FormatBlockMode aFormatBlockMode, const nsIContent& aContent); /** * MakeOrChangeListAndListItemAsSubAction() handles create list commands with * current selection. If * * @param aListElementOrListItemElementTagName * The new list element tag name or * new list item tag name. * If the former, list item tag name will * be computed automatically. Otherwise, * list tag name will be computed. * @param aBulletType If this is not empty string, it's set * to `type` attribute of new list item * elements. Otherwise, existing `type` * attributes will be removed. * @param aSelectAllOfCurrentList Yes if this should treat all of * ancestor list element at selection. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MakeOrChangeListAndListItemAsSubAction( const nsStaticAtom& aListElementOrListItemElementTagName, const nsAString& aBulletType, SelectAllOfCurrentList aSelectAllOfCurrentList, const Element& aEditingHost); /** * DeleteTextAndTextNodesWithTransaction() removes text or text nodes in * the given range. */ enum class TreatEmptyTextNodes { // KeepIfContainerOfRangeBoundaries: // Will remove empty text nodes middle of the range, but keep empty // text nodes which are containers of range boundaries. KeepIfContainerOfRangeBoundaries, // Remove: // Will remove all empty text nodes. Remove, // RemoveAllEmptyInlineAncestors: // Will remove all empty text nodes and its inline ancestors which // become empty due to removing empty text nodes. RemoveAllEmptyInlineAncestors, }; template [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result DeleteTextAndTextNodesWithTransaction( const EditorDOMPointType& aStartPoint, const EditorDOMPointType& aEndPoint, TreatEmptyTextNodes aTreatEmptyTextNodes); /** * Delete the line break with DeleteNodeTransaction or DeleteTextTransaction. * * @param aLineBreak The line break to be deleted. * @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes new empty * inline element if and only if this deletes the * line break node. * @param aEditingHost The editing host. * @return The point where the line break was. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result DeleteLineBreakWithTransaction(const EditorLineBreak& aLineBreak, nsIEditor::EStripWrappers aDeleteEmptyInlines, const Element& aEditingHost); /** * JoinNodesWithTransaction() joins aLeftContent and aRightContent. Content * of aLeftContent will be merged into aRightContent. Actual implemenation of * this method is JoinNodesImpl(). So, see its explanation for the detail. * * @param aLeftContent Will be removed from the DOM tree. * @param aRightContent The node which will be new container of the content * of aLeftContent. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result JoinNodesWithTransaction(nsIContent& aLeftContent, nsIContent& aRightContent); /** * JoinNearestEditableNodesWithTransaction() joins two editable nodes which * are themselves or the nearest editable node of aLeftNode and aRightNode. * XXX This method's behavior is odd. For example, if user types Backspace * key at the second editable paragraph in this case: *
*
first editable paragraph
*
non-editable paragraph
*
second editable paragraph
*
* The first editable paragraph's content will be moved into the second * editable paragraph and the non-editable paragraph becomes the first * paragraph of the editor. I don't think that it's expected behavior of * any users... * * @param aLeftNode The node which will be removed. * @param aRightNode The node which will be inserted the content of * aLeftNode. * @param aNewFirstChildOfRightNode * [out] The point at the first child of aRightNode. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult JoinNearestEditableNodesWithTransaction( nsIContent& aLeftNode, nsIContent& aRightNode, EditorDOMPoint* aNewFirstChildOfRightNode); /** * ReplaceContainerAndCloneAttributesWithTransaction() creates new element * whose name is aTagName, copies all attributes from aOldContainer to the * new element, moves all children in aOldContainer to the new element, then, * removes aOldContainer from the DOM tree. * * @param aOldContainer The element node which should be replaced * with new element. * @param aTagName The name of new element node. */ [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result ReplaceContainerAndCloneAttributesWithTransaction(Element& aOldContainer, const nsAtom& aTagName); /** * ReplaceContainerWithTransaction() creates new element whose name is * aTagName, sets aAttributes of the new element to aAttributeValue, moves * all children in aOldContainer to the new element, then, removes * aOldContainer from the DOM tree. * * @param aOldContainer The element node which should be replaced * with new element. * @param aTagName The name of new element node. * @param aAttribute Attribute name to be set to the new element. * @param aAttributeValue Attribute value to be set to aAttribute. */ [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result ReplaceContainerWithTransaction(Element& aOldContainer, const nsAtom& aTagName, const nsAtom& aAttribute, const nsAString& aAttributeValue); /** * ReplaceContainerWithTransaction() creates new element whose name is * aTagName, moves all children in aOldContainer to the new element, then, * removes aOldContainer from the DOM tree. * * @param aOldContainer The element node which should be replaced * with new element. * @param aTagName The name of new element node. */ [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result ReplaceContainerWithTransaction(Element& aOldContainer, const nsAtom& aTagName); /** * RemoveContainerWithTransaction() removes aElement from the DOM tree and * moves all its children to the parent of aElement. * * @param aElement The element to be removed. * @return A suggestion point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result RemoveContainerWithTransaction(Element& aElement); /** * InsertContainerWithTransaction() creates new element whose name is * aWrapperTagName, moves aContentToBeWrapped into the new element, then, * inserts the new element into where aContentToBeWrapped was. * NOTE: This method does not check if aContentToBeWrapped is valid child * of the new element. So, callers need to guarantee it. * * @param aContentToBeWrapped The content which will be wrapped with new * element. * @param aWrapperTagName Element name of new element which will wrap * aContent and be inserted into where aContent * was. * @param aInitializer A callback to initialize new element before * inserting to the DOM tree. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertContainerWithTransaction( nsIContent& aContentToBeWrapped, const nsAtom& aWrapperTagName, const InitializeInsertingElement& aInitializer = DoNothingForNewElement); /** * MoveNodeWithTransaction() moves aContentToMove to aPointToInsert. * * @param aContentToMove The node to be moved. * @param aPointToInsert The point where aContentToMove will be inserted. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MoveNodeWithTransaction(nsIContent& aContentToMove, const EditorDOMPoint& aPointToInsert); /** * Moves all siblings from aFirstContentToMove to aLastContentToMove to * aPointToInsert with a transaction. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MoveSiblingsWithTransaction(nsIContent& aFirstContentToMove, nsIContent& aLastContentToMove, const EditorDOMPoint& aPointToInsert); /** * MoveNodeToEndWithTransaction() moves aContentToMove to end of * aNewContainer. * * @param aContentToMove The node to be moved. * @param aNewContainer The new container which will contain aContentToMove * as its last child. */ [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result MoveNodeToEndWithTransaction(nsIContent& aContentToMove, nsINode& aNewContainer); /** * Moves all siblings from aFirstContentToMove to aLastContentToMove to the * end of aNewContainer with a transaction. */ [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result MoveSiblingsToEndWithTransaction(nsIContent& aFirstContentToMove, nsIContent& aLastContentToMove, nsINode& aNewContainer); /** * MoveNodeOrChildrenWithTransaction() moves aContent to aPointToInsert. If * cannot insert aContent due to invalid relation, moves only its children * recursively and removes aContent from the DOM tree. * * @param aContent Content which should be moved. * @param aPointToInsert The point to be inserted aContent or its * descendants. * @param aPreserveWhiteSpaceStyle * If yes and if it's possible to keep white-space * style, this method will set `style` attribute to * moving node or creating new element. * @param aRemoveIfCommentNode * If yes, this removes invisible nodes such as * comment nodes, empty inline containers (even if * it has border, etc) instead of moving it to the * destination. Note that this does not remove * invisible descendants in containers which have * visible nodes because it requires additional * scan. */ enum class PreserveWhiteSpaceStyle { No, Yes }; friend std::ostream& operator<<( std::ostream& aStream, const PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle); enum class RemoveIfInvisibleNode { No, Yes }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MoveNodeOrChildrenWithTransaction( nsIContent& aContentToMove, const EditorDOMPoint& aPointToInsert, PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle, RemoveIfInvisibleNode aRemoveIfInvisibleNode); /** * CanMoveNodeOrChildren() returns true if * `MoveNodeOrChildrenWithTransaction()` can move or delete at least a * descendant of aElement into aNewContainer. I.e., when this returns true, * `MoveNodeOrChildrenWithTransaction()` must return "handled". */ Result CanMoveNodeOrChildren( const nsIContent& aContent, const nsINode& aNewContainer) const; /** * MoveChildrenWithTransaction() moves the children of aElement to * aPointToInsert. If cannot insert some children due to invalid relation, * calls MoveNodeOrChildrenWithTransaction() to remove the children but keep * moving its children. * * @param aElement Container element whose children should be * moved. * @param aPointToInsert The point to be inserted children of aElement * or its descendants. * @param aPreserveWhiteSpaceStyle * If yes and if it's possible to keep white-space * style, this method will set `style` attribute to * moving node or creating new element. * @param aRemoveIfCommentNode * If yes, this removes invisible nodes such as * comment nodes, empty inline containers (even if * it has border, etc) instead of moving it to the * destination. Note that this does not remove * invisible descendants in containers which have * visible nodes because it requires additional * scan. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result MoveChildrenWithTransaction(Element& aElement, const EditorDOMPoint& aPointToInsert, PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle, RemoveIfInvisibleNode aRemoveIfInvisibleNode); /** * CanMoveChildren() returns true if `MoveChildrenWithTransaction()` can move * at least a descendant of aElement into aNewContainer. I.e., when this * returns true, `MoveChildrenWithTransaction()` return "handled". */ Result CanMoveChildren(const Element& aElement, const nsINode& aNewContainer) const; /** * MoveAllChildren() moves all children of aContainer to before * aPointToInsert.GetChild(). * See explanation of MoveChildrenBetween() for the detail of the behavior. * * @param aContainer The container node whose all children should * be moved. * @param aPointToInsert The insertion point. The container must not * be a data node like a text node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveAllChildren(nsINode& aContainer, const EditorRawDOMPoint& aPointToInsert); /** * MoveChildrenBetween() moves all children between aFirstChild and aLastChild * to before aPointToInsert.GetChild(). If some children are moved to * different container while this method moves other children, they are just * ignored. If the child node referred by aPointToInsert is moved to different * container while this method moves children, returns error. * * @param aFirstChild The first child which should be moved to * aPointToInsert. * @param aLastChild The last child which should be moved. This * must be a sibling of aFirstChild and it should * be positioned after aFirstChild in the DOM tree * order. * @param aPointToInsert The insertion point. The container must not * be a data node like a text node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveChildrenBetween(nsIContent& aFirstChild, nsIContent& aLastChild, const EditorRawDOMPoint& aPointToInsert); /** * MovePreviousSiblings() moves all siblings before aChild (i.e., aChild * won't be moved) to before aPointToInsert.GetChild(). * See explanation of MoveChildrenBetween() for the detail of the behavior. * * @param aChild The node which is next sibling of the last * node to be moved. * @param aPointToInsert The insertion point. The container must not * be a data node like a text node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MovePreviousSiblings( nsIContent& aChild, const EditorRawDOMPoint& aPointToInsert); /** * MoveInclusiveNextSiblings() moves aChild and all siblings after it to * before aPointToInsert.GetChild(). * See explanation of MoveChildrenBetween() for the detail of the behavior. * * @param aChild The node which is first node to be moved. * @param aPointToInsert The insertion point. The container must not * be a data node like a text node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveInclusiveNextSiblings( nsIContent& aChild, const EditorRawDOMPoint& aPointToInsert); /** * SplitNodeWithTransaction() creates a transaction to create a new node * (left node) identical to an existing node (right node), and split the * contents between the same point in both nodes, then, execute the * transaction. * * @param aStartOfRightNode The point to split. Its container will be * the right node, i.e., become the new node's * next sibling. And the point will be start * of the right node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SplitNodeWithTransaction(const EditorDOMPoint& aStartOfRightNode); /** * SplitNodeDeepWithTransaction() splits aMostAncestorToSplit deeply. * * @param aMostAncestorToSplit The most ancestor node which should be * split. * @param aStartOfDeepestRightNode The start point of deepest right node. * This point must be descendant of * aMostAncestorToSplit. * @param aSplitAtEdges Whether the caller allows this to * create empty container element when * split point is start or end of an * element. * @return SplitPoint() returns split point in * aMostAncestorToSplit. The point must * be good to insert something if the * caller want to do it. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SplitNodeDeepWithTransaction(nsIContent& aMostAncestorToSplit, const EditorDOMPoint& aDeepestStartOfRightNode, SplitAtEdges aSplitAtEdges); /** * DeleteEmptyInclusiveAncestorInlineElements() removes empty inclusive * ancestor inline elements in inclusive ancestor block element of aContent. * * @param aContent Must be an empty content. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result DeleteEmptyInclusiveAncestorInlineElements(nsIContent& aContent, const Element& aEditingHost); /** * DeleteTextAndNormalizeSurroundingWhiteSpaces() deletes text between * aStartToDelete and immediately before aEndToDelete and return new caret * position. If surrounding characters are white-spaces, this normalize them * too. Finally, inserts `
` element if it's required. * Note that if you wants only normalizing white-spaces, you can set same * point to both aStartToDelete and aEndToDelete. Then, this tries to * normalize white-space sequence containing previous character of * aStartToDelete. */ enum class DeleteDirection { Forward, Backward, }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result DeleteTextAndNormalizeSurroundingWhiteSpaces( const EditorDOMPointInText& aStartToDelete, const EditorDOMPointInText& aEndToDelete, TreatEmptyTextNodes aTreatEmptyTextNodes, DeleteDirection aDeleteDirection, const Element& aEditingHost); enum class NormalizeSurroundingWhiteSpaces : bool { No, Yes }; friend constexpr bool operator!(NormalizeSurroundingWhiteSpaces aValue) { return !static_cast(aValue); } /** * Return a normalized string. If aPointToInsert is in a `Text` node, * this returns a range in the `Text` to replace surrounding white-spaces at * aPointToInsert with the normalized string if white-spaces are collapsible * and aNormalizeSurroundingWhiteSpaces is "Yes". */ NormalizedStringToInsertText NormalizeWhiteSpacesToInsertText( const EditorDOMPoint& aPointToInsert, const nsAString& aStringToInsert, NormalizeSurroundingWhiteSpaces aNormalizeSurroundingWhiteSpaces) const; /** * Return normalized white-spaces of a white-space sequence which contains * aPoint. This returns new offset of aPoint.Offset() after replacing the * white-space sequence with normalized white-spaces. */ ReplaceWhiteSpacesData GetNormalizedStringAt( const EditorDOMPointInText& aPoint) const; /** * Return normalized white-spaces after aPointToSplit if there are some * collapsible white-spaces after the point. */ ReplaceWhiteSpacesData GetFollowingNormalizedStringToSplitAt( const EditorDOMPointInText& aPointToSplit) const; /** * Return normalized white-spaces before aPointToSplit if there are some * collapsible white-spaces before the point. */ ReplaceWhiteSpacesData GetPrecedingNormalizedStringToSplitAt( const EditorDOMPointInText& aPointToSplit) const; /** * Return normalized surrounding white-spaces of the given range in aTextNode * if there are some collapsible white-spaces. */ ReplaceWhiteSpacesData GetSurroundingNormalizedStringToDelete( const Text& aTextNode, uint32_t aOffset, uint32_t aLength) const; /** * ExtendRangeToDeleteWithNormalizingWhiteSpaces() is a helper method of * DeleteTextAndNormalizeSurroundingWhiteSpaces(). This expands * aStartToDelete and/or aEndToDelete if there are white-spaces which need * normalizing. * * @param aStartToDelete [In/Out] Start to delete. If this point * follows white-spaces, this may be modified. * @param aEndToDelete [In/Out] Next point of last content to be * deleted. If this point is a white-space, * this may be modified. * @param aNormalizedWhiteSpacesInStartNode * [Out] If container text node of aStartToDelete * should be modified, this offers new string * in the range in the text node. * @param aNormalizedWhiteSpacesInEndNode * [Out] If container text node of aEndToDelete * is different from the container of * aStartToDelete and it should be modified, this * offers new string in the range in the text node. */ void ExtendRangeToDeleteWithNormalizingWhiteSpaces( EditorDOMPointInText& aStartToDelete, EditorDOMPointInText& aEndToDelete, nsString& aNormalizedWhiteSpacesInStartNode, nsString& aNormalizedWhiteSpacesInEndNode) const; /** * CharPointType let the following helper methods of * ExtendRangeToDeleteWithNormalizingWhiteSpaces() know what type of * character will be previous or next char point after deletion. */ enum class CharPointType { TextEnd, // Start or end of the text (hardline break or replaced inline // element) ASCIIWhiteSpace, // One of ASCII white-spaces (collapsible white-space) NoBreakingSpace, // NBSP VisibleChar, // Non-white-space characters PreformattedChar, // Any character except a linefeed in a preformatted // node. PreformattedLineBreak, // Preformatted linebreak }; /** * GetPreviousCharPointType() and GetCharPointType() get type of * previous/current char point from current DOM tree. In other words, if the * point will be deleted, you cannot use these methods. */ template static CharPointType GetPreviousCharPointType( const EditorDOMPointType& aPoint); template static CharPointType GetCharPointType(const EditorDOMPointType& aPoint); /** * CharPointData let the following helper methods of * ExtendRangeToDeleteWithNormalizingWhiteSpaces() know what type of * character will be previous or next char point and the point is * in same or different text node after deletion. */ class MOZ_STACK_CLASS CharPointData final { public: CharPointData() = delete; static CharPointData InDifferentTextNode(CharPointType aCharPointType) { return {aCharPointType, true}; } static CharPointData InSameTextNode(CharPointType aCharPointType) { // Let's mark this as in different text node if given one indicates // that there is end of text because it means that adjacent content // from point of text node view is another element. return {aCharPointType, aCharPointType == CharPointType::TextEnd}; } bool AcrossTextNodeBoundary() const { return mIsInDifferentTextNode; } bool IsCollapsibleWhiteSpace() const { return mType == CharPointType::ASCIIWhiteSpace || mType == CharPointType::NoBreakingSpace; } CharPointType Type() const { return mType; } private: CharPointData(CharPointType aType, bool aIsInDifferentTextNode) : mType(aType), mIsInDifferentTextNode(aIsInDifferentTextNode) {} CharPointType mType; bool mIsInDifferentTextNode; }; /** * GetPreviousCharPointDataForNormalizingWhiteSpaces() and * GetInclusiveNextCharPointDataForNormalizingWhiteSpaces() is helper methods * of ExtendRangeToDeleteWithNormalizingWhiteSpaces(). This retrieves * previous or inclusive next editable char point and returns its data. */ CharPointData GetPreviousCharPointDataForNormalizingWhiteSpaces( const EditorDOMPointInText& aPoint) const; CharPointData GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( const EditorDOMPointInText& aPoint) const; enum class Linefeed : bool { Collapsible, Preformatted }; /** * Normalize all white-spaces in aResult. aPreviousCharPointData is used only * when the first character of aResult is an ASCII space or an NBSP. * aNextCharPointData is used only when the last character of aResult is an * ASCII space or an NBSP. */ static void NormalizeAllWhiteSpaceSequences( nsString& aResult, const CharPointData& aPreviousCharPointData, const CharPointData& aNextCharPointData, Linefeed aLinefeed); /** * GenerateWhiteSpaceSequence() generates white-space sequence which won't * be collapsed. * * @param aResult [out] White space sequence which won't be * collapsed, but wrappable. * @param aLength Length of generating white-space sequence. * Must be 1 or larger. * @param aPreviousCharPointData * Specify the previous char point where it'll be * inserted. Currently, for keepin this method * simple, does not support to generate a part * of white-space sequence in a text node. So, * if the type is white-space, it must indicate * different text nodes white-space. * @param aNextCharPointData Specify the next char point where it'll be * inserted. Same as aPreviousCharPointData, * this must node indicate white-space in same * text node. */ static void GenerateWhiteSpaceSequence( nsString& aResult, uint32_t aLength, const CharPointData& aPreviousCharPointData, const CharPointData& aNextCharPointData); /** * Replace characters starting from aOffset in aResult with normalized * white-space sequence. */ static void ReplaceStringWithNormalizedWhiteSpaceSequence( nsString& aResult, uint32_t aOffset, uint32_t aLength, const CharPointData& aPreviousCharPointData, const CharPointData& aNextCharPointData); /** * ComputeTargetRanges() computes actual delete ranges which will be deleted * unless the following `beforeinput` event is canceled. * * @param aDirectionAndAmount The direction and amount of deletion. * @param aRangesToDelete [In/Out] The ranges to be deleted, * typically, initialized with the * selection ranges. This may be modified * if selection ranges should be extened. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ComputeTargetRanges(nsIEditor::EDirection aDirectionAndAmount, AutoClonedSelectionRangeArray& aRangesToDelete) const; /** * This method handles "delete selection" commands. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result HandleDeleteSelection(nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers) final; class AutoDeleteRangesHandler; class AutoMoveOneLineHandler; /** * DeleteMostAncestorMailCiteElementIfEmpty() deletes most ancestor * mail cite element (`
` or * ``, the former can be created with middle click * paste with `Control` or `Command` even in the web) of aContent if it * becomes empty. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DeleteMostAncestorMailCiteElementIfEmpty(nsIContent& aContent); /** * LiftUpListItemElement() moves aListItemElement outside its parent. * If it's in a middle of a list element, the parent list element is split * before aListItemElement. Then, moves aListItemElement to before its * parent list element. I.e., moves aListItemElement between the 2 list * elements if original parent was split. Then, if new parent becomes not a * list element, the list item element is removed and its contents are moved * to where the list item element was. If aListItemElement becomse not a * child of list element, its contents are unwrapped from aListItemElement. * * @param aListItemElement Must be a
,
or
element. * @param aLiftUpFromAllParentListElements * If Yes, this method calls itself recursively * to unwrap the contents in aListItemElement * from any ancestor list elements. * XXX This checks only direct parent of list * elements. Therefore, if a parent list * element in a list item element, the * list item element and its list element * won't be unwrapped. */ enum class LiftUpFromAllParentListElements { Yes, No }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult LiftUpListItemElement( dom::Element& aListItemElement, LiftUpFromAllParentListElements aLiftUpFromAllParentListElements); /** * DestroyListStructureRecursively() destroys the list structure of * aListElement recursively. * If aListElement has
,
or
as a child, the element is removed * but its descendants are moved to where the list item element was. * If aListElement has another
,
or
as a child, this method is * called recursively. * If aListElement has other nodes as its child, they are just removed. * Finally, aListElement is removed. and its all children are moved to * where the aListElement was. * * @param aListElement A
,
or
element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DestroyListStructureRecursively(Element& aListElement); /** * RemoveListAtSelectionAsSubAction() removes list elements and list item * elements at Selection. And move contents in them where the removed list * was. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveListAtSelectionAsSubAction(const Element& aEditingHost); /** * ChangeMarginStart() changes margin of aElement to indent or outdent. * If it's rtl text, margin-right will be changed. Otherwise, margin-left. * XXX This is not aware of vertical writing-mode. * * @param aElement The element whose start margin should be * changed. * @param aChangeMargin Whether increase or decrease the margin. * @param aEditingHost The editing host. * @return May suggest a suggest point to put caret. */ enum class ChangeMargin { Increase, Decrease }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result ChangeMarginStart(Element& aElement, ChangeMargin aChangeMargin, const Element& aEditingHost); /** * HandleCSSIndentAroundRanges() indents around aRanges with CSS. * * @param aRanges The ranges where the content should be indented. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleCSSIndentAroundRanges( AutoClonedSelectionRangeArray& aRanges, const Element& aEditingHost); /** * HandleCSSIndentAroundRanges() indents around aRanges with HTML. * * @param aRanges The ranges where the content should be indented. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleHTMLIndentAroundRanges( AutoClonedSelectionRangeArray& aRanges, const Element& aEditingHost); /** * HandleIndentAtSelection() indents around Selection with HTML or CSS. * * @param aEditingHost The editing host. */ // TODO: Make this take AutoClonedSelectionRangeArray instead of retrieving // `Selection` [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result HandleIndentAtSelection(const Element& aEditingHost); /** * OutdentPartOfBlock() outdents the nodes between aStartOfOutdent and * aEndOfOutdent. This splits the range off from aBlockElement first. * Then, removes the middle element if aIsBlockIndentedWithCSS is false. * Otherwise, decreases the margin of the middle element. * * @param aBlockElement A block element which includes both * aStartOfOutdent and aEndOfOutdent. * @param aStartOfOutdent First node which is descendant of * aBlockElement will be outdented. * @param aEndOfOutdent Last node which is descandant of * aBlockElement will be outdented. * @param aBlockIndentedWith `CSS` if aBlockElement is indented with * CSS margin property. * `HTML` if aBlockElement is `
` * or something. * @param aEditingHost The editing host. * @return The left content is new created element * splitting before aStartOfOutdent. * The right content is existing element. * The middle content is outdented element * if aBlockIndentedWith is `CSS`. * Otherwise, nullptr. */ enum class BlockIndentedWith { CSS, HTML }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result OutdentPartOfBlock(Element& aBlockElement, nsIContent& aStartOfOutdent, nsIContent& aEndOfOutdent, BlockIndentedWith aBlockIndentedWith, const Element& aEditingHost); /** * HandleOutdentAtSelectionInternal() outdents contents around Selection. * This method creates AutoSelectionRestorer. Therefore, each caller * needs to check if the editor is still available even if this returns * NS_OK. * NOTE: Call `HandleOutdentAtSelection()` instead. * * @param aEditingHost The editing host. * @return The left content is left content of last * outdented element. * The right content is right content of last * outdented element. * The middle content is middle content of last * outdented element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result HandleOutdentAtSelectionInternal(const Element& aEditingHost); /** * HandleOutdentAtSelection() outdents contents around Selection. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result HandleOutdentAtSelection(const Element& aEditingHost); /** * AlignBlockContentsWithDivElement() sets align attribute of
element * which is only child of aBlockElement to aAlignType. If aBlockElement * has 2 or more children or does not have a `
` element, inserts a * new `
` element into aBlockElement and move all children of * aBlockElement into the new `
` element. * * @param aBlockElement The element node whose contents should be * aligned to aAlignType. This should be * an element which can have `
` element * as its child. * @param aAlignType New value of align attribute of `
` * element. * @return A candidate position to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result AlignBlockContentsWithDivElement(Element& aBlockElement, const nsAString& aAlignType); /** * AlignContentsInAllTableCellsAndListItems() calls * AlignBlockContentsWithDivElement() for aligning contents in every list * item element and table cell element in aElement. * * @param aElement The node which is or whose descendants should * be aligned to aAlignType. * @param aAlignType New value of `align` attribute of `
`. * @return A candidate position to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result AlignContentsInAllTableCellsAndListItems(dom::Element& aElement, const nsAString& aAlignType); /** * MakeTransitionList() detects all the transitions in the array, where a * transition means that adjacent nodes in the array don't have the same * parent. */ static void MakeTransitionList( const nsTArray>& aArrayOfContents, nsTArray& aTransitionArray); /** * EnsureHardLineBeginsWithFirstChildOf() inserts `
` element before * first child of aRemovingContainerElement if it will not be start of a * hard line after removing aRemovingContainerElement. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result EnsureHardLineBeginsWithFirstChildOf(Element& aRemovingContainerElement); /** * EnsureHardLineEndsWithLastChildOf() inserts `
` element after last * child of aRemovingContainerElement if it will not be end of a hard line * after removing aRemovingContainerElement. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result EnsureHardLineEndsWithLastChildOf(Element& aRemovingContainerElement); /** * RemoveAlignFromDescendants() removes align attributes, text-align * properties and elements in aElement. * * @param aElement Alignment information of the node and/or its * descendants will be removed. * NOTE: aElement must not be a `
` element. * @param aAlignType New align value to be set only when it's in * CSS mode and this method meets
or
. * XXX This is odd and not clear when you see caller of * this method. Do you have better idea? * @param aEditTarget If `OnlyDescendantsExceptTable`, modifies only * descendants of aElement. * If `NodeAndDescendantsExceptTable`, modifies `aElement` * and its descendants. * @return A candidate point to put caret. */ enum class EditTarget { OnlyDescendantsExceptTable, NodeAndDescendantsExceptTable }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result RemoveAlignFromDescendants(Element& aElement, const nsAString& aAlignType, EditTarget aEditTarget); /** * SetBlockElementAlign() resets `align` attribute, `text-align` property * of descendants of aBlockOrHRElement except `
` element descendants. * Then, set `align` attribute or `text-align` property of aBlockOrHRElement. * * @param aBlockOrHRElement The element whose contents will be aligned. * This must be a block element or `
` element. * If we're not in CSS mode, this element has * to support `align` attribute (i.e., * `HTMLEditUtils::SupportsAlignAttr()` must * return true). * @param aAlignType Boundary or "center" which contents should be * aligned on. * @param aEditTarget If `OnlyDescendantsExceptTable`, modifies only * descendants of aBlockOrHRElement. * If `NodeAndDescendantsExceptTable`, modifies * aBlockOrHRElement and its descendants. * @return A candidate point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SetBlockElementAlign(Element& aBlockOrHRElement, const nsAString& aAlignType, EditTarget aEditTarget); /** * InsertDivElementToAlignContents() inserts a new
element (which has * only a padding
element) to aPointToInsert for a placeholder whose * contents will be aligned. * * @param aPointToInsert A point to insert new empty
. * @param aAlignType New align attribute value where the contents * should be aligned to. * @param aEditingHost The editing host. * @return New
element which has only a padding
* element and is styled to align contents. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertDivElementToAlignContents(const EditorDOMPoint& aPointToInsert, const nsAString& aAlignType, const Element& aEditingHost); /** * AlignNodesAndDescendants() make contents of nodes in aArrayOfContents and * their descendants aligned to aAlignType. * * @param aAlignType New align attribute value where the contents * should be aligned to. * @param aEditingHost The editing host. * @return Last created
element which should contain * caret and candidate position which may be * outside the
element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result AlignNodesAndDescendants( nsTArray>& aArrayOfContents, const nsAString& aAlignType, const Element& aEditingHost); /** * AlignContentsAtRanges() aligns contents around aRanges to aAlignType. * * @param aRanges The ranges where should be aligned. * @param aAlignType New align attribute value where the contents * should be aligned to. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AlignContentsAtRanges( AutoClonedSelectionRangeArray& aRanges, const nsAString& aAlignType, const Element& aEditingHost); /** * AlignAsSubAction() handles "align" command with `Selection`. * * @param aAlignType New align attribute value where the contents * should be aligned to. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result AlignAsSubAction(const nsAString& aAlignType, const Element& aEditingHost); /** * AdjustCaretPositionAndEnsurePaddingBRElement() may adjust caret * position to nearest editable content and if padding `
` element is * necessary at caret position, this creates it. * * @param aDirectionAndAmount Direction of the edit action. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AdjustCaretPositionAndEnsurePaddingBRElement( nsIEditor::EDirection aDirectionAndAmount); /** * EnsureSelectionInBodyOrDocumentElement() collapse `Selection` to the * primary `` element or document element when `Selection` crosses * `` element's boundary. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult EnsureSelectionInBodyOrDocumentElement(); /** * InsertBRElementToEmptyListItemsAndTableCellsInRange() inserts * `
` element into empty list item or table cell elements between * aStartRef and aEndRef. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertBRElementToEmptyListItemsAndTableCellsInRange( const RawRangeBoundary& aStartRef, const RawRangeBoundary& aEndRef); /** * RemoveEmptyNodesIn() removes all empty nodes in aRange. However, if * mail-cite node has only a `
` element, the node will be removed * but
element is moved to where the mail-cite node was. * XXX This method is expensive if aRange is too wide and may remove * unexpected empty element, e.g., it was created by JS, but we haven't * touched it. Cannot we remove this method and make guarantee that * empty nodes won't be created? * * @param aRange Must be positioned. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveEmptyNodesIn(const EditorDOMRange& aRange); /** * SetSelectionInterlinePosition() may set interline position if caret is * positioned around `
` or block boundary. Don't call this when * `Selection` is not collapsed. */ void SetSelectionInterlinePosition(); /** * Called by `HTMLEditor::OnEndHandlingTopLevelEditSubAction()`. This may * adjust Selection, remove unnecessary empty nodes, create `
` elements * if needed, etc. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult OnEndHandlingTopLevelEditSubActionInternal(); /** * MoveSelectedContentsToDivElementToMakeItAbsolutePosition() looks for * a `
` element in selection first. If not, creates new `
` * element. Then, move all selected contents into the target `
` * element. * Note that this creates AutoSelectionRestorer. Therefore, callers need * to check whether we have been destroyed even when this returns NS_OK. * * @param aTargetElement Returns target `
` element which should be * changed to absolute positioned. * @param aEditingHost The editing host. */ // TODO: Rewrite this with `Result, nsresult>`. [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveSelectedContentsToDivElementToMakeItAbsolutePosition( RefPtr* aTargetElement, const Element& aEditingHost); /** * SetSelectionToAbsoluteAsSubAction() move selected contents to first * selected `
` element or newly created `
` element and make * the `
` element positioned absolutely. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SetSelectionToAbsoluteAsSubAction(const Element& aEditingHost); /** * SetSelectionToStaticAsSubAction() sets the `position` property of a * selection parent's block whose `position` is `absolute` to `static`. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SetSelectionToStaticAsSubAction(); /** * AddZIndexAsSubAction() adds aChange to `z-index` of nearest parent * absolute-positioned element from current selection. * * @param aChange Amount to change `z-index`. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result AddZIndexAsSubAction(int32_t aChange); /** * RunOrScheduleOnModifyDocument() is called when editor content is changed. */ MOZ_CAN_RUN_SCRIPT nsresult RunOrScheduleOnModifyDocument( const nsIContent* aContentWillBeRemoved = nullptr); protected: // Called by helper classes. MOZ_CAN_RUN_SCRIPT void OnStartToHandleTopLevelEditSubAction( EditSubAction aTopLevelEditSubAction, nsIEditor::EDirection aDirectionOfTopLevelEditSubAction, ErrorResult& aRv) final; MOZ_CAN_RUN_SCRIPT nsresult OnEndHandlingTopLevelEditSubAction() final; protected: // Shouldn't be used by friend classes virtual ~HTMLEditor(); enum class DOMMutationType { ContentAppended, ContentInserted, ContentWillBeRemoved, CharacterDataChanged, }; [[nodiscard]] LogLevel MutationLogLevelOf( nsIContent* aContent, const CharacterDataChangeInfo* aCharacterDataChangeInfo, DOMMutationType aDOMMutationType) const; [[nodiscard]] LogLevel AttrMutationLogLevelOf( Element* aElement, int32_t aNameSpaceID, nsAtom* aAttribute, AttrModType aModType, const nsAttrValue* aOldValue) const; void MaybeLogContentAppended(nsIContent*) const; void MaybeLogContentInserted(nsIContent*) const; void MaybeLogContentWillBeRemoved(nsIContent*) const; void MaybeLogCharacterDataChanged(nsIContent*, const CharacterDataChangeInfo&) const; void MaybeLogAttributeChanged(Element*, int32_t, nsAtom*, AttrModType, const nsAttrValue*) const; /** * InitEditorContentAndSelection() may insert `
` elements and padding * `
` elements if they are required for `` or document element. * And collapse selection at the end if there is no selection ranges. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InitEditorContentAndSelection(); /** * Collapse `Selection` to the last leaf content of the or the document * element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CollapseSelectionToEndOfLastLeafNodeOfDocument() const; MOZ_CAN_RUN_SCRIPT nsresult SelectAllInternal() final; [[nodiscard]] Element* ComputeEditingHostInternal( const nsIContent* aContent, LimitInBodyElement aLimitInBodyElement) const; /** * Creates a range with just the supplied node and appends that to the * selection. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AppendContentToSelectionAsRange(nsIContent& aContent); /** * When you are using AppendContentToSelectionAsRange(), call this first to * start a new selection. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ClearSelection(); /** * SelectContentInternal() sets Selection to aContentToSelect to * aContentToSelect + 1 in parent of aContentToSelect. * * @param aContentToSelect The content which should be selected. */ MOZ_CAN_RUN_SCRIPT nsresult SelectContentInternal(nsIContent& aContentToSelect); /** * GetInclusiveAncestorByTagNameAtSelection() looks for an element node whose * name matches aTagName from anchor node of Selection to element. * * @param aTagName The tag name which you want to look for. * Must not be nsGkAtoms::_empty. * If nsGkAtoms::list, the result may be
,
or *
element. * If nsGkAtoms::td, the result may be
element in the most * nearest ancestor of aTableOrElementInTable or itself. * When aTableOrElementInTable is neither
or . * If nsGkAtoms::href, the result may be element * which has "href" attribute with non-empty value. * If nsGkAtoms::anchor, the result may be which * has "name" attribute with non-empty value. * @return If an element which matches aTagName, returns * an Element. Otherwise, nullptr. */ Element* GetInclusiveAncestorByTagNameAtSelection( const nsStaticAtom& aTagName) const; /** * GetInclusiveAncestorByTagNameInternal() looks for an element node whose * name matches aTagName from aNode to element. * * @param aTagName The tag name which you want to look for. * Must not be nsGkAtoms::_empty. * If nsGkAtoms::list, the result may be
,
or *
element. * If nsGkAtoms::td, the result may be
or . * If nsGkAtoms::href, the result may be element * which has "href" attribute with non-empty value. * If nsGkAtoms::anchor, the result may be which * has "name" attribute with non-empty value. * @param aContent Start node to look for the element. This should * not be an orphan node. * @return If an element which matches aTagName, returns * an Element. Otherwise, nullptr. */ Element* GetInclusiveAncestorByTagNameInternal( const nsStaticAtom& aTagName, const nsIContent& aContent) const; /** * GetSelectedElement() returns a "selected" element node. "selected" means: * - there is only one selection range * - the range starts from an element node or in an element * - the range ends at immediately after same element * - and the range does not include any other element nodes. * Additionally, only when aTagName is nsGkAtoms::href, this thinks that an * element which has non-empty "href" attribute includes the range, the * element is selected. * * NOTE: This method is implementation of nsIHTMLEditor.getSelectedElement() * and comm-central depends on this behavior. Therefore, if you need to use * this method internally but you need to change, perhaps, you should create * another method for avoiding breakage of comm-central apps. * * @param aTagName The atom of tag name in lower case. Set this to * result of EditorUtils::GetTagNameAtom() if you have a * tag name with nsString. * If nullptr, this returns any element node or nullptr. * If nsGkAtoms::href, this returns an element which * has non-empty "href" attribute or nullptr. * If nsGkAtoms::anchor, this returns an element which * has non-empty "name" attribute or nullptr. * Otherwise, returns an element node whose name is * same as aTagName or nullptr. * @param aRv Returns error code. * @return A "selected" element. */ already_AddRefed GetSelectedElement(const nsAtom* aTagName, ErrorResult& aRv); /** * GetFirstTableRowElement() returns the first
nor in a
element, * returns NS_ERROR_FAILURE. However, if
does not have element, * returns nullptr. * * @param aTableOrElementInTable
element or another element. * If this is a
element, returns * first element in it. Otherwise, * returns first element in nearest * ancestor
element. */ Result, nsresult> GetFirstTableRowElement( const Element& aTableOrElementInTable) const; /** * GetNextTableRowElement() returns next element of aTableRowElement. * This won't cross
element boundary but may cross table section * elements like . * Note that if given element is but there is no next element, this * returns nullptr but does not return error. * * @param aTableRowElement A element. */ Result, nsresult> GetNextTableRowElement( const Element& aTableRowElement) const; struct CellData; /** * CellIndexes store both row index and column index of a table cell. */ struct MOZ_STACK_CLASS CellIndexes final { int32_t mRow; int32_t mColumn; /** * This constructor initializes mRowIndex and mColumnIndex with indexes of * aCellElement. * * @param aCellElement An or //
or element. */ MOZ_CAN_RUN_SCRIPT CellIndexes(Element& aCellElement, PresShell* aPresShell) : mRow(-1), mColumn(-1) { Update(aCellElement, aPresShell); } /** * Update mRowIndex and mColumnIndex with indexes of aCellElement. * * @param See above. */ MOZ_CAN_RUN_SCRIPT void Update(Element& aCellElement, PresShell* aPresShell); /** * This constructor initializes mRowIndex and mColumnIndex with indexes of * cell element which contains anchor of Selection. * * @param aHTMLEditor The editor which creates the instance. * @param aSelection The Selection for the editor. */ MOZ_CAN_RUN_SCRIPT CellIndexes(HTMLEditor& aHTMLEditor, Selection& aSelection) : mRow(-1), mColumn(-1) { Update(aHTMLEditor, aSelection); } /** * Update mRowIndex and mColumnIndex with indexes of cell element which * contains anchor of Selection. * * @param See above. */ MOZ_CAN_RUN_SCRIPT void Update(HTMLEditor& aHTMLEditor, Selection& aSelection); bool operator==(const CellIndexes& aOther) const { return mRow == aOther.mRow && mColumn == aOther.mColumn; } bool operator!=(const CellIndexes& aOther) const { return mRow != aOther.mRow || mColumn != aOther.mColumn; } [[nodiscard]] bool isErr() const { return mRow < 0 || mColumn < 0; } private: CellIndexes() : mRow(-1), mColumn(-1) {} CellIndexes(int32_t aRowIndex, int32_t aColumnIndex) : mRow(aRowIndex), mColumn(aColumnIndex) {} friend struct CellData; }; struct MOZ_STACK_CLASS CellData final { MOZ_KNOWN_LIVE RefPtr mElement; // Current indexes which this is initialized with. CellIndexes mCurrent; // First column/row indexes of the cell. When current position is spanned // from other column/row, this value becomes different from mCurrent. CellIndexes mFirst; // Computed rowspan/colspan values which are specified to the cell. // Note that if the cell has larger rowspan/colspan value than actual // table size, these values are the larger values. int32_t mRowSpan = -1; int32_t mColSpan = -1; // Effective rowspan/colspan value at the index. For example, if first // cell element in first row has rowspan="3", then, if this is initialized // with 0-0 indexes, effective rowspan is 3. However, if this is // initialized with 1-0 indexes, effective rowspan is 2. int32_t mEffectiveRowSpan = -1; int32_t mEffectiveColSpan = -1; // mIsSelected is set to true if mElement itself or its parent
is selected. Otherwise, e.g., the cell just contains selection // range, this is set to false. bool mIsSelected = false; CellData() = delete; /** * This returns an instance which is initialized with a
element and * both row and column index to specify a cell element. */ [[nodiscard]] static CellData AtIndexInTableElement( const HTMLEditor& aHTMLEditor, const Element& aTableElement, int32_t aRowIndex, int32_t aColumnIndex); [[nodiscard]] static CellData AtIndexInTableElement( const HTMLEditor& aHTMLEditor, const Element& aTableElement, const CellIndexes& aIndexes) { MOZ_ASSERT(!aIndexes.isErr()); return AtIndexInTableElement(aHTMLEditor, aTableElement, aIndexes.mRow, aIndexes.mColumn); } /** * Treated as error if fails to compute current index or first index of the * cell. Note that even if the cell is not found due to no corresponding * frame at current index, it's not an error situation. */ [[nodiscard]] bool isOk() const { return !isErr(); } [[nodiscard]] bool isErr() const { return mFirst.isErr(); } /** * FailedOrNotFound() returns true if this failed to initialize/update * or succeeded but found no cell element. */ [[nodiscard]] bool FailedOrNotFound() const { return isErr() || !mElement; } /** * IsSpannedFromOtherRowOrColumn(), IsSpannedFromOtherColumn and * IsSpannedFromOtherRow() return true if there is no cell element * at the index because of spanning from other row and/or column. */ [[nodiscard]] bool IsSpannedFromOtherRowOrColumn() const { return mElement && mCurrent != mFirst; } [[nodiscard]] bool IsSpannedFromOtherColumn() const { return mElement && mCurrent.mColumn != mFirst.mColumn; } [[nodiscard]] bool IsSpannedFromOtherRow() const { return mElement && mCurrent.mRow != mFirst.mRow; } [[nodiscard]] bool IsNextColumnSpannedFromOtherColumn() const { return mElement && mCurrent.mColumn + 1 < NextColumnIndex(); } /** * NextColumnIndex() and NextRowIndex() return column/row index of * next cell. Note that this does not check whether there is next * cell or not actually. */ [[nodiscard]] int32_t NextColumnIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mColumn + mEffectiveColSpan; } [[nodiscard]] int32_t NextRowIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mRow + mEffectiveRowSpan; } /** * LastColumnIndex() and LastRowIndex() return column/row index of * column/row which is spanned by the cell. */ [[nodiscard]] int32_t LastColumnIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return NextColumnIndex() - 1; } [[nodiscard]] int32_t LastRowIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return NextRowIndex() - 1; } /** * NumberOfPrecedingColmuns() and NumberOfPrecedingRows() return number of * preceding columns/rows if current index is spanned from other column/row. * Otherwise, i.e., current point is not spanned form other column/row, * returns 0. */ [[nodiscard]] int32_t NumberOfPrecedingColmuns() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mColumn - mFirst.mColumn; } [[nodiscard]] int32_t NumberOfPrecedingRows() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mRow - mFirst.mRow; } /** * NumberOfFollowingColumns() and NumberOfFollowingRows() return * number of remaining columns/rows if the cell spans to other * column/row. */ [[nodiscard]] int32_t NumberOfFollowingColumns() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mEffectiveColSpan - 1; } [[nodiscard]] int32_t NumberOfFollowingRows() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mEffectiveRowSpan - 1; } private: explicit CellData(int32_t aCurrentRowIndex, int32_t aCurrentColumnIndex, int32_t aFirstRowIndex, int32_t aFirstColumnIndex) : mCurrent(aCurrentRowIndex, aCurrentColumnIndex), mFirst(aFirstRowIndex, aFirstColumnIndex) {} explicit CellData(Element& aElement, int32_t aRowIndex, int32_t aColumnIndex, nsTableCellFrame& aTableCellFrame, nsTableWrapperFrame& aTableWrapperFrame); [[nodiscard]] static CellData Error(int32_t aRowIndex, int32_t aColumnIndex) { return CellData(aRowIndex, aColumnIndex, -1, -1); } [[nodiscard]] static CellData NotFound(int32_t aRowIndex, int32_t aColumnIndex) { return CellData(aRowIndex, aColumnIndex, aRowIndex, aColumnIndex); } }; /** * TableSize stores and computes number of rows and columns of a
* element. */ struct MOZ_STACK_CLASS TableSize final { int32_t mRowCount; int32_t mColumnCount; TableSize() = delete; /** * @param aHTMLEditor The editor which creates the instance. * @param aTableOrElementInTable If a
element, computes number * of rows and columns of it. * If another element in a
element, * computes number of rows and columns * of nearest ancestor
element. * Otherwise, i.e., non-
element * not in
, returns error. */ [[nodiscard]] static Result Create( HTMLEditor& aHTMLEditor, Element& aTableOrElementInTable); [[nodiscard]] bool IsEmpty() const { return !mRowCount || !mColumnCount; } private: TableSize(int32_t aRowCount, int32_t aColumCount) : mRowCount(aRowCount), mColumnCount(aColumCount) {} }; /** * GetTableCellElementAt() returns a
or element of aTableElement * if there is a cell at the indexes. * * @param aTableElement Must be a element. * @param aCellIndexes Indexes of cell which you want. * If rowspan and/or colspan is specified 2 or * larger, any indexes are allowed to retrieve * the cell in the area. * @return The cell element if there is in the
. * Returns nullptr without error if the indexes * are out of bounds. */ [[nodiscard]] inline Element* GetTableCellElementAt( Element& aTableElement, const CellIndexes& aCellIndexes) const; [[nodiscard]] Element* GetTableCellElementAt(Element& aTableElement, int32_t aRowIndex, int32_t aColumnIndex) const; /** * GetSelectedOrParentTableElement() returns or
, ,
* element: * #1 if the first selection range selects a cell, returns it. * #2 if the first selection range does not select a cell and * the selection anchor refers a
, returns it. * #3 if the first selection range does not select a cell and * the selection anchor refers a , returns it. * #4 if the first selection range does not select a cell and * the selection anchor refers a
, returns it. * #5 otherwise, nearest ancestor or element of the * selection anchor if there is. * In #1 and #4, *aIsCellSelected will be set to true (i.e,, when * a selection range selects a cell element). */ Result, nsresult> GetSelectedOrParentTableElement( bool* aIsCellSelected = nullptr) const; /** * GetFirstSelectedCellElementInTable() returns or element at * first selection (using GetSelectedOrParentTableElement). If found cell * element is not in or element, this returns nullptr. */ Result, nsresult> GetFirstSelectedCellElementInTable() const; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePaste(AutoEditActionDataSetter& aEditActionData, nsIClipboard::ClipboardType aClipboardType, DataTransfer* aDataTransfer) final; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePasteAsQuotation(AutoEditActionDataSetter& aEditActionData, nsIClipboard::ClipboardType aClipboardType, DataTransfer* aDataTransfer) final; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePasteTransferable(AutoEditActionDataSetter& aEditActionData, nsITransferable& aTransferable) final; /** * PasteInternal() pasts text with replacing selected content. * This tries to dispatch ePaste event first. If its defaultPrevent() is * called, this does nothing but returns NS_OK. * * @param aClipboardType nsIClipboard::kGlobalClipboard or * nsIClipboard::kSelectionClipboard. * @param aEditingHost The editing host. */ MOZ_CAN_RUN_SCRIPT nsresult PasteInternal(nsIClipboard::ClipboardType aClipboardType, DataTransfer* aDataTransfer, const Element& aEditingHost); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertWithQuotationsAsSubAction(const nsAString& aQuotedText) final; /** * InsertAsCitedQuotationInternal() inserts a
element whose * cite attribute is aCitation and whose content is aQuotedText. * Note that this shouldn't be called when IsPlaintextMailComposer() is true. * * @param aQuotedText HTML source if aInsertHTML is true. Otherwise, * plain text. This is inserted into new
* element. * @param aCitation cite attribute value of new
element. * @param aInsertHTML true if aQuotedText should be treated as HTML * source. * false if aQuotedText should be treated as plain * text. * @param aEditingHost The editing host. * @param aNodeInserted [OUT] The new
element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsCitedQuotationInternal( const nsAString& aQuotedText, const nsAString& aCitation, bool aInsertHTML, const Element& aEditingHost, nsINode** aNodeInserted); /** * InsertNodeIntoProperAncestorWithTransaction() attempts to insert aNode * into the document, at aPointToInsert. Checks with strict dtd to see if * containment is allowed. If not allowed, will attempt to find a parent * in the parent hierarchy of aPointToInsert.GetContainer() that will accept * aNode as a child. If such a parent is found, will split the document * tree from aPointToInsert up to parent, and then insert aNode. * aPointToInsert is then adjusted to point to the actual location that * aNode was inserted at. aSplitAtEdges specifies if the splitting process * is allowed to result in empty nodes. * * @param aContent The content node to insert. * @param aPointToInsert Insertion point. * @param aSplitAtEdges Splitting can result in empty nodes? */ template [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result, nsresult> InsertNodeIntoProperAncestorWithTransaction( NodeType& aContent, const EditorDOMPoint& aPointToInsert, SplitAtEdges aSplitAtEdges); /** * InsertTextWithQuotationsInternal() replaces selection with new content. * First, this method splits aStringToInsert to multiple chunks which start * with non-linebreaker except first chunk and end with a linebreaker except * last chunk. Then, each chunk starting with ">" is inserted after wrapping * with , and each chunk not starting with ">" is * inserted as normal text. */ MOZ_CAN_RUN_SCRIPT nsresult InsertTextWithQuotationsInternal( const nsAString& aStringToInsert, const Element& aEditingHost); /** * ReplaceContainerWithTransactionInternal() is implementation of * ReplaceContainerWithTransaction() and * ReplaceContainerAndCloneAttributesWithTransaction(). * * @param aOldContainer The element which will be replaced with new * element. * @param aTagName The name of new element node. * @param aAttribute Attribute name which will be set to the new * element. This will be ignored if * aCloneAllAttributes is set to true. * @param aAttributeValue Attribute value which will be set to * aAttribute. * @param aCloneAllAttributes If true, all attributes of aOldContainer will * be copied to the new element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result ReplaceContainerWithTransactionInternal(Element& aOldContainer, const nsAtom& aTagName, const nsAtom& aAttribute, const nsAString& aAttributeValue, bool aCloneAllAttributes); /** * DeleteSelectionAndCreateElement() creates a element whose name is aTag. * And insert it into the DOM tree after removing the selected content. * * @param aTag The element name to be created. * @param aInitializer A function to initialize the new element before * or after (depends on the pref) connecting the * element into the DOM tree. Note that this should * not touch outside given element because doing it * would break range updater's result. */ MOZ_CAN_RUN_SCRIPT Result, nsresult> DeleteSelectionAndCreateElement( nsAtom& aTag, const InitializeInsertingElement& aInitializer = DoNothingForNewElement); /** * This method first deletes the selection, if it's not collapsed. Then if * the selection lies in a CharacterData node, it splits it. If the * selection is at this point collapsed in a CharacterData node, it's * adjusted to be collapsed right before or after the node instead (which is * always possible, since the node was split). */ MOZ_CAN_RUN_SCRIPT nsresult DeleteSelectionAndPrepareToCreateNode(); /** * PrepareToInsertLineBreak() returns a point where a new line break node * should be inserted. If aPointToInsert points middle of a text node, this * method splits the text node and returns the point before right node. * * @param aLineBreakType Whether you will insert
or a preformatted * linefeed. * @param aPointToInsert Candidate point to insert new line break node. * @return Computed point to insert new line break node. * If something failed, this return error. */ MOZ_CAN_RUN_SCRIPT Result PrepareToInsertLineBreak( LineBreakType aLineBreakType, const EditorDOMPoint& aPointToInsert); enum class PreservePreformattedLineBreak : bool { No, Yes }; /** * If unnecessary line break is there immediately after aPoint, this deletes * the line break. Note that unnecessary line break means that the line break * is a padding line break for empty line immediately before a block boundary * and it's not a placeholder of ancestor inline elements. * * @param aNextOrAfterModifiedPoint * If you inserted something, this should be next * point or after the inserted content. If you * deleted something, this should be end of the * deleted range. * @param aPreservePreformattedLineBreak * Whether this method should preserve preformatted * linefeed or not. If "Yes", this will delete only * when the unnecessary line break is a
. * @param aPaddingForEmptyBlock * Treat the line break for empty block is * unnecessary or not. If this is set to * "Unnecessary", preformatted line break will be * deleted if it's a padding for empty block and * aPreservePreformattedLineBreak is "Yes". * This should be "Significant" if you use this * after handling the edit action. So, you can use * "Unnecessary" only when you are calling this * before handling the edit action. * @param aEditingHost The editing host containing * aNextOrAfterModifiedPoint. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult EnsureNoFollowingUnnecessaryLineBreak( const EditorDOMPoint& aNextOrAfterModifiedPoint, PreservePreformattedLineBreak aPreservePreformattedLineBreak, PaddingForEmptyBlock aPaddingForEmptyBlock, const Element& aEditingHost); /** * IndentAsSubAction() indents the content around Selection. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result IndentAsSubAction(const Element& aEditingHost); /** * OutdentAsSubAction() outdents the content around Selection. * * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result OutdentAsSubAction(const Element& aEditingHost); MOZ_CAN_RUN_SCRIPT nsresult LoadHTML(const nsAString& aInputString); /** * UpdateMetaCharsetWithTransaction() scans all elements in the * document and if and only if there is a element having `httpEquiv` * attribute and whose value includes `content-type`, updates its `content` * attribute value to aCharacterSet. */ MOZ_CAN_RUN_SCRIPT bool UpdateMetaCharsetWithTransaction( Document& aDocument, const nsACString& aCharacterSet); /** * SetInlinePropertiesAsSubAction() stores new styles with * mPendingStylesToApplyToNewContent if `Selection` is collapsed. Otherwise, * applying the styles to all selected contents. * * @param aStylesToSet The styles which should be applied to the * selected content. * @param aEditingHost The editing host. */ template [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAsSubAction( const AutoTArray& aStylesToSet, const Element& aEditingHost); /** * SetInlinePropertiesAroundRanges() applying the styles to the ranges even if * the ranges are collapsed. */ template [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAroundRanges( AutoClonedRangeArray& aRanges, const AutoTArray& aStylesToSet, const Element& aEditingHost); /** * RemoveInlinePropertiesAsSubAction() removes specified styles from * mPendingStylesToApplyToNewContent if `Selection` is collapsed. Otherwise, * removing the style. * * @param aStylesToRemove Styles to remove from the selected contents. * @param aEditingHost The editing host. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveInlinePropertiesAsSubAction( const nsTArray& aStylesToRemove, const Element& aEditingHost); /** * Helper method to call RemoveInlinePropertiesAsSubAction(). If you want to * remove other elements to remove the style completely, this will append * related elements of aStyleToRemove and aStyleToRemove itself to the array. * E.g., nsGkAtoms::strong and nsGkAtoms::b will be appended if aStyleToRemove * is nsGkAtoms::b. */ void AppendInlineStyleAndRelatedStyle( const EditorInlineStyle& aStyleToRemove, nsTArray& aStylesToRemove) const; enum class RetrievingBackgroundColorOption { // Ignore inline styles, i.e., return only background color of ancestor // blocks. OnlyBlockBackgroundColor, // Stop at nearest inclusive ancestor block. StopAtInclusiveAncestorBlock, // Return default background color for the document if there is no ancestor // elements which have background color. DefaultColorIfNoSpecificBackgroundColor, }; using RetrievingBackgroundColorOptions = EnumSet; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetCSSBackgroundColorState(bool* aMixed, nsAString& aOutColor, RetrievingBackgroundColorOptions aOptions); nsresult GetHTMLBackgroundColorState(bool* aMixed, nsAString& outColor); /** * This sets background on the appropriate container element (table, cell,) * or calls to set the page background. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetBlockBackgroundColorWithCSSAsSubAction(const nsAString& aColor); MOZ_CAN_RUN_SCRIPT nsresult SetHTMLBackgroundColorWithTransaction(const nsAString& aColor); MOZ_CAN_RUN_SCRIPT_BOUNDARY void InitializeSelectionAncestorLimit( Element& aAncestorLimit) const final; /** * Make the given selection span the entire document. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SelectEntireDocument() final; /** * Use this to assure that selection is set after attribute nodes when * trying to collapse selection at begining of a block node * e.g., when setting at beginning of a table cell * This will stop at a table, however, since we don't want to * "drill down" into nested tables. */ MOZ_CAN_RUN_SCRIPT void CollapseSelectionToDeepestNonTableFirstChild( nsINode* aNode); /** * MaybeCollapseSelectionAtFirstEditableNode() may collapse selection at * proper position to staring to edit. If there is a non-editable node * before any editable text nodes or inline elements which can have text * nodes as their children, collapse selection at start of the editing * host. If there is an editable text node which is not collapsed, collapses * selection at the start of the text node. If there is an editable inline * element which cannot have text nodes as its child, collapses selection at * before the element node. Otherwise, collapses selection at start of the * editing host. * * @param aIgnoreIfSelectionInEditingHost * This method does nothing if selection is in the * editing host except if it's collapsed at start of * the editing host. * Note that if selection ranges were outside of * current selection limiter, selection was collapsed * at the start of the editing host therefore, if * you call this with setting this to true, you can * keep selection ranges if user has already been * changed. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MaybeCollapseSelectionAtFirstEditableNode( bool aIgnoreIfSelectionInEditingHost) const; /** * Join aLeftText and aRightText with normalizing white-spaces at the joining * point if it's required. aRightText must be the next sibling of aLeftText. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result JoinTextNodesWithNormalizeWhiteSpaces(Text& aLeftText, Text& aRightText); class BlobReader final { using AutoEditActionDataSetter = EditorBase::AutoEditActionDataSetter; public: MOZ_CAN_RUN_SCRIPT BlobReader(dom::BlobImpl* aBlob, HTMLEditor* aHTMLEditor, SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert, DeleteSelectedContent aDeleteSelectedContent, const Element& aEditingHost); NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(BlobReader) NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(BlobReader) MOZ_CAN_RUN_SCRIPT nsresult OnResult(const nsACString& aResult); nsresult OnError(const nsAString& aErrorName); private: ~BlobReader() = default; RefPtr mBlob; RefPtr mHTMLEditor; RefPtr mEditingHost; RefPtr mDataTransfer; EditorDOMPoint mPointToInsert; EditAction mEditAction; SafeToInsertData mSafeToInsertData; DeleteSelectedContent mDeleteSelectedContent; bool mNeedsToDispatchBeforeInputEvent; }; void CreateEventListeners() final; nsresult InstallEventListeners() final; bool ShouldReplaceRootElement() const; MOZ_CAN_RUN_SCRIPT void NotifyRootChanged(); Element* GetBodyElement() const; /** * Get the focused node of this editor. * @return If the editor has focus, this returns the focused node. * Otherwise, returns null. */ nsINode* GetFocusedNode() const; already_AddRefed GetInputEventTargetElement() const final; /** * Return TRUE if aElement is a table-related elemet and caret was set. */ MOZ_CAN_RUN_SCRIPT bool SetCaretInTableCell(dom::Element* aElement); /** * HandleTabKeyPressInTable() handles "Tab" key press in table if selection * is in a `
` element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result HandleTabKeyPressInTable(WidgetKeyboardEvent* aKeyboardEvent); /** * InsertPosition is an enum to indicate where the method should insert to. */ enum class InsertPosition { // Before selected cell or a cell containing first selection range. eBeforeSelectedCell, // After selected cell or a cell containing first selection range. eAfterSelectedCell, }; /** * InsertTableCellsWithTransaction() inserts element. * @param aNumberOfCellsToInsert Number of cells to insert. * @return The first inserted cell element and * start of the last inserted cell element * as a point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result InsertTableCellsWithTransaction(const EditorDOMPoint& aPointToInsert, int32_t aNumberOfCellsToInsert); /** * InsertTableColumnsWithTransaction() inserts cell elements to every rows * at same column index as the cell specified by aPointToInsert. * * @param aNumberOfColumnsToInsert Number of columns to insert. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertTableColumnsWithTransaction( const EditorDOMPoint& aPointToInsert, int32_t aNumberOfColumnsToInsert); /** * InsertTableRowsWithTransaction() inserts elements before or after * aCellElement. When aCellElement spans rows and aInsertPosition is * eAfterSelectedCell, new rows will be inserted after the most-bottom row * which contains the cell. * * @param aCellElement The cell element pinting where this will * insert a row before or after. * @param aNumberOfRowsToInsert Number of rows to insert. * @param aInsertPosition Before or after the target cell which * contains first selection range. */ MOZ_CAN_RUN_SCRIPT nsresult InsertTableRowsWithTransaction( Element& aCellElement, int32_t aNumberOfRowsToInsert, InsertPosition aInsertPosition); /** * Insert a new cell after or before supplied aCell. * Optional: If aNewCell supplied, returns the newly-created cell (addref'd, * of course) * This doesn't change or use the current selection. */ MOZ_CAN_RUN_SCRIPT nsresult InsertCell(Element* aCell, int32_t aRowSpan, int32_t aColSpan, bool aAfter, bool aIsHeader, Element** aNewCell); /** * DeleteSelectedTableColumnsWithTransaction() removes cell elements which * belong to same columns of selected cell elements. * If only one cell element is selected or first selection range is * in a cell, removes cell elements which belong to same column. * If 2 or more cell elements are selected, removes cell elements which * belong to any of all selected columns. In this case, * aNumberOfColumnsToDelete is ignored. * If there is no selection ranges, returns error. * If selection is not in a cell element, this does not return error, * just does nothing. * WARNING: This does not remove nor elements. * * @param aNumberOfColumnsToDelete Number of columns to remove. This is * ignored if 2 ore more cells are * selected. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteSelectedTableColumnsWithTransaction(int32_t aNumberOfColumnsToDelete); /** * DeleteTableColumnWithTransaction() removes cell elements which belong * to the specified column. * This method adjusts colspan attribute value if cells spanning the * column to delete. * WARNING: This does not remove nor elements. * * @param aTableElement The
elements at aPointToInsert. * Note that this simply inserts elements, i.e., colspan and rowspan * around the cell containing selection are not modified. So, for example, * adding a cell to rectangular table changes non-rectangular table. * And if the cell containing selection is at left of row-spanning cell, * it may be moved to right side of the row-spanning cell after inserting * some cell elements before it. Similarly, colspan won't be adjusted * for keeping table rectangle. * Finally, puts caret into previous cell of the insertion point or the * first inserted cell if aPointToInsert is start of the row. * * @param aPointToInsert The place to insert one or more cell * elements. The container must be a *

element which contains the * column which you want to remove. * @param aRowIndex Index of the column which you want to remove. * 0 is the first column. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteTableColumnWithTransaction( Element& aTableElement, int32_t aColumnIndex); /** * DeleteSelectedTableRowsWithTransaction() removes elements. * If only one cell element is selected or first selection range is * in a cell, removes elements starting from a element * containing the selected cell or first selection range. * If 2 or more cell elements are selected, all elements * which contains selected cell(s). In this case, aNumberOfRowsToDelete * is ignored. * If there is no selection ranges, returns error. * If selection is not in a cell element, this does not return error, * just does nothing. * * @param aNumberOfRowsToDelete Number of rows to remove. This is ignored * if 2 or more cells are selected. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteSelectedTableRowsWithTransaction(int32_t aNumberOfRowsToDelete); /** * DeleteTableRowWithTransaction() removes a element whose index in * the
is aRowIndex. * This method adjusts rowspan attribute value if the element contains * cells which spans rows. * * @param aTableElement The
element which contains the * element which you want to remove. * @param aRowIndex Index of the element which you want to * remove. 0 is the first row. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteTableRowWithTransaction(Element& aTableElement, int32_t aRowIndex); /** * DeleteTableCellWithTransaction() removes table cell elements. If two or * more cell elements are selected, this removes all selected cell elements. * Otherwise, this removes some cell elements starting from selected cell * element or a cell containing first selection range. When this removes * last cell element in or
, this removes the or the *
too. Note that when removing a cell causes number of its row * becomes less than the others, this method does NOT fill the place with * rowspan nor colspan. This does not return error even if selection is not * in cell element, just does nothing. * * @param aNumberOfCellsToDelete Number of cells to remove. This is ignored * if 2 or more cells are selected. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteTableCellWithTransaction(int32_t aNumberOfCellsToDelete); /** * DeleteAllChildrenWithTransaction() removes all children of aElement from * the tree. * * @param aElement The element whose children you want to remove. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteAllChildrenWithTransaction(Element& aElement); /** * Move all contents from aCellToMerge into aTargetCell (append at end). */ MOZ_CAN_RUN_SCRIPT nsresult MergeCells(RefPtr aTargetCell, RefPtr aCellToMerge, bool aDeleteCellToMerge); /** * DeleteTableElementAndChildren() removes aTableElement (and its children) * from the DOM tree with transaction. * * @param aTableElement The
element which you want to remove. */ MOZ_CAN_RUN_SCRIPT nsresult DeleteTableElementAndChildrenWithTransaction(Element& aTableElement); MOZ_CAN_RUN_SCRIPT nsresult SetColSpan(Element* aCell, int32_t aColSpan); MOZ_CAN_RUN_SCRIPT nsresult SetRowSpan(Element* aCell, int32_t aRowSpan); /** * Helper used to get nsTableWrapperFrame for a table. */ static nsTableWrapperFrame* GetTableFrame(const Element* aTable); /** * GetNumberOfCellsInRow() returns number of actual cell elements in the row. * If some cells appear by "rowspan" in other rows, they are ignored. * * @param aTableElement The
element. * @param aRowIndex Valid row index in aTableElement. This method * counts cell elements in the row. * @return -1 if this meets unexpected error. * Otherwise, number of cells which this method found. */ int32_t GetNumberOfCellsInRow(Element& aTableElement, int32_t aRowIndex); /** * Test if all cells in row or column at given index are selected. */ bool AllCellsInRowSelected(Element* aTable, int32_t aRowIndex, int32_t aNumberOfColumns); bool AllCellsInColumnSelected(Element* aTable, int32_t aColIndex, int32_t aNumberOfRows); bool IsEmptyCell(Element* aCell); /** * Most insert methods need to get the same basic context data. * Any of the pointers may be null if you don't need that datum (for more * efficiency). * Input: *aCell is a known cell, * if null, cell is obtained from the anchor node of the selection. * Returns NS_EDITOR_ELEMENT_NOT_FOUND if cell is not found even if aCell is * null. */ MOZ_CAN_RUN_SCRIPT nsresult GetCellContext(Element** aTable, Element** aCell, nsINode** aCellParent, int32_t* aCellOffset, int32_t* aRowIndex, int32_t* aColIndex); nsresult GetCellSpansAt(Element* aTable, int32_t aRowIndex, int32_t aColIndex, int32_t& aActualRowSpan, int32_t& aActualColSpan); MOZ_CAN_RUN_SCRIPT nsresult SplitCellIntoColumns( Element* aTable, int32_t aRowIndex, int32_t aColIndex, int32_t aColSpanLeft, int32_t aColSpanRight, Element** aNewCell); MOZ_CAN_RUN_SCRIPT nsresult SplitCellIntoRows( Element* aTable, int32_t aRowIndex, int32_t aColIndex, int32_t aRowSpanAbove, int32_t aRowSpanBelow, Element** aNewCell); MOZ_CAN_RUN_SCRIPT nsresult CopyCellBackgroundColor(Element* aDestCell, Element* aSourceCell); /** * Reduce rowspan/colspan when cells span into nonexistent rows/columns. */ MOZ_CAN_RUN_SCRIPT nsresult FixBadRowSpan(Element* aTable, int32_t aRowIndex, int32_t& aNewRowCount); MOZ_CAN_RUN_SCRIPT nsresult FixBadColSpan(Element* aTable, int32_t aColIndex, int32_t& aNewColCount); /** * XXX NormalizeTableInternal() is broken. If it meets a cell which has * bigger or smaller rowspan or colspan than actual number of cells, * this always failed to scan the table. Therefore, this does nothing * when the table should be normalized. * * @param aTableOrElementInTable An element which is in a
element * or
element itself. Otherwise, * this returns NS_OK but does nothing. */ MOZ_CAN_RUN_SCRIPT nsresult NormalizeTableInternal(Element& aTableOrElementInTable); /** * Fallback method: Call this after using ClearSelection() and you * failed to set selection to some other content in the document. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetSelectionAtDocumentStart(); // Methods for handling plaintext quotations MOZ_CAN_RUN_SCRIPT nsresult PasteAsPlaintextQuotation( nsIClipboard::ClipboardType aSelectionType, DataTransfer* aDataTransfer, const Element& aEditingHost); enum class AddCites { No, Yes }; /** * Insert a string as quoted text, replacing the selected text (if any). * @param aQuotedText The string to insert. * @param aAddCites Whether to prepend extra ">" to each line * (usually true, unless those characters * have already been added.) * @param aEditingHost The editing host. * @return aNodeInserted The node spanning the insertion, if applicable. * If aAddCites is false, this will be null. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsPlaintextQuotation( const nsAString& aQuotedText, AddCites aAddCites, const Element& aEditingHost, nsINode** aNodeInserted = nullptr); /** * InsertObject() inserts given object at aPointToInsert. * * @param aType one of kFileMime, kJPEGImageMime, kJPGImageMime, * kPNGImageMime, kGIFImageMime. */ MOZ_CAN_RUN_SCRIPT nsresult InsertObject( const nsACString& aType, nsISupports* aObject, SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert, DeleteSelectedContent aDeleteSelectedContent, const Element& aEditingHost); class HTMLTransferablePreparer; nsresult PrepareHTMLTransferable(nsITransferable** aTransferable, const Element* aEditingHost) const; enum class HavePrivateHTMLFlavor { No, Yes }; MOZ_CAN_RUN_SCRIPT nsresult InsertFromTransferableAtSelection( nsITransferable* aTransferable, const nsAString& aContextStr, const nsAString& aInfoStr, HavePrivateHTMLFlavor aHavePrivateHTMLFlavor, const Element& aEditingHost); /** * InsertFromDataTransfer() is called only when user drops data into * this editor. Don't use this method for other purposes. * * @param aIndex index of aDataTransfer's item to insert. */ MOZ_CAN_RUN_SCRIPT nsresult InsertFromDataTransfer( const DataTransfer* aDataTransfer, uint32_t aIndex, nsIPrincipal* aSourcePrincipal, const EditorDOMPoint& aDroppedAt, DeleteSelectedContent aDeleteSelectedContent, const Element& aEditingHost); MOZ_CAN_RUN_SCRIPT nsresult InsertURLAsLinkInternal( const nsAString& aURL, const EditorDOMPoint& aPointToInsert, DeleteSelectedContent aDeleteSelectedContent); static HavePrivateHTMLFlavor DataTransferOrClipboardHasPrivateHTMLFlavor( DataTransfer* aDataTransfer, nsIClipboard* clipboard); /** * CF_HTML: * . * * @param[in] aCfhtml a CF_HTML string as defined above. * @param[out] aStuffToPaste the fragment, excluding context. * @param[out] aCfcontext the context, excluding the fragment, including a * marker (`kInsertionCookie`) indicating where the * fragment begins. */ nsresult ParseCFHTML(const nsCString& aCfhtml, char16_t** aStuffToPaste, char16_t** aCfcontext); /** * AutoHTMLFragmentBoundariesFixer fixes both edges of topmost child contents * which are created with SubtreeContentIterator. */ class MOZ_STACK_CLASS AutoHTMLFragmentBoundariesFixer final { public: /** * @param aArrayOfTopMostChildContents * [in/out] The topmost child contents which will be * inserted into the DOM tree. Both edges, i.e., * first node and last node in this array will be * checked whether they can be inserted into * another DOM tree. If not, it'll replaces some * orphan nodes around nodes with proper parent. */ explicit AutoHTMLFragmentBoundariesFixer( nsTArray>& aArrayOfTopMostChildContents); private: /** * EnsureBeginsOrEndsWithValidContent() replaces some nodes starting from * start or end with proper element node if it's necessary. * If first or last node of aArrayOfTopMostChildContents is in list and/or * `
` element, looks for topmost list element or `
` element * with `CollectTableAndAnyListElementsOfInclusiveAncestorsAt()` and * `GetMostDistantAncestorListOrTableElement()`. Then, checks * whether some nodes are in aArrayOfTopMostChildContents are the topmost * list/table element or its descendant and if so, removes the nodes from * aArrayOfTopMostChildContents and inserts the list/table element instead. * Then, aArrayOfTopMostChildContents won't start/end with list-item nor * table cells. */ enum class StartOrEnd { start, end }; void EnsureBeginsOrEndsWithValidContent( StartOrEnd aStartOrEnd, nsTArray>& aArrayOfTopMostChildContents) const; /** * CollectTableAndAnyListElementsOfInclusiveAncestorsAt() collects list * elements and table related elements from the inclusive ancestors * (https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor) of aNode. */ static void CollectTableAndAnyListElementsOfInclusiveAncestorsAt( nsIContent& aContent, nsTArray>& aOutArrayOfListAndTableElements); /** * GetMostDistantAncestorListOrTableElement() returns a list or a * `
` element which is in * aInclusiveAncestorsTableOrListElements and they are actually * valid ancestor of at least one of aArrayOfTopMostChildContents. */ static Element* GetMostDistantAncestorListOrTableElement( const nsTArray>& aArrayOfTopMostChildContents, const nsTArray>& aInclusiveAncestorsTableOrListElements); /** * FindReplaceableTableElement() is a helper method of * EnsureBeginsOrEndsWithValidContent(). If aNodeMaybeInTableElement is * a descendant of aTableElement, returns aNodeMaybeInTableElement or its * nearest ancestor whose tag name is ``, ``, * ``, `` or `
`, ` `, `
`. * * @param aTableElement Must be a `` element. * @param aContentMaybeInTableElement A node which may be in aTableElement. */ Element* FindReplaceableTableElement( Element& aTableElement, nsIContent& aContentMaybeInTableElement) const; /** * IsReplaceableListElement() is a helper method of * EnsureBeginsOrEndsWithValidContent(). If aNodeMaybeInListElement is a * descendant of aListElement, returns true. Otherwise, false. * * @param aListElement Must be a list element. * @param aContentMaybeInListElement A node which may be in aListElement. */ bool IsReplaceableListElement(Element& aListElement, nsIContent& aContentMaybeInListElement) const; }; /** * MakeDefinitionListItemWithTransaction() replaces parent list of current * selection with
or create new
element and creates a definition * list item whose name is aTagName. * * @param aTagName Must be nsGkAtoms::dt or nsGkAtoms::dd. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MakeDefinitionListItemWithTransaction(nsAtom& aTagName); /** * FormatBlockContainerAsSubAction() inserts a block element whose name * is aTagName at selection. If selection is not collapsed and aTagName is * nsGkAtoms::normal or nsGkAtoms::_empty, this removes block containers. * * @param aTagName A block level element name. Must NOT be * nsGkAtoms::dt nor nsGkAtoms::dd. * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. * @param aEditingHost The editing host. */ MOZ_CAN_RUN_SCRIPT nsresult FormatBlockContainerAsSubAction( const nsStaticAtom& aTagName, FormatBlockMode aFormatBlockMode, const Element& aEditingHost); /** * Increase/decrease the font size of selection. */ MOZ_CAN_RUN_SCRIPT nsresult IncrementOrDecrementFontSizeAsSubAction(FontSize aIncrementOrDecrement); /** * Wrap aContent in or element and make children of * wrap with or too. Note that if there is * opposite element for aIncrementOrDecrement, their children will be just * unwrapped. * * @param aDir Whether increase or decrease the font size of aContent. * @param aContent The content node whose font size will be changed. * @return A suggest point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SetFontSizeWithBigOrSmallElement(nsIContent& aContent, FontSize aIncrementOrDecrement); /** * Adjust font size of font element children recursively with handling * and elements. * * @param aDir Whether increase or decrease the font size of aContent. * @param aContent The content node whose font size will be changed. * All descendants will be handled recursively. * @return A suggest point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result SetFontSizeOfFontElementChildren(nsIContent& aContent, FontSize aIncrementOrDecrement); /** * Get extended range to select element whose all children are selected by * aRange. */ EditorRawDOMRange GetExtendedRangeWrappingEntirelySelectedElements( const EditorRawDOMRange& aRange) const; /** * Get extended range to select ancestor elements. */ EditorRawDOMRange GetExtendedRangeWrappingNamedAnchor( const EditorRawDOMRange& aRange) const; // Declared in HTMLEditorNestedClasses.h and defined in HTMLStyleEditor.cpp class AutoInlineStyleSetter; /** * RemoveStyleInside() removes elements which represent aStyleToRemove * and removes CSS style. This handles aElement and all its descendants * (including leaf text nodes) recursively. * TODO: Rename this to explain that this maybe remove aElement from the DOM * tree. * * @param aSpecifiedStyle Whether the class and style attributes should * be preserved or discarded. * @return A suggest point to put caret. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result RemoveStyleInside(Element& aElement, const EditorInlineStyle& aStyleToRemove, SpecifiedStyle aSpecifiedStyle); /** * CollectEditableLeafTextNodes() collects text nodes in aElement. */ void CollectEditableLeafTextNodes( Element& aElement, nsTArray>& aLeafTextNodes) const; /** * IsRemovableParentStyleWithNewSpanElement() checks whether aStyle of parent * block can be removed from aContent with creating `` element. Note * that this does NOT check whether the specified style comes from parent * block or not. * XXX This may destroy the editor, but using `Result` * is not reasonable because code for accessing the result becomes * messy. However, anybody must forget to check `Destroyed()` after * calling this. Which is the way to smart to make every caller * must check the editor state? */ MOZ_CAN_RUN_SCRIPT Result IsRemovableParentStyleWithNewSpanElement( nsIContent& aContent, const EditorInlineStyle& aStyle) const; /** * HasStyleOrIdOrClassAttribute() returns true when at least one of * `style`, `id` or `class` attribute value of aElement is not empty. */ static bool HasStyleOrIdOrClassAttribute(Element& aElement); /** * Whether the outer window of the DOM event target has focus or not. */ bool OurWindowHasFocus() const; class HTMLWithContextInserter; /** * This function is used to insert a string of HTML input optionally with some * context information into the editable field. The HTML input either comes * from a transferable object created as part of a drop/paste operation, or * from the InsertHTML method. We may want the HTML input to be sanitized * (for example, if it's coming from a transferable object), in which case * aTrustedInput should be set to false, otherwise, the caller should set it * to true, which means that the HTML will be inserted in the DOM verbatim. */ enum class InlineStylesAtInsertionPoint { Preserve, // If you want the paste to be affected by local style, e.g., // for the insertHTML command, use "Preserve" Clear, // If you want the paste to be keep its own style, e.g., pasting // from clipboard, use "Clear" }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertHTMLWithContextAsSubAction( const nsAString& aInputString, const nsAString& aContextStr, const nsAString& aInfoStr, const nsAString& aFlavor, SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert, DeleteSelectedContent aDeleteSelectedContent, InlineStylesAtInsertionPoint aInlineStylesAtInsertionPoint, const Element& aEditingHost); /** * sets the position of an element; warning it does NOT check if the * element is already positioned or not and that's on purpose. * @param aStyledElement [IN] the element * @param aX [IN] the x position in pixels. * @param aY [IN] the y position in pixels. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetTopAndLeftWithTransaction( nsStyledElement& aStyledElement, int32_t aX, int32_t aY); /** * Reset a selected cell or collapsed selection (the caret) after table * editing. * * @param aTable A table in the document. * @param aRow The row ... * @param aCol ... and column defining the cell where we will try to * place the caret. * @param aSelected If true, we select the whole cell instead of setting * caret. * @param aDirection If cell at (aCol, aRow) is not found, search for * previous cell in the same column (aPreviousColumn) or * row (ePreviousRow) or don't search for another cell * (aNoSearch). If no cell is found, caret is place just * before table; and if that fails, at beginning of * document. Thus we generally don't worry about the * return value and can use the * AutoSelectionSetterAfterTableEdit stack-based object to * insure we reset the caret in a table-editing method. */ MOZ_CAN_RUN_SCRIPT void SetSelectionAfterTableEdit(Element* aTable, int32_t aRow, int32_t aCol, int32_t aDirection, bool aSelected); void RemoveListenerAndDeleteRef(const nsAString& aEvent, nsIDOMEventListener* aListener, bool aUseCapture, ManualNACPtr aElement, PresShell* aPresShell); void DeleteRefToAnonymousNode(ManualNACPtr aContent, PresShell* aPresShell); /** * RefreshEditingUI() may refresh editing UIs for current Selection, focus, * etc. If this shows or hides some UIs, it causes reflow. So, this is * not safe method. */ MOZ_CAN_RUN_SCRIPT nsresult RefreshEditingUI(); /** * Returns the offset of an element's frame to its absolute containing block. */ nsresult GetElementOrigin(Element& aElement, int32_t& aX, int32_t& aY); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetPositionAndDimensions( Element& aElement, int32_t& aX, int32_t& aY, int32_t& aW, int32_t& aH, int32_t& aBorderLeft, int32_t& aBorderTop, int32_t& aMarginLeft, int32_t& aMarginTop); bool IsInObservedSubtree(nsIContent* aChild); void UpdateRootElement(); /** * SetAllResizersPosition() moves all resizers to proper position. * If the resizers are hidden or replaced with another set of resizers * while this is running, this returns error. So, callers shouldn't * keep handling the resizers if this returns error. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetAllResizersPosition(); /** * Shows active resizers around an element's frame * @param aResizedElement [IN] a DOM Element */ MOZ_CAN_RUN_SCRIPT nsresult ShowResizersInternal(Element& aResizedElement); /** * Hide resizers if they are visible. If this is called while there is no * visible resizers, this does not return error, but does nothing. */ nsresult HideResizersInternal(); /** * RefreshResizersInternal() moves resizers to proper position. This does * nothing if there is no resizing target. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RefreshResizersInternal(); ManualNACPtr CreateResizer(int16_t aLocation, nsIContent& aParentContent); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetAnonymousElementPositionWithoutTransaction(nsStyledElement& aStyledElement, int32_t aX, int32_t aY); ManualNACPtr CreateShadow(nsIContent& aParentContent, Element& aOriginalObject); /** * SetShadowPosition() moves the shadow element to proper position. * * @param aShadowElement Must be mResizingShadow or mPositioningShadow. * @param aElement The element which has the shadow. * @param aElementX Left of aElement. * @param aElementY Top of aElement. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetShadowPosition(Element& aShadowElement, Element& aElement, int32_t aElementLeft, int32_t aElementTop); ManualNACPtr CreateResizingInfo(nsIContent& aParentContent); MOZ_CAN_RUN_SCRIPT nsresult SetResizingInfoPosition(int32_t aX, int32_t aY, int32_t aW, int32_t aH); enum class ResizeAt { eX, eY, eWidth, eHeight, }; [[nodiscard]] int32_t GetNewResizingIncrement(int32_t aX, int32_t aY, ResizeAt aResizeAt) const; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult StartResizing(Element& aHandle); int32_t GetNewResizingX(int32_t aX, int32_t aY); int32_t GetNewResizingY(int32_t aX, int32_t aY); int32_t GetNewResizingWidth(int32_t aX, int32_t aY); int32_t GetNewResizingHeight(int32_t aX, int32_t aY); void HideShadowAndInfo(); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetFinalSizeWithTransaction(int32_t aX, int32_t aY); void SetResizeIncrements(int32_t aX, int32_t aY, int32_t aW, int32_t aH, bool aPreserveRatio); /** * HideAnonymousEditingUIs() forcibly hides all editing UIs (resizers, * inline-table-editing UI, absolute positioning UI). * * XXX This method is called by the CC, therefore, needs to be a boundary * method. */ MOZ_CAN_RUN_SCRIPT_BOUNDARY void HideAnonymousEditingUIs(); /** * HideAnonymousEditingUIsIfUnnecessary() hides all editing UIs if some of * visible UIs are now unnecessary. */ MOZ_CAN_RUN_SCRIPT void HideAnonymousEditingUIsIfUnnecessary(); /** * sets the z-index of an element. * @param aElement [IN] the element * @param aZorder [IN] the z-index */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetZIndexWithTransaction(nsStyledElement& aElement, int32_t aZIndex); /** * shows a grabber attached to an arbitrary element. The grabber is an image * positioned on the left hand side of the top border of the element. Draggin * and dropping it allows to change the element's absolute position in the * document. See chrome://editor/content/images/grabber.gif * @param aElement [IN] the element */ MOZ_CAN_RUN_SCRIPT nsresult ShowGrabberInternal(Element& aElement); /** * Setting grabber to proper position for current mAbsolutelyPositionedObject. * For example, while an element has grabber, the element may be resized * or repositioned by script or something. Then, you need to reset grabber * position with this. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RefreshGrabberInternal(); /** * hide the grabber if it shown. */ MOZ_CAN_RUN_SCRIPT void HideGrabberInternal(); /** * CreateGrabberInternal() creates a grabber for moving aParentContent. * This sets mGrabber to the new grabber. If this returns true, it's * always non-nullptr. Otherwise, i.e., the grabber is hidden during * creation, this returns false. */ bool CreateGrabberInternal(nsIContent& aParentContent); MOZ_CAN_RUN_SCRIPT nsresult StartMoving(); MOZ_CAN_RUN_SCRIPT nsresult SetFinalPosition(int32_t aX, int32_t aY); void SnapToGrid(int32_t& newX, int32_t& newY) const; nsresult GrabberClicked(); MOZ_CAN_RUN_SCRIPT nsresult EndMoving(); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetTemporaryStyleForFocusedPositionedElement(Element& aElement, nsAString& aReturn); /** * Shows inline table editing UI around a
element which contains * aCellElement. This returns error if creating UI is hidden during this, * or detects another set of UI during this. In such case, callers * shouldn't keep handling anything for the UI. * * @param aCellElement Must be an
or element. */ MOZ_CAN_RUN_SCRIPT nsresult ShowInlineTableEditingUIInternal(Element& aCellElement); /** * Hide all inline table editing UI. */ void HideInlineTableEditingUIInternal(); /** * RefreshInlineTableEditingUIInternal() moves inline table editing UI to * proper position. This returns error if the UI is hidden or replaced * during moving. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RefreshInlineTableEditingUIInternal(); enum class ContentNodeIs { Inserted, Appended }; MOZ_CAN_RUN_SCRIPT void DoContentInserted(nsIContent* aChild, ContentNodeIs aContentNodeIs); /** * Returns an anonymous Element of type aTag, * child of aParentContent. If aIsCreatedHidden is true, the class * "hidden" is added to the created element. If aClass is not the empty * string, it becomes the value of the class attribute * @return a Element * @param aTag [IN] desired type of the element to create * @param aParentContent [IN] the parent node of the created anonymous * element * @param aClass [IN] contents of the _moz_anonclass attribute * @param aIsCreatedHidden [IN] a boolean specifying if the class "hidden" * is to be added to the created anonymous * element */ ManualNACPtr CreateAnonymousElement(nsAtom* aTag, nsIContent& aParentContent, const nsAString& aClass, bool aIsCreatedHidden); /** * Reads a blob into memory and notifies the BlobReader object when the read * operation is finished. * * @param aBlob The input blob * @param aGlobal The global object under which the read should happen. * @param aBlobReader The blob reader object to be notified when finished. */ static nsresult SlurpBlob(dom::Blob* aBlob, nsIGlobalObject* aGlobal, BlobReader* aBlobReader); /** * For saving allocation cost in the constructor of * EditorBase::TopLevelEditSubActionData, we should reuse same RangeItem * instance with all top level edit sub actions. * The instance is always cleared when TopLevelEditSubActionData is * destructed and the class is stack only class so that we don't need * to (and also should not) add the RangeItem into the cycle collection. */ [[nodiscard]] inline already_AddRefed GetSelectedRangeItemForTopLevelEditSubAction() const; /** * For saving allocation cost in the constructor of * EditorBase::TopLevelEditSubActionData, we should reuse same nsRange * instance with all top level edit sub actions. * The instance is always cleared when TopLevelEditSubActionData is * destructed, but AbstractRange::mOwner keeps grabbing the owner document * so that we need to make it in the cycle collection. */ [[nodiscard]] inline already_AddRefed GetChangedRangeForTopLevelEditSubAction() const; MOZ_CAN_RUN_SCRIPT void DidDoTransaction( TransactionManager& aTransactionManager, nsITransaction& aTransaction, nsresult aDoTransactionResult) { if (mComposerCommandsUpdater) { RefPtr updater(mComposerCommandsUpdater); updater->DidDoTransaction(aTransactionManager); } } MOZ_CAN_RUN_SCRIPT void DidUndoTransaction( TransactionManager& aTransactionManager, nsITransaction& aTransaction, nsresult aUndoTransactionResult) { if (mComposerCommandsUpdater) { RefPtr updater(mComposerCommandsUpdater); updater->DidUndoTransaction(aTransactionManager); } } MOZ_CAN_RUN_SCRIPT void DidRedoTransaction( TransactionManager& aTransactionManager, nsITransaction& aTransaction, nsresult aRedoTransactionResult) { if (mComposerCommandsUpdater) { RefPtr updater(mComposerCommandsUpdater); updater->DidRedoTransaction(aTransactionManager); } } protected: /** * IndentListChildWithTransaction() is a helper method of * Handle(CSS|HTML)IndentAtSelectionInternal(). * * @param aSubListElement [in/out] Specify a sub-list element of the * container of aPointInListElement or nullptr. * When there is no proper sub-list element to * move aContentMovingToSubList, this method * inserts a new sub-list element and update this * to it. * @param aPointInListElement A point in a list element whose child should * be indented. If this method creates new list * element into the list element, this inserts * the new list element to this point. * @param aContentMovingToSubList * A content node which is a child of a list * element and should be moved into a sub-list * element. * @param aEditingHost The editing host. * @return A candidate caret position. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result IndentListChildWithTransaction(RefPtr* aSubListElement, const EditorDOMPoint& aPointInListElement, nsIContent& aContentMovingToSubList, const Element& aEditingHost); /** * Stack based helper class for calling EditorBase::EndTransactionInternal(). * NOTE: This does not suppress multiple input events. In most cases, * only one "input" event should be fired for an edit action rather * than per edit sub-action. In such case, you should use * EditorBase::AutoPlaceholderBatch instead. */ class MOZ_RAII AutoTransactionBatch final { public: /** * @param aRequesterFuncName function name which wants to end the batch. * This won't be stored nor exposed to selection listeners etc, used only * for logging. This MUST be alive when the destructor runs. */ MOZ_CAN_RUN_SCRIPT explicit AutoTransactionBatch( HTMLEditor& aHTMLEditor, const char* aRequesterFuncName) : mHTMLEditor(aHTMLEditor), mRequesterFuncName(aRequesterFuncName) { MOZ_KnownLive(mHTMLEditor).BeginTransactionInternal(mRequesterFuncName); } MOZ_CAN_RUN_SCRIPT ~AutoTransactionBatch() { MOZ_KnownLive(mHTMLEditor).EndTransactionInternal(mRequesterFuncName); } protected: // The lifetime must be guaranteed by the creator of this instance. MOZ_KNOWN_LIVE HTMLEditor& mHTMLEditor; const char* const mRequesterFuncName; }; RefPtr mPendingStylesToApplyToNewContent; RefPtr mComposerCommandsUpdater; // Used by TopLevelEditSubActionData::mSelectedRange. mutable RefPtr mSelectedRangeForTopLevelEditSubAction; // Used by TopLevelEditSubActionData::mChangedRange. mutable RefPtr mChangedRangeForTopLevelEditSubAction; RefPtr mPendingRootElementUpdatedRunner; RefPtr mPendingDocumentModifiedRunner; // mPaddingBRElementForEmptyEditor should be used for placing caret // at proper position when editor is empty. RefPtr mPaddingBRElementForEmptyEditor; // This is set only when HandleInsertText appended a collapsible white-space. RefPtr mLastCollapsibleWhiteSpaceAppendedTextNode; // While this instance or its helper class updates the DOM with a DOM API, // this is set to the wrapper class to call the DOM API. const AutoDOMAPIWrapperBase* mRunningDOMAPIWrapper = nullptr; bool mCRInParagraphCreatesParagraph; // resizing bool mIsObjectResizingEnabled; bool mIsResizing; bool mPreserveRatio; bool mResizedObjectIsAnImage; // absolute positioning bool mIsAbsolutelyPositioningEnabled; bool mResizedObjectIsAbsolutelyPositioned; bool mGrabberClicked; bool mIsMoving; bool mSnapToGridEnabled; // inline table editing bool mIsInlineTableEditingEnabled; bool mIsCSSPrefChecked; // resizing ManualNACPtr mTopLeftHandle; ManualNACPtr mTopHandle; ManualNACPtr mTopRightHandle; ManualNACPtr mLeftHandle; ManualNACPtr mRightHandle; ManualNACPtr mBottomLeftHandle; ManualNACPtr mBottomHandle; ManualNACPtr mBottomRightHandle; RefPtr mActivatedHandle; ManualNACPtr mResizingShadow; ManualNACPtr mResizingInfo; RefPtr mResizedObject; int32_t mOriginalX; int32_t mOriginalY; int32_t mResizedObjectX; int32_t mResizedObjectY; int32_t mResizedObjectWidth; int32_t mResizedObjectHeight; int32_t mResizedObjectMarginLeft; int32_t mResizedObjectMarginTop; int32_t mResizedObjectBorderLeft; int32_t mResizedObjectBorderTop; int32_t mXIncrementFactor; int32_t mYIncrementFactor; int32_t mWidthIncrementFactor; int32_t mHeightIncrementFactor; int8_t mInfoXIncrement; int8_t mInfoYIncrement; // absolute positioning int32_t mPositionedObjectX; int32_t mPositionedObjectY; int32_t mPositionedObjectWidth; int32_t mPositionedObjectHeight; int32_t mPositionedObjectMarginLeft; int32_t mPositionedObjectMarginTop; int32_t mPositionedObjectBorderLeft; int32_t mPositionedObjectBorderTop; RefPtr mAbsolutelyPositionedObject; ManualNACPtr mGrabber; ManualNACPtr mPositioningShadow; int32_t mGridSize; // inline table editing RefPtr mInlineEditedCell; ManualNACPtr mAddColumnBeforeButton; ManualNACPtr mRemoveColumnButton; ManualNACPtr mAddColumnAfterButton; ManualNACPtr mAddRowBeforeButton; ManualNACPtr mRemoveRowButton; ManualNACPtr mAddRowAfterButton; void AddPointerClickListener(Element* aElement); void RemovePointerClickListener(Element* aElement); bool mDisabledLinkHandling = false; bool mOldLinkHandlingEnabled = false; bool mHasBeforeInputBeenCanceled = false; bool mHasFocus = false; bool mIsInDesignMode = false; ParagraphSeparator mDefaultParagraphSeparator; friend class AlignStateAtSelection; // CollectEditableTargetNodes, // CollectNonEditableNodes friend class AutoClonedRangeArray; // RangeUpdaterRef, // SplitNodeWithTransaction, // SplitInlineAncestorsAtRangeBoundaries friend class AutoDOMAPIWrapperBase; // OnDOMAPICallEnd, // OnDOMAPICallStart, friend class AutoClonedSelectionRangeArray; // RangeUpdaterRef, friend class AutoSelectionRestore; friend class AutoSelectionSetterAfterTableEdit; // SetSelectionAfterEdit friend class CSSEditUtils; // DoTransactionInternal, HasAttributes, // RemoveContainerWithTransaction friend class EditorBase; // ComputeTargetRanges, // GetChangedRangeForTopLevelEditSubAction, // GetSelectedRangeItemForTopLevelEditSubAction, // MaybeCreatePaddingBRElementForEmptyEditor, // PrepareToInsertBRElement, // ReflectPaddingBRElementForEmptyEditor, // RefreshEditingUI, // mComposerUpdater, mHasBeforeInputBeenCanceled friend class JoinNodesTransaction; // DidJoinNodesTransaction, DoJoinNodes, // DoSplitNode, // RangeUpdaterRef friend class ListElementSelectionState; // CollectEditTargetNodes, // CollectNonEditableNodes friend class ListItemElementSelectionState; // CollectEditTargetNodes, // CollectNonEditableNodes friend class MoveNodeTransaction; // AllowsTransactionsToChangeSelection, // CollapseSelectionTo, RangeUpdaterRef friend class MoveSiblingsTransaction; // AllowsTransactionsToChangeSelection, // CollapseSelectionTo, RangeUpdaterRef friend class ParagraphStateAtSelection; // CollectChildren, // CollectEditTargetNodes, // CollectListChildren, // CollectNonEditableNodes, // CollectTableChildren friend class SlurpBlobEventListener; // BlobReader friend class SplitNodeTransaction; // DoJoinNodes, DoSplitNode friend class TransactionManager; // DidDoTransaction, DidRedoTransaction, // DidUndoTransaction friend class WhiteSpaceVisibilityKeeper; // AutoMoveOneLineHandler // CanMoveChildren, // ChangeListElementType, // DeleteNodeWithTransaction, // DeleteTextAndTextNodesWithTransaction, // InsertLineBreak, // JoinNearestEditableNodesWithTransaction, // LineBreakType, // MoveChildrenWithTransaction, // SplitAncestorStyledInlineElementsAt, // TreatEmptyTextNodes }; /** * ListElementSelectionState class gets which list element is selected right * now. */ class MOZ_STACK_CLASS ListElementSelectionState final { public: ListElementSelectionState() = delete; ListElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv); bool IsOLElementSelected() const { return mIsOLElementSelected; } bool IsULElementSelected() const { return mIsULElementSelected; } bool IsDLElementSelected() const { return mIsDLElementSelected; } bool IsNotOneTypeListElementSelected() const { return (mIsOLElementSelected + mIsULElementSelected + mIsDLElementSelected + mIsOtherContentSelected) > 1; } private: bool mIsOLElementSelected = false; bool mIsULElementSelected = false; bool mIsDLElementSelected = false; bool mIsOtherContentSelected = false; }; /** * ListItemElementSelectionState class gets which list item element is selected * right now. */ class MOZ_STACK_CLASS ListItemElementSelectionState final { public: ListItemElementSelectionState() = delete; ListItemElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv); bool IsLIElementSelected() const { return mIsLIElementSelected; } bool IsDTElementSelected() const { return mIsDTElementSelected; } bool IsDDElementSelected() const { return mIsDDElementSelected; } bool IsNotOneTypeDefinitionListItemElementSelected() const { return (mIsDTElementSelected + mIsDDElementSelected + mIsOtherElementSelected) > 1; } private: bool mIsLIElementSelected = false; bool mIsDTElementSelected = false; bool mIsDDElementSelected = false; bool mIsOtherElementSelected = false; }; /** * AlignStateAtSelection class gets alignment at selection. * XXX This currently returns only first alignment. */ class MOZ_STACK_CLASS AlignStateAtSelection final { public: AlignStateAtSelection() = delete; MOZ_CAN_RUN_SCRIPT AlignStateAtSelection(HTMLEditor& aHTMLEditor, ErrorResult& aRv); nsIHTMLEditor::EAlignment AlignmentAtSelectionStart() const { return mFirstAlign; } bool IsSelectionRangesFound() const { return mFoundSelectionRanges; } private: nsIHTMLEditor::EAlignment mFirstAlign = nsIHTMLEditor::eLeft; bool mFoundSelectionRanges = false; }; /** * ParagraphStateAtSelection class gets format block types around selection. */ class MOZ_STACK_CLASS ParagraphStateAtSelection final { public: using FormatBlockMode = HTMLEditor::FormatBlockMode; ParagraphStateAtSelection() = delete; /** * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. */ ParagraphStateAtSelection(HTMLEditor& aHTMLEditor, FormatBlockMode aFormatBlockMode, ErrorResult& aRv); /** * GetFirstParagraphStateAtSelection() returns: * - nullptr if there is no format blocks nor inline nodes. * - nsGkAtoms::_empty if first node is not in any format block. * - a tag name of format block at first node. * XXX See the private method explanations. If selection ranges contains * non-format block first, it'll be check after its siblings. Therefore, * this may return non-first paragraph state. */ nsAtom* GetFirstParagraphStateAtSelection() const { return mIsMixed && mIsInDLElement ? nsGkAtoms::dl : mFirstParagraphState.get(); } /** * If selected nodes are not in same format node nor only in no-format blocks, * this returns true. */ bool IsMixed() const { return mIsMixed && !mIsInDLElement; } private: using EditorType = EditorBase::EditorType; [[nodiscard]] static bool IsFormatElement(FormatBlockMode aFormatBlockMode, const nsIContent& aContent); /** * AppendDescendantFormatNodesAndFirstInlineNode() appends descendant * format blocks and first inline child node in aNonFormatBlockElement to * the last of the array (not inserting where aNonFormatBlockElement is, * so that the node order becomes randomly). * * @param aArrayOfContents [in/out] Found descendant format blocks * and first inline node in each non-format * block will be appended to this. * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. * @param aNonFormatBlockElement Must be a non-format block element. */ static void AppendDescendantFormatNodesAndFirstInlineNode( nsTArray>& aArrayOfContents, FormatBlockMode aFormatBlockMode, dom::Element& aNonFormatBlockElement); /** * CollectEditableFormatNodesInSelection() collects only editable nodes * around selection ranges (with * AutoClonedRangeArray::ExtendRangesToWrapLines() and * HTMLEditor::CollectEditTargetNodes(), see its document for the detail). * If it includes list, list item or table related elements, they will be * replaced their children. * * @param aFormatBlockMode Whether HTML formatBlock command or XUL * paragraphState command. */ static nsresult CollectEditableFormatNodesInSelection( HTMLEditor& aHTMLEditor, FormatBlockMode aFormatBlockMode, const dom::Element& aEditingHost, nsTArray>& aArrayOfContents); RefPtr mFirstParagraphState; bool mIsInDLElement = false; bool mIsMixed = false; }; } // namespace mozilla mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() { MOZ_DIAGNOSTIC_ASSERT(IsHTMLEditor()); return static_cast(this); } const mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() const { MOZ_DIAGNOSTIC_ASSERT(IsHTMLEditor()); return static_cast(this); } mozilla::HTMLEditor* nsIEditor::GetAsHTMLEditor() { return AsEditorBase()->IsHTMLEditor() ? AsHTMLEditor() : nullptr; } const mozilla::HTMLEditor* nsIEditor::GetAsHTMLEditor() const { return AsEditorBase()->IsHTMLEditor() ? AsHTMLEditor() : nullptr; } #endif // #ifndef mozilla_HTMLEditor_h