`, * `

` or one of list elements. This method climbs down from * aContent while there is only one editable children and the editable child * is `
`, `
` or a list element. When it reaches different * kind of node, returns the last found element. */ Element* GetDeepestEditableOnlyChildDivBlockquoteOrListElement( nsINode& aNode); /** * Try to get parent list element at `Selection`. This returns first find * parent list element of common ancestor of ranges (looking for it from * first range to last range). */ Element* GetParentListElementAtSelection() const; /** * MaybeExtendSelectionToHardLineEdgesForBlockEditAction() adjust Selection if * there is only one range. If range start and/or end point is
node 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]] MOZ_CAN_RUN_SCRIPT nsresult MaybeExtendSelectionToHardLineEdgesForBlockEditAction(); /** * IsEmptyInlineNode() returns true if aContent is an inline node and it does * not have meaningful content. */ bool IsEmptyInlineNode(nsIContent& aContent) const; /** * IsEmptyOneHardLine() returns true if aArrayOfContents does not represent * 2 or more lines and have meaningful content. */ bool IsEmptyOneHardLine( nsTArray>& aArrayOfContents) const { if (NS_WARN_IF(aArrayOfContents.IsEmpty())) { return true; } bool brElementHasFound = false; for (OwningNonNull& content : aArrayOfContents) { if (!EditorUtils::IsEditableContent(content, EditorType::HTML)) { continue; } if (content->IsHTMLElement(nsGkAtoms::br)) { // If there are 2 or more `
` elements, it's not empty line since // there may be only one `
` element in a hard line. if (brElementHasFound) { return false; } brElementHasFound = true; continue; } if (!IsEmptyInlineNode(content)) { return false; } } return true; } /** * 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 descendant of * active editing host. * @return When succeeded, SplitPoint() returns * the point to insert the element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT SplitNodeResult MaybeSplitAncestorsForInsertWithTransaction( nsAtom& aTag, const EditorDOMPoint& aStartOfDeepestRightNode); /** * SplitRangeOffFromBlock() splits aBlockElement at two points, before * aStartOfMiddleElement and after aEndOfMiddleElement. If they are very * start or very end of aBlcok, this won't create empty block. * * @param aBlockElement A block 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 SplitRangeOffFromNodeResult SplitRangeOffFromBlock(Element& aBlockElement, nsIContent& aStartOfMiddleElement, nsIContent& aEndOfMiddleElement); /** * SplitRangeOffFromBlockAndRemoveMiddleContainer() splits the nodes * between aStartOfRange and aEndOfRange, then, removes the middle element * and moves its content to where the middle element was. * * @param aBlockElement The node which will be split. * @param aStartOfRange The first node which will be unwrapped * from aBlockElement. * @param aEndOfRange The last node which will be unwrapped from * aBlockElement. * @return The left content is new created left * element of aBlockElement. * The right content is split element, * i.e., must be aBlockElement. * The middle content is nullptr since * removing it is the job of this method. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT SplitRangeOffFromNodeResult SplitRangeOffFromBlockAndRemoveMiddleContainer(Element& aBlockElement, nsIContent& aStartOfRange, nsIContent& aEndOfRange); /** * MoveNodesIntoNewBlockquoteElement() 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveNodesIntoNewBlockquoteElement( nsTArray>& aArrayOfContents); /** * RemoveBlockContainerElements() 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveBlockContainerElements( nsTArray>& aArrayOfContents); /** * CreateOrChangeBlockContainerElement() formats all nodes in aArrayOfContents * with block elements whose name is aBlockTag. * 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 aBlockTag The element name of new block elements. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CreateOrChangeBlockContainerElement( nsTArray>& aArrayOfContents, nsAtom& aBlockTag); /** * FormatBlockContainerWithTransaction() is implementation of "formatBlock" * command of `Document.execCommand()`. This applies block style or removes * it. * NOTE: This creates AutoSelectionRestorer. Therefore, even when this * return NS_OK, editor may have been destroyed. * * @param aBlockType New block tag name. * If nsGkAtoms::normal or nsGkAtoms::_empty, * RemoveBlockContainerElements() will be called. * If nsGkAtoms::blockquote, * MoveNodesIntoNewBlockquoteElement() will be * called. Otherwise, * CreateOrChangeBlockContainerElement() will be * called. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult FormatBlockContainerWithTransaction(nsAtom& aBlockType); /** * InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary() determines if * aPointToInsert is start of a hard line and end of the line (i.e, the * line is empty) and the line ends with block boundary, inserts a `
` * element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( const EditorDOMPoint& aPointToInsert); /** * Insert a `
` element if aElement is a block element and empty. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertBRElementIfEmptyBlockElement(Element& aElement); /** * Insert padding `
` element for empty last line into aElement if * aElement is a block element and empty. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertPaddingBRElementForEmptyLastLineIfNeeded(Element& aElement); /** * This method inserts a padding `
` element for empty last line if * selection is collapsed and container of the range needs it. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); /** * IsEmptyBlockElement() returns true if aElement is a block level element * and it doesn't have any visible content. */ enum class IgnoreSingleBR { Yes, No }; bool IsEmptyBlockElement(Element& aElement, IgnoreSingleBR aIgnoreSingleBR) const; /** * SplitParagraph() splits the parent block, aParentDivOrP, at * aStartOfRightNode. * * @param aParentDivOrP The parent block to be split. This must be
* or
element. * @param aStartOfRightNode The point to be start of right node after * split. This must be descendant of * aParentDivOrP. * @param aNextBRNode Next
node if there is. Otherwise, nullptr. * If this is not nullptr, the
node may be * removed. */ template [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitParagraph( Element& aParentDivOrP, const EditorDOMPointBase& aStartOfRightNode, nsIContent* aBRNode); /** * HandleInsertParagraphInParagraph() does the right thing for Enter key * press or 'insertParagraph' command in aParentDivOrP. aParentDivOrP will * be split at start of first selection range. * * @param aParentDivOrP The parent block. This must be
or
* element. * @return Returns with NS_OK if this doesn't meat any * unexpected situation. If this method tries to * split the paragraph, marked as handled. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleInsertParagraphInParagraph(Element& aParentDivOrP); /** * HandleInsertParagraphInHeadingElement() handles insertParagraph command * (i.e., handling Enter key press) in a heading element. This splits * aHeader element at aOffset in aNode. Then, if right heading element is * empty, it'll be removed and new paragraph is created (its type is decided * with default paragraph separator). * * @param aHeader The heading element to be split. * @param aNode Typically, Selection start container, * where to be split. * @param aOffset Typically, Selection start offset in the * start container, where to be split. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleInsertParagraphInHeadingElement(Element& aHeader, nsINode& aNode, int32_t aOffset); /** * HandleInsertParagraphInListItemElement() handles insertParagraph command * (i.e., handling Enter key press) in a list item element. * * @param aListItem The list item which has the following point. * @param aNode Typically, Selection start container, where to * insert a break. * @param aOffset Typically, Selection start offset in the * start container, where to insert a break. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleInsertParagraphInListItemElement(Element& aListItem, nsINode& aNode, int32_t aOffset); /** * GetNearestAncestorListItemElement() returns a list item element if * aContent or its ancestor in editing host is one. However, this won't * cross table related element. */ Element* GetNearestAncestorListItemElement(nsIContent& aContent) const; /** * InsertParagraphSeparatorAsSubAction() handles insertPargraph commad * (i.e., handling Enter key press) with the above helper methods. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult InsertParagraphSeparatorAsSubAction(); /** * Returns true if aNode1 or aNode2 or both is the descendant of some type of * table element, but their nearest table element ancestors differ. "Table * element" here includes not just
but also , , etc. * The nodes count as being their own descendants for this purpose, so a * table element is its own nearest table element ancestor. */ static bool NodesInDifferentTableElements(nsINode& aNode1, nsINode& aNode2); /** * 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 CreateElementResult ChangeListElementType( Element& aListElement, nsAtom& aListType, nsAtom& aItemType); /** * ChangeSelectedHardLinesToList() converts selected ranges to specified * list element. If there is different type of list elements, this method * converts them to specified list items too. Basically, each hard line * will be wrapped with a list item element. However, only when `
` * element is selected, its child `
` elements won't be treated as * hard line separators. Perhaps, this is a bug. * NOTE: This method creates AutoSelectionRestorer. Therefore, each caller * need to check if the editor is still available even if this returns * NS_OK. * * @param aListElementTagName The new list element tag name. * @param aListItemElementTagName The new list item element tag name. * @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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult ChangeSelectedHardLinesToList(nsAtom& aListElementTagName, nsAtom& aListItemElementTagName, const nsAString& aBulletType, SelectAllOfCurrentList aSelectAllOfCurrentList); /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult MakeOrChangeListAndListItemAsSubAction( nsAtom& aListElementOrListItemElementTagName, const nsAString& aBulletType, SelectAllOfCurrentList aSelectAllOfCurrentList); /** * 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 nsresult DeleteTextAndTextNodesWithTransaction( const EditorDOMPointType& aStartPoint, const EditorDOMPointType& aEndPoint, TreatEmptyTextNodes aTreatEmptyTextNodes); /** * JoinNodesWithTransaction() joins aLeftNode and aRightNode. Content of * aLeftNode will be merged into aRightNode. Actual implemenation of this * method is JoinNodesImpl(). So, see its explanation for the detail. * * @param aLeftNode Will be removed from the DOM tree. * @param aRightNode The node which will be new container of the content of * aLeftNode. */ MOZ_CAN_RUN_SCRIPT nsresult JoinNodesWithTransaction(nsINode& aLeftNode, nsINode& aRightNode); /** * 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. */ MOZ_CAN_RUN_SCRIPT already_AddRefed ReplaceContainerAndCloneAttributesWithTransaction(Element& aOldContainer, nsAtom& aTagName) { return ReplaceContainerWithTransactionInternal( aOldContainer, aTagName, *nsGkAtoms::_empty, u""_ns, true); } /** * 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. */ MOZ_CAN_RUN_SCRIPT already_AddRefed ReplaceContainerWithTransaction( Element& aOldContainer, nsAtom& aTagName, nsAtom& aAttribute, const nsAString& aAttributeValue) { return ReplaceContainerWithTransactionInternal( aOldContainer, aTagName, aAttribute, aAttributeValue, false); } /** * 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. */ MOZ_CAN_RUN_SCRIPT already_AddRefed ReplaceContainerWithTransaction( Element& aOldContainer, nsAtom& aTagName) { return ReplaceContainerWithTransactionInternal( aOldContainer, aTagName, *nsGkAtoms::_empty, u""_ns, false); } /** * RemoveContainerWithTransaction() removes aElement from the DOM tree and * moves all its children to the parent of aElement. * * @param aElement The element to be removed. */ MOZ_CAN_RUN_SCRIPT nsresult RemoveContainerWithTransaction(Element& aElement); /** * InsertContainerWithTransaction() creates new element whose name is * aTagName, moves aContent into the new element, then, inserts the new * element into where aContent was. * Note that this method does not check if aContent is valid child of * the new element. So, callers need to guarantee it. * * @param aContent The content which will be wrapped with new * element. * @param aTagName Element name of new element which will wrap * aContent and be inserted into where aContent * was. * @return The new element. */ MOZ_CAN_RUN_SCRIPT already_AddRefed InsertContainerWithTransaction( nsIContent& aContent, nsAtom& aTagName) { return InsertContainerWithTransactionInternal(aContent, aTagName, *nsGkAtoms::_empty, u""_ns); } /** * InsertContainerWithTransaction() creates new element whose name is * aTagName, sets its aAttribute to aAttributeValue, moves aContent into the * new element, then, inserts the new element into where aContent was. * Note that this method does not check if aContent is valid child of * the new element. So, callers need to guarantee it. * * @param aContent The content which will be wrapped with new * element. * @param aTagName Element name of new element which will wrap * aContent and be inserted into where aContent * was. * @param aAttribute Attribute which should be set to the new * element. * @param aAttributeValue Value to be set to aAttribute. * @return The new element. */ MOZ_CAN_RUN_SCRIPT already_AddRefed InsertContainerWithTransaction( nsIContent& aContent, nsAtom& aTagName, nsAtom& aAttribute, const nsAString& aAttributeValue) { return InsertContainerWithTransactionInternal(aContent, aTagName, aAttribute, aAttributeValue); } /** * MoveNodeWithTransaction() moves aContent to aPointToInsert. * * @param aContent The node to be moved. */ MOZ_CAN_RUN_SCRIPT nsresult MoveNodeWithTransaction( nsIContent& aContent, const EditorDOMPoint& aPointToInsert); /** * MoveNodeToEndWithTransaction() moves aContent to end of aNewContainer. * * @param aContent The node to be moved. * @param aNewContainer The new container which will contain aContent as * its last child. */ MOZ_CAN_RUN_SCRIPT nsresult MoveNodeToEndWithTransaction(nsIContent& aContent, nsINode& aNewContainer) { EditorDOMPoint pointToInsert; pointToInsert.SetToEndOf(&aNewContainer); return MoveNodeWithTransaction(aContent, pointToInsert); } /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT MoveNodeResult MoveNodeOrChildrenWithTransaction(nsIContent& aNode, const EditorDOMPoint& aPointToInsert); /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT MoveNodeResult MoveChildrenWithTransaction( Element& aElement, const EditorDOMPoint& aPointToInsert); /** * 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. * @param aError The result. If this succeeds to move children, * returns NS_OK. Otherwise, an error. */ void MoveAllChildren(nsINode& aContainer, const EditorRawDOMPoint& aPointToInsert, ErrorResult& aError); /** * 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. * @param aError The result. If this succeeds to move children, * returns NS_OK. Otherwise, an error. */ void MoveChildrenBetween(nsIContent& aFirstChild, nsIContent& aLastChild, const EditorRawDOMPoint& aPointToInsert, ErrorResult& aError); /** * 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. * @param aError The result. If this succeeds to move children, * returns NS_OK. Otherwise, an error. */ void MovePreviousSiblings(nsIContent& aChild, const EditorRawDOMPoint& aPointToInsert, ErrorResult& aError); /** * MoveOneHardLineContents() moves the content in a hard line which contains * aPointInHardLine to aPointToInsert or end of aPointToInsert's container. * * @param aPointInHardLine A point in a hard line. All nodes in * same hard line will be moved. * @param aPointToInsert Point to insert contents of the hard * line. * @param aMoveToEndOfContainer If `Yes`, aPointToInsert.Offset() will * be ignored and instead, all contents * will be appended to the container of * aPointToInsert. The result may be * different from setting this to `No` * and aPointToInsert points end of the * container because mutation event * listeners may modify children of the * container while we're moving nodes. */ enum class MoveToEndOfContainer { Yes, No }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT MoveNodeResult MoveOneHardLineContents( const EditorDOMPoint& aPointInHardLine, const EditorDOMPoint& aPointToInsert, MoveToEndOfContainer aMoveToEndOfContainer = MoveToEndOfContainer::No); /** * CanMoveOrDeleteSomethingInHardLine() returns true if there are some content * nodes which can be moved to another place or deleted. Note that if there * is only a padding `
` element in empty block element, this returns * false even though it may be deleted. * * @param aPointInHardLine A point in a hard line. */ template Result CanMoveOrDeleteSomethingInHardLine( const EditorDOMPointBase& aPointInHardLine) const; /** * 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. * @param aError If succeed, returns no error. Otherwise, an * error. */ MOZ_CAN_RUN_SCRIPT already_AddRefed SplitNodeWithTransaction( const EditorDOMPoint& aStartOfRightNode, ErrorResult& aResult); enum class SplitAtEdges { // SplitNodeDeepWithTransaction() won't split container element // nodes at their edges. I.e., when split point is start or end of // container, it won't be split. eDoNotCreateEmptyContainer, // SplitNodeDeepWithTransaction() always splits containers even // if the split point is at edge of a container. E.g., if split point is // start of an inline element, empty inline element is created as a new left // node. eAllowToCreateEmptyContainer, }; /** * 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. */ MOZ_CAN_RUN_SCRIPT SplitNodeResult SplitNodeDeepWithTransaction(nsIContent& aMostAncestorToSplit, const EditorDOMPoint& aDeepestStartOfRightNode, SplitAtEdges aSplitAtEdges); /** * GetGoodCaretPointFor() returns a good point to collapse `Selection` * after handling edit action with aDirectionAndAmount. * * @param aContent The content where you want to put caret * around. * @param aDirectionAndAmount Muse be one of eNext, eNextWord, eToEndOfLine, * ePrevious, ePreviousWord and eToBeggingOfLine. * Set the direction of handled edit action. */ EditorDOMPoint GetGoodCaretPointFor( nsIContent& aContent, nsIEditor::EDirection aDirectionAndAmount) const; /** * RemoveEmptyInclusiveAncestorInlineElements() removes empty inclusive * ancestor inline elements in inclusive ancestor block element of aContent. * * @param aContent Must be an empty content. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveEmptyInclusiveAncestorInlineElements(nsIContent& aContent); /** * 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); /** * 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, nsAString& aNormalizedWhiteSpacesInStartNode, nsAString& 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 (including white-space) in preformatted // element }; /** * 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) { MOZ_ASSERT(aPoint.IsInTextNode()); if (aPoint.IsStartOfContainer()) { return CharPointType::TextEnd; } if (EditorUtils::IsContentPreformatted(*aPoint.ContainerAsText())) { return CharPointType::PreformattedChar; } if (aPoint.IsPreviousCharASCIISpace()) { return CharPointType::ASCIIWhiteSpace; } return aPoint.IsPreviousCharNBSP() ? CharPointType::NoBreakingSpace : CharPointType::VisibleChar; } template static CharPointType GetCharPointType(const EditorDOMPointType& aPoint) { MOZ_ASSERT(aPoint.IsInTextNode()); if (aPoint.IsEndOfContainer()) { return CharPointType::TextEnd; } if (EditorUtils::IsContentPreformatted(*aPoint.ContainerAsText())) { return CharPointType::PreformattedChar; } if (aPoint.IsCharASCIISpace()) { return CharPointType::ASCIIWhiteSpace; } return aPoint.IsCharNBSP() ? CharPointType::NoBreakingSpace : CharPointType::VisibleChar; } /** * 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: static CharPointData InDifferentTextNode(CharPointType aCharPointType) { CharPointData result; result.mIsInDifferentTextNode = true; result.mType = aCharPointType; return result; } static CharPointData InSameTextNode(CharPointType aCharPointType) { CharPointData result; // 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. result.mIsInDifferentTextNode = aCharPointType == CharPointType::TextEnd; result.mType = aCharPointType; return result; } bool AcrossTextNodeBoundary() const { return mIsInDifferentTextNode; } bool IsWhiteSpace() const { return mType == CharPointType::ASCIIWhiteSpace || mType == CharPointType::NoBreakingSpace; } CharPointType Type() const { return mType; } private: CharPointData() = default; 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; /** * GenerateWhiteSpaceSequence() generates white-space sequence which won't * be collapsed. * * @param aResult [out] White space sequence which won't be * collapsed, but wrapable. * @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 indidate white-space in same * text node. */ static void GenerateWhiteSpaceSequence( nsAString& aResult, 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, AutoRangeArray& aRangesToDelete); /** * This method handles "delete selection" commands. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT virtual EditActionResult HandleDeleteSelection(nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers) final; class AutoDeleteRangesHandler; /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveListAtSelectionAsSubAction(); /** * 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. */ enum class ChangeMargin { Increase, Decrease }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ChangeMarginStart(Element& aElement, ChangeMargin aChangeMargin); /** * HandleCSSIndentAtSelectionInternal() indents around Selection with CSS. * This method creates AutoSelectionRestorer. Therefore, each caller * need to check if the editor is still available even if this returns * NS_OK. * NOTE: Use HandleCSSIndentAtSelection() instead. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleCSSIndentAtSelectionInternal(); /** * HandleHTMLIndentAtSelectionInternal() indents around Selection with HTML. * This method creates AutoSelectionRestorer. Therefore, each caller * need to check if the editor is still available even if this returns * NS_OK. * NOTE: Use HandleHTMLIndentAtSelection() instead. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleHTMLIndentAtSelectionInternal(); /** * HandleCSSIndentAtSelection() indents around Selection with CSS. * NOTE: This is a helper method of `HandleIndentAtSelection()`. If you * want to call this directly, you should check whether you need * do do something which `HandleIndentAtSelection()` does. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleCSSIndentAtSelection(); /** * HandleHTMLIndentAtSelection() indents around Selection with HTML. * NOTE: This is a helper method of `HandleIndentAtSelection()`. If you * want to call this directly, you should check whether you need * do do something which `HandleIndentAtSelection()` does. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleHTMLIndentAtSelection(); /** * HandleIndentAtSelection() indents around Selection with HTML or CSS. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleIndentAtSelection(); /** * 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. * @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 SplitRangeOffFromNodeResult OutdentPartOfBlock(Element& aBlockElement, nsIContent& aStartOfOutdent, nsIContent& aEndOutdent, BlockIndentedWith aBlockIndentedWith); /** * 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. * * @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 SplitRangeOffFromNodeResult HandleOutdentAtSelectionInternal(); /** * HandleOutdentAtSelection() outdents contents around Selection. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleOutdentAtSelection(); /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AlignBlockContentsWithDivElement( dom::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 `
`. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult 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 nsresult EnsureHardLineBeginsWithFirstChildOf(dom::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 nsresult EnsureHardLineEndsWithLastChildOf(dom::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. */ enum class EditTarget { OnlyDescendantsExceptTable, NodeAndDescendantsExceptTable }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetBlockElementAlign(Element& aBlockOrHRElement, const nsAString& aAlignType, EditTarget aEditTarget); /** * AlignContentsAtSelectionWithEmptyDivElement() inserts new `
` element * at `Selection` to align selected contents. This returns as "handled" * if this modifies `Selection` so that callers shouldn't modify `Selection` * in such case especially when using AutoSelectionRestorer. * * @param aAlignType New align attribute value where the contents * should be aligned to. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult AlignContentsAtSelectionWithEmptyDivElement(const nsAString& aAlignType); /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AlignNodesAndDescendants( nsTArray>& aArrayOfContents, const nsAString& aAlignType); /** * AlignContentsAtSelection() aligns contents around Selection to aAlignType. * This creates AutoSelectionRestorer. Therefore, even if this returns * NS_OK, we might have been destroyed. So, every caller needs to check if * Destroyed() returns false before modifying the DOM tree or changing * Selection. * NOTE: Call AlignAsSubAction() instead. * * @param aAlignType New align attribute value where the contents * should be aligned to. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult AlignContentsAtSelection(const nsAString& aAlignType); /** * AlignAsSubAction() handles "align" command with `Selection`. * * @param aAlignType New align attribute value where the contents * should be aligned to. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult AlignAsSubAction(const nsAString& aAlignType); /** * StartOrEndOfSelectionRangesIsIn() returns true if start or end of one * of selection ranges is in aContent. */ bool StartOrEndOfSelectionRangesIsIn(nsIContent& aContent) const; /** * FindNearEditableContent() tries to find an editable node near aPoint. * * @param aPoint The DOM point where to start to search from. * @param aDirection If nsIEditor::ePrevious is set, this searches an * editable node from next nodes. Otherwise, from * previous nodes. * @return If found, returns non-nullptr. Otherwise, nullptr. * Note that if found node is in different table element, * this returns nullptr. * And also if aDirection is not nsIEditor::ePrevious, * the result may be the node pointed by aPoint. */ template nsIContent* FindNearEditableContent(const EditorDOMPointBase& aPoint, nsIEditor::EDirection aDirection); /** * 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(nsRange& 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(); /** * EnsureSelectionInBlockElement() may move caret into aElement or its * parent block if caret is outside of them. Don't call this when * `Selection` is not collapsed. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult EnsureCaretInBlockElement(dom::Element& aElement); /** * 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. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MoveSelectedContentsToDivElementToMakeItAbsolutePosition( RefPtr* aTargetElement); /** * SetSelectionToAbsoluteAsSubAction() move selected contents to first * selected `
` element or newly created `
` element and make * the `
` element positioned absolutely. * mNewBlockElement of TopLevelEditSubActionData will be set to the `
` * element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult SetSelectionToAbsoluteAsSubAction(); /** * SetSelectionToStaticAsSubAction() sets the `position` property of a * selection parent's block whose `position` is `absolute` to `static`. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult 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 EditActionResult AddZIndexAsSubAction(int32_t aChange); /** * OnDocumentModified() is called when editor content is changed. */ MOZ_CAN_RUN_SCRIPT nsresult OnDocumentModified(); protected: // Called by helper classes. MOZ_CAN_RUN_SCRIPT virtual void OnStartToHandleTopLevelEditSubAction( EditSubAction aTopLevelEditSubAction, nsIEditor::EDirection aDirectionOfTopLevelEditSubAction, ErrorResult& aRv) override; MOZ_CAN_RUN_SCRIPT virtual nsresult OnEndHandlingTopLevelEditSubAction() override; protected: // Shouldn't be used by friend classes virtual ~HTMLEditor(); template [[nodiscard]] MOZ_CAN_RUN_SCRIPT MOZ_NEVER_INLINE_DEBUG nsresult CollapseSelectionTo(const EditorDOMPointBase& aPoint) const { ErrorResult error; CollapseSelectionTo(aPoint, error); return error.StealNSResult(); } template MOZ_CAN_RUN_SCRIPT MOZ_NEVER_INLINE_DEBUG void CollapseSelectionTo( const EditorDOMPointBase& aPoint, ErrorResult& aRv) const { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!aRv.Failed()); MOZ_KnownLive(SelectionRefPtr())->CollapseInLimiter(aPoint, aRv); if (NS_WARN_IF(Destroyed())) { aRv = NS_ERROR_EDITOR_DESTROYED; return; } NS_WARNING_ASSERTION(!aRv.Failed(), "Selection::CollapseInLimiter() failed"); } [[nodiscard]] MOZ_CAN_RUN_SCRIPT MOZ_NEVER_INLINE_DEBUG nsresult CollapseSelectionToStartOf(nsINode& aNode) { return CollapseSelectionTo(EditorRawDOMPoint(&aNode, 0)); } MOZ_CAN_RUN_SCRIPT MOZ_NEVER_INLINE_DEBUG void CollapseSelectionToStartOf( nsINode& aNode, ErrorResult& aRv) const { CollapseSelectionTo(EditorRawDOMPoint(&aNode, 0), aRv); } /** * 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. * XXX I think that this should work with active editing host unless * all over the document is ediable (i.e., in design mode or `` * or `` has `contenteditable` attribute). */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InitEditorContentAndSelection(); MOZ_CAN_RUN_SCRIPT virtual nsresult SelectAllInternal() override; /** * 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); /** * CollapseSelectionAfter() collapses Selection after aElement. * If aElement is an orphan node or not in editing host, returns error. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CollapseSelectionAfter(Element& aElement); /** * 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. * * @param aTableOrElementInTable
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, 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
element or another element. * If this is a
element, returns * first element in it. Otherwise, * returns first element in nearest * ancestor
element. * @param aRv Returns an error code. When * aTableOrElementInTable is neither *
nor in a
element, * returns NS_ERROR_FAILURE. * However, if
does not have * element, returns NS_OK. */ Element* GetFirstTableRowElement(Element& aTableOrElementInTable, ErrorResult& aRv) const; /** * GetNextTableRowElement() returns next element of aTableRowElement. * This won't cross
element boundary but may cross table section * elements like . * * @param aTableRowElement A element. * @param aRv Returns error. If given element is but * there is no next element, this returns * nullptr but does not return error. */ Element* GetNextTableRowElement(Element& aTableRowElement, ErrorResult& aRv) 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. * @param aRv Returns error if layout information is not * available or given element is not a table cell. */ MOZ_CAN_RUN_SCRIPT CellIndexes(Element& aCellElement, PresShell* aPresShell, ErrorResult& aRv) : mRow(-1), mColumn(-1) { MOZ_ASSERT(!aRv.Failed()); Update(aCellElement, aPresShell, aRv); } /** * Update mRowIndex and mColumnIndex with indexes of aCellElement. * * @param See above. */ MOZ_CAN_RUN_SCRIPT void Update(Element& aCellElement, PresShell* aPresShell, ErrorResult& aRv); /** * 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. * @param aRv Returns error if there is no cell element * which contains anchor of Selection, or layout * information is not available. */ MOZ_CAN_RUN_SCRIPT CellIndexes(HTMLEditor& aHTMLEditor, Selection& aSelection, ErrorResult& aRv) : mRow(-1), mColumn(-1) { Update(aHTMLEditor, aSelection, aRv); } /** * 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, ErrorResult& aRv); 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; } private: CellIndexes() : mRow(-1), mColumn(-1) {} friend struct CellData; }; struct MOZ_STACK_CLASS CellData final { 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; int32_t mColSpan; // 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; int32_t mEffectiveColSpan; // 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; CellData() : mRowSpan(-1), mColSpan(-1), mEffectiveRowSpan(-1), mEffectiveColSpan(-1), mIsSelected(false) {} /** * Those constructors initializes the members with a
element and * both row and column index to specify a cell element. */ CellData(HTMLEditor& aHTMLEditor, Element& aTableElement, int32_t aRowIndex, int32_t aColumnIndex, ErrorResult& aRv) { Update(aHTMLEditor, aTableElement, aRowIndex, aColumnIndex, aRv); } CellData(HTMLEditor& aHTMLEditor, Element& aTableElement, const CellIndexes& aIndexes, ErrorResult& aRv) { Update(aHTMLEditor, aTableElement, aIndexes, aRv); } /** * Those Update() methods updates the members with a
element and * both row and column index to specify a cell element. */ void Update(HTMLEditor& aHTMLEditor, Element& aTableElement, int32_t aRowIndex, int32_t aColumnIndex, ErrorResult& aRv) { mCurrent.mRow = aRowIndex; mCurrent.mColumn = aColumnIndex; Update(aHTMLEditor, aTableElement, aRv); } void Update(HTMLEditor& aHTMLEditor, Element& aTableElement, const CellIndexes& aIndexes, ErrorResult& aRv) { mCurrent = aIndexes; Update(aHTMLEditor, aTableElement, aRv); } void Update(HTMLEditor& aHTMLEditor, Element& aTableElement, ErrorResult& aRv); /** * FailedOrNotFound() returns true if this failed to initialize/update * or succeeded but found no cell element. */ bool FailedOrNotFound() const { return !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. */ bool IsSpannedFromOtherRowOrColumn() const { return mElement && mCurrent != mFirst; } bool IsSpannedFromOtherColumn() const { return mElement && mCurrent.mColumn != mFirst.mColumn; } bool IsSpannedFromOtherRow() const { return mElement && mCurrent.mRow != mFirst.mRow; } /** * NextColumnIndex() and NextRowIndex() return column/row index of * next cell. Note that this does not check whether there is next * cell or not actually. */ int32_t NextColumnIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mColumn + mEffectiveColSpan; } 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. */ int32_t LastColumnIndex() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return NextColumnIndex() - 1; } 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. */ int32_t NumberOfPrecedingColmuns() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mCurrent.mColumn - mFirst.mColumn; } 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. */ int32_t NumberOfFollowingColumns() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mEffectiveColSpan - 1; } int32_t NumberOfFollowingRows() const { if (NS_WARN_IF(FailedOrNotFound())) { return -1; } return mEffectiveRowSpan - 1; } }; /** * TableSize stores and computes number of rows and columns of a
* element. */ struct MOZ_STACK_CLASS TableSize final { int32_t mRowCount; int32_t mColumnCount; /** * @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. * @param aRv Returns error if the element is not * in
or layout information is * not available. */ TableSize(HTMLEditor& aHTMLEditor, Element& aTableOrElementInTable, ErrorResult& aRv) : mRowCount(-1), mColumnCount(-1) { MOZ_ASSERT(!aRv.Failed()); Update(aHTMLEditor, aTableOrElementInTable, aRv); } /** * Update mRowCount and mColumnCount for aTableOrElementInTable. * See above for the detail. */ void Update(HTMLEditor& aHTMLEditor, Element& aTableOrElementInTable, ErrorResult& aRv); bool IsEmpty() const { return !mRowCount || !mColumnCount; } }; /** * 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. */ Element* GetTableCellElementAt(Element& aTableElement, const CellIndexes& aCellIndexes) const { return GetTableCellElementAt(aTableElement, aCellIndexes.mRow, aCellIndexes.mColumn); } 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). */ already_AddRefed GetSelectedOrParentTableElement( ErrorResult& aRv, bool* aIsCellSelected = nullptr) const; /** * 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. */ MOZ_CAN_RUN_SCRIPT nsresult PasteInternal(int32_t aClipboardType); /** * InsertWithQuotationsAsSubAction() inserts aQuotedText with appending ">" * to start of every line. * * @param aQuotedText String to insert. This will be quoted by ">" * automatically. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT virtual 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 IsPlaintextEditor() 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 aNodeInserted [OUT] The new
element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsCitedQuotationInternal( const nsAString& aQuotedText, const nsAString& aCitation, bool aInsertHTML, 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 aNode Node to insert. * @param aPointToInsert Insertion point. * @param aSplitAtEdges Splitting can result in empty nodes? * @return Returns inserted point if succeeded. * Otherwise, the result is not set. */ MOZ_CAN_RUN_SCRIPT EditorDOMPoint InsertNodeIntoProperAncestorWithTransaction( nsIContent& aNode, const EditorDOMPoint& aPointToInsert, SplitAtEdges aSplitAtEdges); /** * InsertBRElementAtSelectionWithTransaction() inserts a new
element at * selection. If there is non-collapsed selection ranges, the selected * ranges is deleted first. */ MOZ_CAN_RUN_SCRIPT nsresult InsertBRElementAtSelectionWithTransaction(); /** * 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); /** * 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. */ MOZ_CAN_RUN_SCRIPT already_AddRefed ReplaceContainerWithTransactionInternal(Element& aElement, nsAtom& aTagName, nsAtom& aAttribute, const nsAString& aAttributeValue, bool aCloneAllAttributes); /** * InsertContainerWithTransactionInternal() creates new element whose name is * aTagName, moves aContent into the new element, then, inserts the new * element into where aContent was. If aAttribute is not nsGkAtoms::_empty, * aAttribute of the new element will be set to aAttributeValue. * * @param aContent The content which will be wrapped with new * element. * @param aTagName Element name of new element which will wrap * aContent and be inserted into where aContent * was. * @param aAttribute Attribute which should be set to the new * element. If this is nsGkAtoms::_empty, * this does not set any attributes to the new * element. * @param aAttributeValue Value to be set to aAttribute. * @return The new element. */ MOZ_CAN_RUN_SCRIPT already_AddRefed InsertContainerWithTransactionInternal(nsIContent& aContent, nsAtom& aTagName, nsAtom& aAttribute, const nsAString& aAttributeValue); /** * 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. * @return Created new element. */ MOZ_CAN_RUN_SCRIPT already_AddRefed DeleteSelectionAndCreateElement( nsAtom& aTag); /** * 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(); /** * PrepareToInsertBRElement() returns a point where new
element 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 aPointToInsert Candidate point to insert new
element. * @return Computed point to insert new
element. * If something failed, this is unset. */ MOZ_CAN_RUN_SCRIPT EditorDOMPoint PrepareToInsertBRElement(const EditorDOMPoint& aPointToInsert); /** * IndentAsSubAction() indents the content around Selection. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult IndentAsSubAction(); /** * OutdentAsSubAction() outdents the content around Selection. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult OutdentAsSubAction(); MOZ_CAN_RUN_SCRIPT nsresult LoadHTML(const nsAString& aInputString); /** * SetInlinePropertyInternal() stores new style with `mTypeInState` if * `Selection` is collapsed. Otherwise, applying the style at all selection * ranges. * * @param aProperty One of the presentation tag names which we * support in style editor. * @param aAttribute For some aProperty values, needs to be set to * its attribute name. Otherwise, nullptr. * @param aAttributeValue The value of aAttribute. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertyInternal( nsAtom& aProperty, nsAtom* aAttribute, const nsAString& aValue); /** * RemoveInlinePropertyInternal() removes specified style from `mTypeInState` * if `Selection` is collapsed. Otherwise, removing the style. * * @param aHTMLProperty nullptr if you want to remove all inline styles. * Otherwise, one of the presentation tag names * which we support in style editor. * @param aAttribute For some aHTMLProperty values, need to be set to * its attribute name. Otherwise, nullptr. * @param aRemoveRelatedElements If Yes, this method removes different * name's elements in the block if * necessary. For example, if * aHTMLProperty is nsGkAtoms::b, * `` elements are also removed. */ enum class RemoveRelatedElements { Yes, No }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveInlinePropertyInternal( nsStaticAtom* aHTMLProperty, nsStaticAtom* aAttribute, RemoveRelatedElements aRemoveRelatedElements); /** * ReplaceHeadContentsWithSourceWithTransaction() replaces all children of * element with given source code. This is undoable. * * @param aSourceToInsert HTML source fragment to replace the children * of element. */ MOZ_CAN_RUN_SCRIPT nsresult ReplaceHeadContentsWithSourceWithTransaction( const nsAString& aSourceToInsert); [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetCSSBackgroundColorState( bool* aMixed, nsAString& aOutColor, bool aBlockLevel); nsresult GetHTMLBackgroundColorState(bool* aMixed, nsAString& outColor); nsresult GetLastCellInRow(nsINode* aRowNode, nsINode** aCellNode); /** * This sets background on the appropriate container element (table, cell,) * or calls into nsTextEditor to set the page background. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetCSSBackgroundColorWithTransaction(const nsAString& aColor); MOZ_CAN_RUN_SCRIPT nsresult SetHTMLBackgroundColorWithTransaction(const nsAString& aColor); MOZ_CAN_RUN_SCRIPT_BOUNDARY virtual void InitializeSelectionAncestorLimit( nsIContent& aAncestorLimit) const override; /** * Make the given selection span the entire document. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT virtual nsresult SelectEntireDocument() override; /** * 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; class BlobReader final { typedef EditorBase::AutoEditActionDataSetter AutoEditActionDataSetter; public: BlobReader(dom::BlobImpl* aBlob, HTMLEditor* aHTMLEditor, bool aIsSafe, Document* aSourceDoc, const EditorDOMPoint& aPointToInsert, bool aDoDeleteSelection); 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 mDataTransfer; nsCOMPtr mSourceDoc; EditorDOMPoint mPointToInsert; EditAction mEditAction; bool mIsSafe; bool mDoDeleteSelection; bool mNeedsToDispatchBeforeInputEvent; }; virtual void CreateEventListeners() override; virtual nsresult InstallEventListeners() override; virtual void RemoveEventListeners() override; 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; virtual already_AddRefed GetInputEventTargetElement() const override; /** * 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 EditActionResult 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 elements before or after * a cell element containing first selection range. I.e., if the cell * spans rows and aInsertPosition is eAfterSelectedCell, new rows will be * inserted after the most-bottom row which contains the cell. If first * selection range is not in table cell element, this does nothing but * does not return error. * * @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( 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 before or after * a cell element containing first selection range. I.e., if the cell * spans columns and aInsertPosition is eAfterSelectedCell, new columns * will be inserted after the right-most column which contains the cell. * 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. * If first selection range is not in table cell element, this does nothing * but does not return error. * * @param aNumberOfCellssToInsert Number of cells to insert. * @param aInsertPosition Before or after the target cell which * contains first selection range. */ MOZ_CAN_RUN_SCRIPT nsresult InsertTableCellsWithTransaction( int32_t aNumberOfCellsToInsert, InsertPosition aInsertPosition); /** * InsertTableColumnsWithTransaction() inserts columns before or after * a cell element containing first selection range. I.e., if the cell * spans columns and aInsertPosition is eAfterSelectedCell, new columns * will be inserted after the right-most row which contains the cell. * If first selection range is not in table cell element, this does nothing * but does not return error. * * @param aNumberOfColumnsToInsert Number of columns to insert. * @param aInsertPosition Before or after the target cell which * contains first selection range. */ MOZ_CAN_RUN_SCRIPT nsresult InsertTableColumnsWithTransaction( int32_t aNumberOfColumnsToInsert, InsertPosition aInsertPosition); /** * InsertTableRowsWithTransaction() inserts

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(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(int32_t aSelectionType); /** * 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.) * @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, bool aAddCites, nsINode** aNodeInserted); /** * 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, bool aIsSafe, Document* aSourceDoc, const EditorDOMPoint& aPointToInsert, bool aDoDeleteSelection); // factored methods for handling insertion of data from transferables // (drag&drop or clipboard) virtual nsresult PrepareTransferable( nsITransferable** aTransferable) override; class HTMLTransferablePreparer; nsresult PrepareHTMLTransferable(nsITransferable** aTransferable) const; MOZ_CAN_RUN_SCRIPT nsresult InsertFromTransferable( nsITransferable* aTransferable, Document* aSourceDoc, const nsAString& aContextStr, const nsAString& aInfoStr, bool aHavePrivateHTMLFlavor, bool aDoDeleteSelection); /** * 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 dom::DataTransfer* aDataTransfer, int32_t aIndex, Document* aSourceDoc, const EditorDOMPoint& aDroppedAt, bool aDoDeleteSelection); static bool HavePrivateHTMLFlavor(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; }; /** * GetBetterInsertionPointFor() returns better insertion point to insert * aContentToInsert. * * @param aContentToInsert The content to insert. * @param aPointToInsert A candidate point to insert the node. * @return Better insertion point if next visible node * is a
element and previous visible node * is neither none, another
element nor * different block level element. */ EditorRawDOMPoint GetBetterInsertionPointFor( nsIContent& aContentToInsert, const EditorRawDOMPoint& aPointToInsert) 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. */ MOZ_CAN_RUN_SCRIPT nsresult FormatBlockContainerAsSubAction(nsAtom& aTagName); /** * Increase/decrease the font size of selection. */ MOZ_CAN_RUN_SCRIPT nsresult RelativeFontChange(FontSize aDir); MOZ_CAN_RUN_SCRIPT nsresult RelativeFontChangeOnNode(int32_t aSizeChange, nsIContent* aNode); MOZ_CAN_RUN_SCRIPT nsresult RelativeFontChangeHelper(int32_t aSizeChange, nsINode* aNode); /** * Helper routines for inline style. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertyOnTextNode( Text& aData, uint32_t aStartOffset, uint32_t aEndOffset, nsAtom& aProperty, nsAtom* aAttribute, const nsAString& aValue); nsresult PromoteInlineRange(nsRange& aRange); nsresult PromoteRangeIfStartsOrEndsInNamedAnchor(nsRange& aRange); /** * RemoveStyleInside() removes elements which represent aProperty/aAttribute * and removes CSS style. This handles aElement and all its descendants * (including leaf text nodes) recursively. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveStyleInside(Element& aElement, nsAtom* aProperty, nsAtom* aAttribute); /** * CollectEditableLeafTextNodes() collects text nodes in aElement. */ void CollectEditableLeafTextNodes( Element& aElement, nsTArray>& aLeafTextNodes) const; /** * IsRemovableParentStyleWithNewSpanElement() checks whether * aProperty/aAttribute 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 bool IsRemovableParentStyleWithNewSpanElement( nsIContent& aContent, nsAtom* aHTMLProperty, nsAtom* aAttribute) const; /** * XXX These methods seem odd and except the only caller, * `PromoteInlineRange()`, cannot use them. */ bool IsStartOfContainerOrBeforeFirstEditableChild( const EditorRawDOMPoint& aPoint) const; bool IsEndOfContainerOrEqualsOrAfterLastEditableChild( const EditorRawDOMPoint& aPoint) const; bool IsOnlyAttribute(const Element* aElement, nsAtom* aAttribute); /** * 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. * * aClearStyle should be set to false if you want the paste to be affected by * local style (e.g., for the insertHTML command). */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DoInsertHTMLWithContext( const nsAString& aInputString, const nsAString& aContextStr, const nsAString& aInfoStr, const nsAString& aFlavor, Document* aSourceDoc, const EditorDOMPoint& aPointToInsert, bool aDeleteSelection, bool aTrustedInput, bool aClearStyle = true); /** * 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. */ 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, }; int32_t GetNewResizingIncrement(int32_t aX, int32_t aY, ResizeAt aResizeAt); [[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). */ void HideAnonymousEditingUIs(); /** * HideAnonymousEditingUIsIfUnnecessary() hides all editing UIs if some of * visible UIs are now unnecessary. */ 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. */ MOZ_CAN_RUN_SCRIPT nsresult RefreshGrabberInternal(); /** * hide the grabber if it shown. */ 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 AddPositioningOffset(int32_t& aX, int32_t& aY); void SnapToGrid(int32_t& newX, int32_t& newY); 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. */ MOZ_CAN_RUN_SCRIPT nsresult RefreshInlineTableEditingUIInternal(); /** * IsEmptyTextNode() returns true if aNode is a text node and does not have * any visible characters. */ bool IsEmptyTextNode(nsINode& aNode) const { return aNode.IsText() && IsEmptyNode(aNode); } /** * ElementIsGoodContainerForTheStyle() returns true if aElement is a * good container for applying the style (aProperty/aAttribute/aValue) * to a node. I.e., if this returns true, moving nodes into aElement * is enough to apply the style to them. Otherwise, you need to create * new element for the style. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result ElementIsGoodContainerForTheStyle(Element& aElement, nsAtom* aProperty, nsAtom* aAttribute, const nsAString* aValue); MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertyOnNodeImpl(nsIContent& aNode, nsAtom& aProperty, nsAtom* aAttribute, const nsAString& aValue); typedef enum { eInserted, eAppended } InsertedOrAppended; MOZ_CAN_RUN_SCRIPT void DoContentInserted( nsIContent* aChild, InsertedOrAppended aInsertedOrAppended); /** * Returns an anonymous Element of type aTag, * child of aParentContent. If aIsCreatedHidden is true, the class * "hidden" is added to the created element. If aAnonClass is not * the empty string, it becomes the value of the attribute "_moz_anonclass" * @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 aAnonClass [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& aAnonClass, bool aIsCreatedHidden); /** * Reads a blob into memory and notifies the BlobReader object when the read * operation is finished. * * @param aBlob The input blob * @param aWindow 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, nsPIDOMWindowOuter* aWindow, BlobReader* aBlobReader); /** * OnModifyDocumentInternal() is called by OnModifyDocument(). */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult OnModifyDocumentInternal(); /** * 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. */ already_AddRefed GetSelectedRangeItemForTopLevelEditSubAction() const { if (!mSelectedRangeForTopLevelEditSubAction) { mSelectedRangeForTopLevelEditSubAction = new RangeItem(); } return do_AddRef(mSelectedRangeForTopLevelEditSubAction); } /** * 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. */ already_AddRefed GetChangedRangeForTopLevelEditSubAction() const { if (!mChangedRangeForTopLevelEditSubAction) { mChangedRangeForTopLevelEditSubAction = nsRange::Create(GetDocument()); } return do_AddRef(mChangedRangeForTopLevelEditSubAction); } protected: // Helper for Handle[CSS|HTML]IndentAtSelectionInternal [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult IndentListChild(RefPtr* aCurList, const EditorDOMPoint& aCurPoint, nsIContent& aContent); RefPtr mTypeInState; RefPtr mComposerCommandsUpdater; // Used by TopLevelEditSubActionData::mSelectedRange. mutable RefPtr mSelectedRangeForTopLevelEditSubAction; // Used by TopLevelEditSubActionData::mChangedRange. mutable RefPtr mChangedRangeForTopLevelEditSubAction; RefPtr mPendingRootElementUpdatedRunner; RefPtr mPendingDocumentModifiedRunner; bool mCRInParagraphCreatesParagraph; bool mCSSAware; UniquePtr mCSSEditUtils; // 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; // 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 AddMouseClickListener(Element* aElement); void RemoveMouseClickListener(Element* aElement); bool mDisabledLinkHandling = false; bool mOldLinkHandlingEnabled = false; bool mHasBeforeInputBeenCanceled = false; ParagraphSeparator mDefaultParagraphSeparator; friend class AlignStateAtSelection; friend class AutoSelectionSetterAfterTableEdit; friend class AutoSetTemporaryAncestorLimiter; friend class CSSEditUtils; friend class EditorBase; friend class EmptyEditableFunctor; friend class JoinNodeTransaction; friend class ListElementSelectionState; friend class ListItemElementSelectionState; friend class ParagraphStateAtSelection; friend class SlurpBlobEventListener; friend class SplitNodeTransaction; friend class TextEditor; friend class WhiteSpaceVisibilityKeeper; friend class WSRunScanner; friend class WSScanResult; }; /** * 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: ParagraphStateAtSelection() = delete; ParagraphStateAtSelection(HTMLEditor& aHTMLEditor, 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 mFirstParagraphState; } /** * If selected nodes are not in same format node nor only in no-format blocks, * this returns true. */ bool IsMixed() const { return mIsMixed; } private: using EditorType = EditorBase::EditorType; /** * 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 aNonFormatBlockElement Must be a non-format block element. */ static void AppendDescendantFormatNodesAndFirstInlineNode( nsTArray>& aArrayOfContents, dom::Element& aNonFormatBlockElement); /** * CollectEditableFormatNodesInSelection() collects only editable nodes * around selection ranges (with * `HTMLEditor::CollectEditTargetNodesInExtendedSelectionRanges()`, see its * document for the detail). If it includes list, list item or table * related elements, they will be replaced their children. */ static nsresult CollectEditableFormatNodesInSelection( HTMLEditor& aHTMLEditor, nsTArray>& aArrayOfContents); RefPtr mFirstParagraphState; bool mIsMixed = false; }; } // namespace mozilla mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() { return static_cast(this)->IsHTMLEditor() ? static_cast(this) : nullptr; } const mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() const { return static_cast(this)->IsHTMLEditor() ? static_cast(this) : nullptr; } #endif // #ifndef mozilla_HTMLEditor_h