element as * its child or its descendant. */ bool CanContainParagraph(Element& aElement) const; /** * InsertBRElement() inserts a
element into aInsertToBreak. * This may split container elements at the point and/or may move following *
element to immediately after the new
element if necessary. * XXX This method name is too generic and unclear whether such complicated * things will be done automatically or not. * XXX This modifies Selection, but should return CreateElementResult instead. * * @param aInsertToBreak The point where new
element will be * inserted before. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertBRElement(const EditorDOMPoint& aInsertToBreak); /** * GetMostAncestorInlineElement() returns the most ancestor inline element * between aNode and the editing host. Even if the editing host is an inline * element, this method never returns the editing host as the result. */ nsIContent* GetMostAncestorInlineElement(nsINode& aNode) const; /** * SplitParentInlineElementsAtRangeEdges() splits parent inline nodes at both * start and end of aRangeItem. If this splits at every point, this modifies * aRangeItem to point each split point (typically, right node). * * @param aRangeItem [in/out] One or two DOM points where should be * split. Will be modified to split point if * they're split. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitParentInlineElementsAtRangeEdges(RangeItem& aRangeItem); /** * SplitParentInlineElementsAtRangeEdges(nsTArray>&) calls * SplitParentInlineElementsAtRangeEdges(RangeItem&) for each range. Then, * updates given range to keep edit target ranges as expected. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitParentInlineElementsAtRangeEdges( nsTArray>& aArrayOfRanges); /** * SplitElementsAtEveryBRElement() splits before all
elements in * aMostAncestorToBeSplit. All
nodes will be moved before right node * at splitting its parent. Finally, this returns left node, first
* element, next left node, second
element... and right-most node. * * @param aMostAncestorToBeSplit Most-ancestor element which should * be split. * @param aOutArrayOfNodes First left node, first
element, * Second left node, second
element, * ...right-most node. So, all nodes * in this list should be siblings (may be * broken the relation by mutation event * listener though). If first
element * is first leaf node of * aMostAncestorToBeSplit, starting from * the first
element. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitElementsAtEveryBRElement( nsIContent& aMostAncestorToBeSplit, nsTArray>& aOutArrayOfContents); /** * MaybeSplitElementsAtEveryBRElement() calls SplitElementsAtEveryBRElement() * for each given node when this needs to do that for aEditSubAction. * If split a node, it in aArrayOfContents is replaced with split nodes and *
elements. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MaybeSplitElementsAtEveryBRElement( nsTArray>& aArrayOfContents, EditSubAction aEditSubAction); /** * CollectEditableChildren() collects child nodes of aNode (starting from * first editable child, but may return non-editable children after it). * * @param aNode Parent node of retrieving children. * @param aOutArrayOfContents [out] This method will inserts found children * into this array. * @param aIndexToInsertChildren Starting from this index, found * children will be inserted to the array. * @param aCollectListChildren If Yes, will collect children of list * and list-item elements recursively. * @param aCollectTableChildren If Yes, will collect children of table * related elements recursively. * @param aCollectNonEditableNodes If Yes, will collect found children * even if they are not editable. * @return Number of found children. */ enum class CollectListChildren { No, Yes }; enum class CollectTableChildren { No, Yes }; enum class CollectNonEditableNodes { No, Yes }; size_t CollectChildren( nsINode& aNode, nsTArray>& aOutArrayOfContents, size_t aIndexToInsertChildren, CollectListChildren aCollectListChildren, CollectTableChildren aCollectTableChildren, CollectNonEditableNodes aCollectNonEditableNodes) const; /** * SplitInlinessAndCollectEditTargetNodes() splits text nodes and inline * elements around aArrayOfRanges. Then, collects edit target nodes to * aOutArrayOfNodes. Finally, each edit target nodes is split at every *
element in it. * FYI: You can use SplitInlinesAndCollectEditTargetNodesInOneHardLine() * or SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges() * instead if you want to call this with a hard line including * specific DOM point or extended selection ranges. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitInlinesAndCollectEditTargetNodes( nsTArray>& aArrayOfRanges, nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes); /** * SplitTextNodesAtRangeEnd() splits text nodes if each range end is in * middle of a text node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitTextNodesAtRangeEnd(nsTArray>& aArrayOfRanges); /** * CollectEditTargetNodes() collects edit target nodes in aArrayOfRanges. * First, this collects all nodes in given ranges, then, modifies the * result for specific edit sub-actions. * FYI: You can use CollectEditTargetNodesInExtendedSelectionRanges() instead * if you want to call this with extended selection ranges. */ nsresult CollectEditTargetNodes( nsTArray>& aArrayOfRanges, nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes); /** * GetWhiteSpaceEndPoint() returns point at first or last ASCII whitespace * or non-breakable space starting from aPoint. I.e., this returns next or * previous point whether the character is neither ASCII whitespace nor * non-brekable space. */ enum class ScanDirection { Backward, Forward }; template static EditorDOMPoint GetWhiteSpaceEndPoint( const RangeBoundaryBase& aPoint, ScanDirection aScanDirection); /** * GetCurrentHardLineStartPoint() returns start point of hard line * including aPoint. If the line starts after a `
` element, returns * next sibling of the `
` element. If the line is first line of a block, * returns point of the block. * NOTE: The result may be point of editing host. I.e., the container may * be outside of editing host. */ template EditorDOMPoint GetCurrentHardLineStartPoint( const RangeBoundaryBase& aPoint, EditSubAction aEditSubAction); /** * GetCurrentHardLineEndPoint() returns end point of hard line including * aPoint. If the line ends with a `
` element, returns the `
` * element unless it's the last node of a block. If the line is last line * of a block, returns next sibling of the block. Additionally, if the * line ends with a linefeed in pre-formated text node, returns point of * the linefeed. * NOTE: This result may be point of editing host. I.e., the container * may be outside of editing host. */ template EditorDOMPoint GetCurrentHardLineEndPoint( const RangeBoundaryBase& aPoint); /** * CreateRangeIncludingAdjuscentWhiteSpaces() creates an nsRange instance * which may be expanded from the given range to include adjuscent * whitespaces. If this fails handling something, returns nullptr. */ already_AddRefed CreateRangeIncludingAdjuscentWhiteSpaces( const dom::AbstractRange& aAbstractRange); template already_AddRefed CreateRangeIncludingAdjuscentWhiteSpaces( const RangeBoundaryBase& aStartRef, const RangeBoundaryBase& aEndRef); /** * GetSelectionRangesExtendedToIncludeAdjuscentWhiteSpaces() collects * selection ranges with extending to include adjuscent whitespaces * of each range start and end. * * @param aOutArrayOfRanges [out] Always appended same number of ranges * as Selection::RangeCount(). Must be empty * when you call this. */ void GetSelectionRangesExtendedToIncludeAdjuscentWhiteSpaces( nsTArray>& aOutArrayOfRanges); /** * CreateRangeExtendedToHardLineStartAndEnd() creates an nsRange instance * which may be expanded to start/end of hard line at both edges of the given * range. If this fails handling something, returns nullptr. */ already_AddRefed CreateRangeExtendedToHardLineStartAndEnd( const dom::AbstractRange& aAbstractRange, EditSubAction aEditSubAction); template already_AddRefed CreateRangeExtendedToHardLineStartAndEnd( const RangeBoundaryBase& aStartRef, const RangeBoundaryBase& aEndRef, EditSubAction aEditSubAction); /** * GetSelectionRangesExtendedToHardLineStartAndEnd() collects selection ranges * with extending to start/end of hard line from each range start and end. * XXX This means that same range may be included in the result. * * @param aOutArrayOfRanges [out] Always appended same number of ranges * as Selection::RangeCount(). Must be empty * when you call this. */ void GetSelectionRangesExtendedToHardLineStartAndEnd( nsTArray>& aOutArrayOfRanges, EditSubAction aEditSubAction); /** * SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges() calls * SplitInlinesAndCollectEditTargetNodes() with result of * GetSelectionRangesExtendedToHardLineStartAndEnd(). See comments for these * methods for the detail. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitInlinesAndCollectEditTargetNodesInExtendedSelectionRanges( nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes) { AutoTArray, 4> extendedSelectionRanges; GetSelectionRangesExtendedToHardLineStartAndEnd(extendedSelectionRanges, aEditSubAction); nsresult rv = SplitInlinesAndCollectEditTargetNodes( extendedSelectionRanges, aOutArrayOfContents, aEditSubAction, aCollectNonEditableNodes); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "SplitInlinesAndCollectEditTargetNodes() failed"); return rv; } /** * SplitInlinesAndCollectEditTargetNodesInOneHardLine() just calls * SplitInlinesAndCollectEditTargetNodes() with result of calling * CreateRangeExtendedToHardLineStartAndEnd() with aPointInOneHardLine. * In other words, returns nodes in the hard line including * `aPointInOneHardLine`. See the comments for these methods for the * detail. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SplitInlinesAndCollectEditTargetNodesInOneHardLine( const EditorDOMPoint& aPointInOneHardLine, nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes) { if (NS_WARN_IF(!aPointInOneHardLine.IsSet())) { return NS_ERROR_INVALID_ARG; } RefPtr oneLineRange = CreateRangeExtendedToHardLineStartAndEnd( aPointInOneHardLine.ToRawRangeBoundary(), aPointInOneHardLine.ToRawRangeBoundary(), aEditSubAction); if (!oneLineRange) { // XXX It seems odd to create collapsed range for one line range... ErrorResult error; oneLineRange = nsRange::Create(aPointInOneHardLine.ToRawRangeBoundary(), aPointInOneHardLine.ToRawRangeBoundary(), error); if (NS_WARN_IF(error.Failed())) { return error.StealNSResult(); } } AutoTArray, 1> arrayOfLineRanges; arrayOfLineRanges.AppendElement(oneLineRange); nsresult rv = SplitInlinesAndCollectEditTargetNodes( arrayOfLineRanges, aOutArrayOfContents, aEditSubAction, aCollectNonEditableNodes); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "SplitInlinesAndCollectEditTargetNodes() failed"); return rv; } /** * CollectEditTargetNodesInExtendedSelectionRanges() calls * CollectEditTargetNodes() with result of * GetSelectionRangesExtendedToHardLineStartAndEnd(). See comments for these * methods for the detail. */ nsresult CollectEditTargetNodesInExtendedSelectionRanges( nsTArray>& aOutArrayOfContents, EditSubAction aEditSubAction, CollectNonEditableNodes aCollectNonEditableNodes) { AutoTArray, 4> extendedSelectionRanges; GetSelectionRangesExtendedToHardLineStartAndEnd(extendedSelectionRanges, aEditSubAction); nsresult rv = CollectEditTargetNodes(extendedSelectionRanges, aOutArrayOfContents, aEditSubAction, aCollectNonEditableNodes); NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "CollectEditTargetNodes() failed"); return rv; } /** * SelectBRElementIfCollapsedInEmptyBlock() helper method for * CreateRangeIncludingAdjuscentWhiteSpaces() and * CreateRangeExtendedToLineStartAndEnd(). If the given range is collapsed * in a block and the block has only one `
` element, this makes * aStartRef and aEndRef select the `
` element. */ template void SelectBRElementIfCollapsedInEmptyBlock( RangeBoundaryBase& aStartRef, RangeBoundaryBase& aEndRef); /** * GetChildNodesOf() returns all child nodes of aParent with an array. */ static void GetChildNodesOf( nsINode& aParentNode, nsTArray>& aOutArrayOfContents) { MOZ_ASSERT(aOutArrayOfContents.IsEmpty()); aOutArrayOfContents.SetCapacity(aParentNode.GetChildCount()); for (nsIContent* childContent = aParentNode.GetFirstChild(); childContent; childContent = childContent->GetNextSibling()) { aOutArrayOfContents.AppendElement(*childContent); } } /** * GetDeepestEditableOnlyChildDivBlockquoteOrListElement() returns a `

`, * `

` 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); /** * If aContent is a text node that contains only collapsed whitespace or empty * and editable. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DeleteNodeIfInvisibleAndEditableTextNode(nsIContent& aContent); /** * If aPoint follows invisible `
` element, returns the invisible `
` * element. Otherwise, nullptr. */ template Element* GetInvisibleBRElementAt(const EditorDOMPointBase& aPoint); /** * 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); /** * MoveNodeOrChildren() 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 MoveNodeOrChildren(nsIContent& aNode, const EditorDOMPoint& aPointToInsert); /** * MoveContents() moves the children of aElement to aPointToInsert. If * cannot insert some children due to invalid relation, calls * MoveNodeOrChildren() 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 MoveChildren(Element& aElement, const EditorDOMPoint& aPointToInsert); /** * 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); /** * TryToJoinBlocksWithTransaction() tries to join two block elements. The * right element is always joined to the left element. If the elements are * the same type and not nested within each other, * JoinEditableNodesWithTransaction() is called (example, joining two list * items together into one). If the elements are not the same type, or one * is a descendant of the other, we instead destroy the right block placing * its children into leftblock. * * @return Sets canceled to true if the operation should do * nothing anymore even if this doesn't join the blocks. * Sets handled to true if this actually handles the * request. Note that this may set it to true even if this * does not join the block. E.g., if the blocks shouldn't * be joined or it's impossible to join them but it's not * unexpected case, this returns true with this. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult TryToJoinBlocksWithTransaction(nsIContent& aLeftContentInBlock, nsIContent& aRightContentInBlock); /** * 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); /** * MaybeDeleteTopMostEmptyAncestor() looks for top most empty block ancestor * of aStartContent in aEditingHostElement. * If found empty ancestor is a list item element, inserts a
element * before its parent element if grand parent is a list element. Then, * collapse Selection to after the empty block. * If found empty ancestor is not a list item element, collapse Selection to * somewhere depending on aAction. * Finally, removes the empty block ancestor. * * @param aStartContent Start content to look for empty ancestors. * @param aEditingHostElement Current editing host. * @param aDirectionAndAmount If found empty ancestor block is a list item * element, this is ignored. Otherwise: * - If eNext, eNextWord or eToEndOfLine, collapse * Selection to after found empty ancestor. * - If ePrevious, ePreviousWord or * eToBeginningOfLine, collapse Selection to * end of previous editable node. * Otherwise, eNone is allowed but does nothing. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult MaybeDeleteTopMostEmptyAncestor(nsIContent& aStartContent, Element& aEditingHostElement, nsIEditor::EDirection aDirectionAndAmount); /** * GetExtendedRangeToIncludeInvisibleNodes() returns extended range. * If there are some invisible nodes around aAbstractRange, they may * be included. * * @param aAbstractRange Original range. This must not be collapsed * and must be positioned. * @return Extended range. */ already_AddRefed GetExtendedRangeToIncludeInvisibleNodes( const dom::AbstractRange& aAbstractRange); /** * HandleDeleteCollapsedSelectionAtWhiteSpaces() handles deletion of * collapsed selection at whitespaces in a text node. * * @param aDirectionAndAmount Direction of the deletion. * @param aWSRunObjectAtCaret WSRunObject instance which was initialized with * the caret point. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteCollapsedSelectionAtWhiteSpaces( nsIEditor::EDirection aDirectionAndAmount, WSRunObject& aWSRunObjectAtCaret); /** * HandleDeleteCollapsedSelectionAtTextNode() handles deletion of * collapsed selection in a text node. * * @param aDirectionAndAmount Direction of the deletion. * @param aPointToDelete The point in a text node to delete character(s). * Caller must guarantee that this is in a text * node. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteCollapsedSelectionAtTextNode( nsIEditor::EDirection aDirectionAndAmount, const EditorDOMPoint& aPointToDelete); /** * HandleDeleteCollapsedSelectionAtAtomicContent() handles deletion of * atomic elements like `
`, `
`, ``, ``, etc and * data nodes except text node (e.g., comment node). * If aAtomicContent is a invisible `
` element, this will call * `WillDeleteSelection()` recursively after deleting it. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. * @param aAtomicContent The atomic content to be deleted. * @param aCaretPoint The caret point (i.e., selection start or * end). * @param aWSRunScannerAtCaret WSRunScanner instance which was initialized * with the caret point. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteCollapsedSelectionAtAtomicContent( nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers, nsIContent& aAtomicContent, const EditorDOMPoint& aCaretPoint, WSRunScanner& aWSRunScannerAtCaret); /** * HandleDeleteCollapsedSelectionAtOtherBlockBoundary() handles deletion at * other block boundary (i.e., immediately before or after a block). * If this does not join blocks, `WillDeleteSelection()` may be called * recursively. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. * @param aOtherBlockElement The block element which follows the caret or * is followed by caret. * @param aCaretPoint The caret point (i.e., selection start or * end). * @param aWSRunScannerAtCaret WSRunScanner instance which was initialized * with the caret point. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteCollapsedSelectionAtOtherBlockBoundary( nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers, Element& aOtherBlockElement, const EditorDOMPoint& aCaretPoint, WSRunScanner& aWSRunScannerAtCaret); /** * HandleDeleteCollapsedSelectionAtCurrentBlockBoundary() handles deletion * at current block boundary (i.e., at start or end of current block). * * @param aDirectionAndAmount Direction of the deletion. * @param aCurrentBlockElement The current block element. * @param aCaretPoint The caret point (i.e., selection start * or end). */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteCollapsedSelectionAtCurrentBlockBoundary( nsIEditor::EDirection aDirectionAndAmount, Element& aCurrentBlockElement, const EditorDOMPoint& aCaretPoint); /** * DeleteUnnecessaryNodesAndCollapseSelection() removes unnecessary nodes * around aSelectionStartPoint and aSelectionEndPoint. Then, collapse * selection at aSelectionStartPoint or aSelectionEndPoint (depending on * aDirectionAndAmount). * * @param aDirectionAndAmount Direction of the deletion. * If nsIEditor::ePrevious, selection will * be collapsed to aSelectionEndPoint. * Otherwise, selection will be collapsed * to aSelectionStartPoint. * @param aSelectionStartPoint First selection range start after * computing the deleting range. * @param aSelectionEndPoint First selection range end after * computing the deleting range. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DeleteUnnecessaryNodesAndCollapseSelection( nsIEditor::EDirection aDirectionAndAmount, const EditorDOMPoint& aSelectionStartPoint, const EditorDOMPoint& aSelectionEndPoint); /** * HandleDeleteAroundCollapsedSelection() handles deletion with collapsed * `Selection`. Callers must guarantee that this is called only when * `Selection` is collapsed. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteAroundCollapsedSelection( nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers); /** * HandleDeleteNonCollapsedSelection() handles deletion with non-collapsed * `Selection`. Callers must guarantee that this is called only when * `Selection` is NOT collapsed. * * @param aDirectionAndAmount Direction of the deletion. * @param aStripWrappers Must be eStrip or eNoStrip. * @param aSelectionWasCollpased If the caller extended `Selection` * from collapsed, set this to `Yes`. * Otherwise, i.e., `Selection` is not * collapsed from the beginning, set * this to `No`. */ enum class SelectionWasCollapsed { Yes, No }; [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteNonCollapsedSelection( nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers, SelectionWasCollapsed aSelectionWasCollapsed); /** * DeleteElementsExceptTableRelatedElements() removes elements except * table related elements (except
,
itself) and their contents * from the DOM tree. * * @param aNode If this is not a table related element, this * node will be removed from the DOM tree. * Otherwise, this method calls itself recursively * with its children. * */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DeleteElementsExceptTableRelatedElements(nsINode& aNode); /** * HandleDeleteSelectionInternal() is a helper method of * HandleDeleteSelection(). This can be called recursively by the helper * methods. * NOTE: This method creates SelectionBatcher. Therefore, each caller * needs to check if the editor is still available even if this returns * NS_OK. */ [[nodiscard]] MOZ_CAN_RUN_SCRIPT EditActionResult HandleDeleteSelectionInternal(nsIEditor::EDirection aDirectionAndAmount, nsIEditor::EStripWrappers aStripWrappers); /** * This method handles "delete selection" commands. * NOTE: Don't call this method recursively from the helper methods since * when nobody handled it without canceling and returing an error, * this falls it back to `DeleteSelectionWithTransaction()`. * * @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; /** * 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) { ErrorResult error; CollapseSelectionTo(aPoint, error); return error.StealNSResult(); } template MOZ_CAN_RUN_SCRIPT MOZ_NEVER_INLINE_DEBUG void CollapseSelectionTo( const EditorDOMPointBase& aPoint, ErrorResult& aRv) { MOZ_ASSERT(IsEditActionDataAvailable()); MOZ_ASSERT(!aRv.Failed()); SelectionRefPtr()->Collapse(aPoint, aRv); if (NS_WARN_IF(Destroyed())) { aRv = NS_ERROR_EDITOR_DESTROYED; return; } NS_WARNING_ASSERTION(!aRv.Failed(), "Selection::Collapse() 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) { 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 CellAndIndexes; 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. */ CellIndexes(Element& aCellElement, ErrorResult& aRv) : mRow(-1), mColumn(-1) { MOZ_ASSERT(!aRv.Failed()); Update(aCellElement, aRv); } /** * Update mRowIndex and mColumnIndex with indexes of aCellElement. * * @param See above. */ void Update(Element& aCellElement, 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. */ 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. */ 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 CellAndIndexes; friend struct CellData; }; struct MOZ_STACK_CLASS CellAndIndexes final { RefPtr mElement; CellIndexes mIndexes; /** * This constructor initializes the members with cell element which is * selected by first range of the Selection. Note that even if the * first range is in the cell element, this does not treat it as the * cell element is selected. */ CellAndIndexes(HTMLEditor& aHTMLEditor, Selection& aSelection, ErrorResult& aRv) { Update(aHTMLEditor, aSelection, aRv); } /** * Update mElement and mIndexes with cell element which is selected by * first range of the Selection. Note that even if the first range is * in the cell element, this does not treat it as the cell element is * selected. */ void Update(HTMLEditor& aHTMLEditor, Selection& aSelection, ErrorResult& aRv); }; 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); /** * 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); static nsresult GetCellFromRange(nsRange* aRange, Element** aCell); /** * 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) 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); /** * Returns TRUE if sheet was loaded, false if it wasn't. */ bool EnableExistingStyleSheet(const nsAString& aURL); /** * GetStyleSheetForURL() returns a pointer to StyleSheet which was added * with AddOverrideStyleSheetInternal(). If it's not found, returns nullptr. * * @param aURL URL to the style sheet. */ StyleSheet* GetStyleSheetForURL(const nsAString& aURL); /** * Add a url + known style sheet to the internal lists. */ nsresult AddNewStyleSheetToList(const nsAString& aURL, StyleSheet* aStyleSheet); /** * Removes style sheet from the internal lists. * * @param aURL URL to the style sheet. * @return If the URL is in the internal list, returns the * removed style sheet. Otherwise, i.e., not found, * nullptr. */ already_AddRefed RemoveStyleSheetFromList(const nsAString& aURL); /** * Add and apply the style sheet synchronously. * * @param aURL URL to the style sheet. */ nsresult AddOverrideStyleSheetInternal(const nsAString& aURL); /** * Remove the style sheet from this editor synchronously. * * @param aURL URL to the style sheet. * @return Even if there is no specified style sheet in the * internal lists, this returns NS_OK. */ nsresult RemoveOverrideStyleSheetInternal(const nsAString& aURL); /** * Enable or disable the style sheet synchronously. * aURL is just a key to specify a style sheet in the internal array. * I.e., the style sheet has already been registered with * AddOverrideStyleSheetInternal(). * * @param aURL URL to the style sheet. * @param aEnable true if enable the style sheet. false if disable it. */ void EnableStyleSheetInternal(const nsAString& aURL, bool aEnable); /** * 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); 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. */ 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(); static Element* GetEnclosingTable(nsINode* aNode); // 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. */ 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; nsresult PrepareHTMLTransferable(nsITransferable** aTransferable); 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. */ MOZ_CAN_RUN_SCRIPT nsresult InsertFromDataTransfer( dom::DataTransfer* aDataTransfer, int32_t aIndex, Document* aSourceDoc, const EditorDOMPoint& aDroppedAt, bool aDoDeleteSelection); bool HavePrivateHTMLFlavor(nsIClipboard* clipboard); nsresult ParseCFHTML(nsCString& aCfhtml, char16_t** aStuffToPaste, char16_t** aCfcontext); nsresult StripFormattingNodes(nsIContent& aNode, bool aOnlyList = false); nsresult CreateDOMFragmentFromPaste( const nsAString& aInputString, const nsAString& aContextStr, const nsAString& aInfoStr, nsCOMPtr* aOutFragNode, nsCOMPtr* aOutStartNode, nsCOMPtr* aOutEndNode, int32_t* aOutStartOffset, int32_t* aOutEndOffset, bool aTrustedInput); nsresult ParseFragment(const nsAString& aStr, nsAtom* aContextLocalName, Document* aTargetDoc, dom::DocumentFragment** aFragment, bool aTrustedInput); /** * CollectTopMostChildContentsCompletelyInRange() collects topmost child * contents which are completely in the given range. * For example, if the range points a node with its container node, the * result is only the node (meaning does not include its descendants). * If the range starts start of a node and ends end of it, and if the node * does not have children, returns no nodes, otherwise, if the node has * some children, the result includes its all children (not including their * descendants). * * @param aStartPoint Start point of the range. * @param aEndPoint End point of the range. * @param aOutArrayOfContents [Out] Topmost children which are completely in * the range. */ static void CollectTopMostChildNodesCompletelyInRange( const EditorRawDOMPoint& aStartPoint, const EditorRawDOMPoint& aEndPoint, nsTArray>& aOutArrayOfContents); /** * AutoHTMLFragmentBoundariesFixer fixes both edges of topmost child nodes * which are created with SubtreeContentIterator. */ class MOZ_STACK_CLASS AutoHTMLFragmentBoundariesFixer final { public: /** * @param aArrayOfTopMostChildContents * [in/out] The topmost child nodes 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 insertted 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 `CollectListAndTableRelatedElementsAt()` and * `GetMostAncestorListOrTableElement()`. 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; /** * CollectListAndTableRelatedElementsAt() collects list elements and * table related elements from aNode (meaning aNode may be in the first of * the result) to the root element. */ void CollectListAndTableRelatedElementsAt( nsIContent& aContent, nsTArray>& aOutArrayOfListAndTableElements) const; /** * GetMostAncestorListOrTableElement() returns a list or a `
` * element which is in aArrayOfListAndTableElements and they are * actually valid ancestor of at least one of aArrayOfTopMostChildContents. */ Element* GetMostAncestorListOrTableElement( const nsTArray>& aArrayOfTopMostChildContents, const nsTArray>& aArrayOfListAndTableRelatedElements) const; /** * 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); /** * 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; /** * 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 aElement [IN] the element * @param aX [IN] the x position in pixels. * @param aY [IN] the y position in pixels. */ MOZ_CAN_RUN_SCRIPT void SetTopAndLeft(Element& aElement, 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); MOZ_CAN_RUN_SCRIPT void SetAnonymousElementPosition(int32_t aX, int32_t aY, Element* aResizer); 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); 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(); MOZ_CAN_RUN_SCRIPT void SetFinalSize(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 */ MOZ_CAN_RUN_SCRIPT void SetZIndex(Element& aElement, int32_t aZorder); /** * 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 EditorBase::IsTextNode(&aNode) && IsEmptyNode(aNode); } MOZ_CAN_RUN_SCRIPT bool IsSimpleModifiableNode(nsIContent* aContent, 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; bool mCRInParagraphCreatesParagraph; bool mCSSAware; UniquePtr mCSSEditUtils; // mSelectedCellIndex is reset by GetFirstSelectedTableCellElement(), // then, it'll be referred and incremented by // GetNextSelectedTableCellElement(). mutable uint32_t mSelectedCellIndex; // Maintain a list of associated style sheets and their urls. nsTArray mStyleSheetURLs; nsTArray> mStyleSheets; // 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; ParagraphSeparator mDefaultParagraphSeparator; friend class AlignStateAtSelection; friend class AutoSelectionSetterAfterTableEdit; friend class AutoSetTemporaryAncestorLimiter; friend class CSSEditUtils; friend class EditorBase; friend class EmptyEditableFunctor; friend class ListElementSelectionState; friend class ListItemElementSelectionState; friend class ParagraphStateAtSelection; friend class SlurpBlobEventListener; friend class TextEditor; friend class WSRunObject; 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