diff options
Diffstat (limited to 'editor/libeditor/HTMLEditor.h')
| -rw-r--r-- | editor/libeditor/HTMLEditor.h | 4726 |
1 files changed, 4726 insertions, 0 deletions
diff --git a/editor/libeditor/HTMLEditor.h b/editor/libeditor/HTMLEditor.h new file mode 100644 index 0000000000..2a31ead29d --- /dev/null +++ b/editor/libeditor/HTMLEditor.h @@ -0,0 +1,4726 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_HTMLEditor_h +#define mozilla_HTMLEditor_h + +#include "mozilla/Attributes.h" +#include "mozilla/ComposerCommandsUpdater.h" +#include "mozilla/EditorBase.h" +#include "mozilla/EditorForwards.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/ManualNAC.h" +#include "mozilla/Result.h" +#include "mozilla/dom/BlobImpl.h" +#include "mozilla/dom/Element.h" +#include "mozilla/dom/File.h" + +#include "nsAttrName.h" +#include "nsCOMPtr.h" +#include "nsIDocumentObserver.h" +#include "nsIDOMEventListener.h" +#include "nsIEditorMailSupport.h" +#include "nsIHTMLAbsPosEditor.h" +#include "nsIHTMLEditor.h" +#include "nsIHTMLInlineTableEditor.h" +#include "nsIHTMLObjectResizer.h" +#include "nsIPrincipal.h" +#include "nsITableEditor.h" +#include "nsPoint.h" +#include "nsStubMutationObserver.h" + +#include <functional> + +class nsDocumentFragment; +class nsFrameSelection; +class nsHTMLDocument; +class nsITransferable; +class nsIClipboard; +class nsRange; +class nsStaticAtom; +class nsStyledElement; +class nsTableCellFrame; +class nsTableWrapperFrame; +template <class E> +class nsTArray; + +namespace mozilla { +class AlignStateAtSelection; +class AutoSelectionSetterAfterTableEdit; +class AutoSetTemporaryAncestorLimiter; +class EmptyEditableFunctor; +class ListElementSelectionState; +class ListItemElementSelectionState; +class ParagraphStateAtSelection; +class ResizerSelectionListener; +class Runnable; +template <class T> +class OwningNonNull; +namespace dom { +class AbstractRange; +class Blob; +class DocumentFragment; +class Event; +class HTMLBRElement; +class MouseEvent; +class StaticRange; +} // namespace dom +namespace widget { +struct IMEState; +} // namespace widget + +enum class ParagraphSeparator { div, p, br }; + +/** + * The HTML editor implementation.<br> + * Use to edit HTML document represented as a DOM tree. + */ +class HTMLEditor final : public EditorBase, + public nsIHTMLEditor, + public nsIHTMLObjectResizer, + public nsIHTMLAbsPosEditor, + public nsITableEditor, + public nsIHTMLInlineTableEditor, + public nsStubMutationObserver, + public nsIEditorMailSupport { + public: + /**************************************************************************** + * NOTE: DO NOT MAKE YOUR NEW METHODS PUBLIC IF they are called by other + * classes under libeditor except EditorEventListener and + * HTMLEditorEventListener because each public method which may fire + * eEditorInput event will need to instantiate new stack class for + * managing input type value of eEditorInput and cache some objects + * for smarter handling. In other words, when you add new root + * method to edit the DOM tree, you can make your new method public. + ****************************************************************************/ + + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLEditor, EditorBase) + + // nsStubMutationObserver overrides + NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED + NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED + NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED + NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED + + // nsIHTMLEditor methods + NS_DECL_NSIHTMLEDITOR + + // nsIHTMLObjectResizer methods (implemented in HTMLObjectResizer.cpp) + NS_DECL_NSIHTMLOBJECTRESIZER + + // nsIHTMLAbsPosEditor methods (implemented in HTMLAbsPositionEditor.cpp) + NS_DECL_NSIHTMLABSPOSEDITOR + + // nsIHTMLInlineTableEditor methods (implemented in HTMLInlineTableEditor.cpp) + NS_DECL_NSIHTMLINLINETABLEEDITOR + + // nsIEditorMailSupport methods + NS_DECL_NSIEDITORMAILSUPPORT + + // nsITableEditor methods + NS_DECL_NSITABLEEDITOR + + // nsISelectionListener overrides + NS_DECL_NSISELECTIONLISTENER + + /** + * @param aDocument The document whose content will be editable. + */ + explicit HTMLEditor(const Document& aDocument); + + /** + * @param aDocument The document whose content will be editable. + * @param aComposerCommandsUpdater The composer command updater. + * @param aFlags Some of nsIEditor::eEditor*Mask flags. + */ + MOZ_CAN_RUN_SCRIPT nsresult + Init(Document& aDocument, ComposerCommandsUpdater& aComposerCommandsUpdater, + uint32_t aFlags); + + /** + * PostCreate() should be called after Init, and is the time that the editor + * tells its documentStateObservers that the document has been created. + */ + MOZ_CAN_RUN_SCRIPT nsresult PostCreate(); + + /** + * PreDestroy() is called before the editor goes away, and gives the editor a + * chance to tell its documentStateObservers that the document is going away. + */ + MOZ_CAN_RUN_SCRIPT void PreDestroy(); + + static HTMLEditor* GetFrom(nsIEditor* aEditor) { + return aEditor ? aEditor->GetAsHTMLEditor() : nullptr; + } + static const HTMLEditor* GetFrom(const nsIEditor* aEditor) { + return aEditor ? aEditor->GetAsHTMLEditor() : nullptr; + } + + [[nodiscard]] bool GetReturnInParagraphCreatesNewParagraph() const; + + // EditorBase overrides + MOZ_CAN_RUN_SCRIPT NS_IMETHOD BeginningOfDocument() final; + MOZ_CAN_RUN_SCRIPT NS_IMETHOD EndOfDocument() final; + + NS_IMETHOD GetDocumentCharacterSet(nsACString& aCharacterSet) final; + MOZ_CAN_RUN_SCRIPT NS_IMETHOD + SetDocumentCharacterSet(const nsACString& aCharacterSet) final; + + bool IsEmpty() const final; + + bool CanPaste(int32_t aClipboardType) const final; + using EditorBase::CanPaste; + + MOZ_CAN_RUN_SCRIPT NS_IMETHOD DeleteNode(nsINode* aNode, + bool aPreseveSelection, + uint8_t aOptionalArgCount) final; + + MOZ_CAN_RUN_SCRIPT NS_IMETHOD InsertLineBreak() final; + + /** + * PreHandleMouseDown() and PreHandleMouseUp() are called before + * HTMLEditorEventListener handles them. The coming event may be + * non-acceptable event. + */ + void PreHandleMouseDown(const dom::MouseEvent& aMouseDownEvent); + void PreHandleMouseUp(const dom::MouseEvent& aMouseUpEvent); + + /** + * PreHandleSelectionChangeCommand() and PostHandleSelectionChangeCommand() + * are called before or after handling a command which may change selection + * and/or scroll position. + */ + void PreHandleSelectionChangeCommand(Command aCommand); + void PostHandleSelectionChangeCommand(Command aCommand); + + MOZ_CAN_RUN_SCRIPT nsresult + HandleKeyPressEvent(WidgetKeyboardEvent* aKeyboardEvent) final; + Element* GetFocusedElement() const final; + bool IsActiveInDOMWindow() const final; + dom::EventTarget* GetDOMEventTarget() const final; + [[nodiscard]] Element* FindSelectionRoot(const nsINode& aNode) const final; + bool IsAcceptableInputEvent(WidgetGUIEvent* aGUIEvent) const final; + nsresult GetPreferredIMEState(widget::IMEState* aState) final; + MOZ_CAN_RUN_SCRIPT nsresult + OnFocus(const nsINode& aOriginalEventTargetNode) final; + nsresult OnBlur(const dom::EventTarget* aEventTarget) final; + + /** + * Called when aDocument or aElement becomes editable without focus change. + * E.g., when the design mode is enabled or the contenteditable attribute + * is set to the focused element. + */ + MOZ_CAN_RUN_SCRIPT nsresult FocusedElementOrDocumentBecomesEditable( + Document& aDocument, Element* aElement); + + /** + * Called when aDocument or aElement becomes not editable without focus + * change. E.g., when the design mode ends or the contenteditable attribute is + * removed or set to "false". + */ + MOZ_CAN_RUN_SCRIPT static nsresult FocusedElementOrDocumentBecomesNotEditable( + HTMLEditor* aHTMLEditor, Document& aDocument, Element* aElement); + + /** + * GetBackgroundColorState() returns what the background color of the + * selection. + * + * @param aMixed true if there is more than one font color + * @param aOutColor Color string. "" is returned for none. + */ + MOZ_CAN_RUN_SCRIPT nsresult GetBackgroundColorState(bool* aMixed, + nsAString& aOutColor); + + /** + * PasteNoFormattingAsAction() pastes content in clipboard without any style + * information. + * + * @param aClipboardType nsIClipboard::kGlobalClipboard or + * nsIClipboard::kSelectionClipboard. + * @param aDispatchPasteEvent Yes if this should dispatch ePaste event + * before pasting. Otherwise, No. + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult PasteNoFormattingAsAction( + int32_t aClipboardType, DispatchPasteEvent aDispatchPasteEvent, + nsIPrincipal* aPrincipal = nullptr); + + bool CanPasteTransferable(nsITransferable* aTransferable) final; + + MOZ_CAN_RUN_SCRIPT nsresult + InsertLineBreakAsAction(nsIPrincipal* aPrincipal = nullptr) final; + + /** + * InsertParagraphSeparatorAsAction() is called when user tries to separate + * current paragraph with Enter key press in HTMLEditor or something. + * + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + InsertParagraphSeparatorAsAction(nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult + InsertElementAtSelectionAsAction(Element* aElement, bool aDeleteSelection, + nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult InsertLinkAroundSelectionAsAction( + Element* aAnchorElement, nsIPrincipal* aPrincipal = nullptr); + + /** + * CreateElementWithDefaults() creates new element whose name is + * aTagName with some default attributes are set. Note that this is a + * public utility method. I.e., just creates element, not insert it + * into the DOM tree. + * NOTE: This is available for internal use too since this does not change + * the DOM tree nor undo transactions, and does not refer Selection, + * etc. + * + * @param aTagName The new element's tag name. If the name is + * one of "href", "anchor" or "namedanchor", + * this creates an <a> element. + * @return Newly created element. + */ + MOZ_CAN_RUN_SCRIPT already_AddRefed<Element> CreateElementWithDefaults( + const nsAtom& aTagName); + + /** + * Indent or outdent content around Selection. + * + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult + IndentAsAction(nsIPrincipal* aPrincipal = nullptr); + MOZ_CAN_RUN_SCRIPT nsresult + OutdentAsAction(nsIPrincipal* aPrincipal = nullptr); + + /** + * The Document.execCommand("formatBlock") handler. + * + * @param aParagraphFormat Must not be an empty string, and the value must + * be one of address, article, aside, blockquote, + * div, footer, h1, h2, h3, h4, h5, h6, header, + * hgroup, main, nav, p, pre, selection, dt or dd. + */ + MOZ_CAN_RUN_SCRIPT nsresult FormatBlockAsAction( + const nsAString& aParagraphFormat, nsIPrincipal* aPrincipal = nullptr); + + /** + * The cmd_paragraphState command handler. + * + * @param aParagraphFormat Can be empty string. If this is empty string, + * this removes ancestor format elements. + * Otherwise, the value must be one of p, pre, + * h1, h2, h3, h4, h5, h6, address, dt or dl. + */ + MOZ_CAN_RUN_SCRIPT nsresult SetParagraphStateAsAction( + const nsAString& aParagraphFormat, nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult AlignAsAction(const nsAString& aAlignType, + nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult RemoveListAsAction( + const nsAString& aListType, nsIPrincipal* aPrincipal = nullptr); + + /** + * MakeOrChangeListAsAction() makes selected hard lines list element(s). + * + * @param aListElementTagName The new list element tag name. Must be + * nsGkAtoms::ul, nsGkAtoms::ol or + * nsGkAtoms::dl. + * @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. + */ + enum class SelectAllOfCurrentList { Yes, No }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MakeOrChangeListAsAction( + const nsStaticAtom& aListElementTagName, const nsAString& aBulletType, + SelectAllOfCurrentList aSelectAllOfCurrentList, + nsIPrincipal* aPrincipal = nullptr); + + /** + * If aTargetElement is a resizer, start to drag the resizer. Otherwise, if + * aTargetElement is the grabber, start to handle drag gester on it. + * + * @param aMouseDownEvent A `mousedown` event fired on aTargetElement. + * @param aEventTargetElement The target element being pressed. This must + * be same as explicit original event target of + * aMouseDownEvent. + */ + MOZ_CAN_RUN_SCRIPT nsresult StartToDragResizerOrHandleDragGestureOnGrabber( + dom::MouseEvent& aMouseDownEvent, Element& aEventTargetElement); + + /** + * If the editor is handling dragging a resizer, handling drag gesture on + * the grabber or dragging the grabber, this finalize it. Otherwise, + * does nothing. + * + * @param aClientPoint The final point of the drag. + */ + MOZ_CAN_RUN_SCRIPT nsresult + StopDraggingResizerOrGrabberAt(const CSSIntPoint& aClientPoint); + + /** + * If the editor is handling dragging a resizer, handling drag gesture to + * start dragging the grabber or dragging the grabber, this method updates + * it's position. + * + * @param aClientPoint The new point of the drag. + */ + MOZ_CAN_RUN_SCRIPT nsresult + UpdateResizerOrGrabberPositionTo(const CSSIntPoint& aClientPoint); + + /** + * IsCSSEnabled() returns true if this editor treats styles with style + * attribute of HTML elements. Otherwise, if this editor treats all styles + * with "font style elements" like <b>, <i>, etc, and <blockquote> to indent, + * align attribute to align contents, returns false. + */ + bool IsCSSEnabled() const { return mIsCSSPrefChecked; } + + /** + * Enable/disable object resizers for <img> elements, <table> elements, + * absolute positioned elements (required absolute position editor enabled). + */ + MOZ_CAN_RUN_SCRIPT void EnableObjectResizer(bool aEnable) { + if (mIsObjectResizingEnabled == aEnable) { + return; + } + + AutoEditActionDataSetter editActionData( + *this, EditAction::eEnableOrDisableResizer); + if (NS_WARN_IF(!editActionData.CanHandle())) { + return; + } + + mIsObjectResizingEnabled = aEnable; + RefreshEditingUI(); + } + bool IsObjectResizerEnabled() const { return mIsObjectResizingEnabled; } + + Element* GetResizerTarget() const { return mResizedObject; } + + /** + * Enable/disable inline table editor, e.g., adding new row or column, + * removing existing row or column. + */ + MOZ_CAN_RUN_SCRIPT void EnableInlineTableEditor(bool aEnable) { + if (mIsInlineTableEditingEnabled == aEnable) { + return; + } + + AutoEditActionDataSetter editActionData( + *this, EditAction::eEnableOrDisableInlineTableEditingUI); + if (NS_WARN_IF(!editActionData.CanHandle())) { + return; + } + + mIsInlineTableEditingEnabled = aEnable; + RefreshEditingUI(); + } + bool IsInlineTableEditorEnabled() const { + return mIsInlineTableEditingEnabled; + } + + /** + * Enable/disable absolute position editor, resizing absolute positioned + * elements (required object resizers enabled) or positioning them with + * dragging grabber. + */ + MOZ_CAN_RUN_SCRIPT void EnableAbsolutePositionEditor(bool aEnable) { + if (mIsAbsolutelyPositioningEnabled == aEnable) { + return; + } + + AutoEditActionDataSetter editActionData( + *this, EditAction::eEnableOrDisableAbsolutePositionEditor); + if (NS_WARN_IF(!editActionData.CanHandle())) { + return; + } + + mIsAbsolutelyPositioningEnabled = aEnable; + RefreshEditingUI(); + } + bool IsAbsolutePositionEditorEnabled() const { + return mIsAbsolutelyPositioningEnabled; + } + + /** + * returns the deepest absolutely positioned container of the selection + * if it exists or null. + */ + MOZ_CAN_RUN_SCRIPT already_AddRefed<Element> + GetAbsolutelyPositionedSelectionContainer() const; + + Element* GetPositionedElement() const { return mAbsolutelyPositionedObject; } + + /** + * extracts the selection from the normal flow of the document and + * positions it. + * + * @param aEnabled [IN] true to absolutely position the selection, + * false to put it back in the normal flow + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult SetSelectionToAbsoluteOrStaticAsAction( + bool aEnabled, nsIPrincipal* aPrincipal = nullptr); + + /** + * returns the absolute z-index of a positioned element. Never returns 'auto' + * @return the z-index of the element + * @param aElement [IN] the element. + */ + MOZ_CAN_RUN_SCRIPT int32_t GetZIndex(Element& aElement); + + /** + * adds aChange to the z-index of the currently positioned element. + * + * @param aChange [IN] relative change to apply to current z-index + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult + AddZIndexAsAction(int32_t aChange, nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult SetBackgroundColorAsAction( + const nsAString& aColor, nsIPrincipal* aPrincipal = nullptr); + + /** + * SetInlinePropertyAsAction() sets a property which changes inline style of + * text. E.g., bold, italic, super and sub. + * This automatically removes exclusive style, however, treats all changes + * as a transaction. + * + * @param aPrincipal Set subject principal if it may be called by + * JS. If set to nullptr, will be treated as + * called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertyAsAction( + nsStaticAtom& aProperty, nsStaticAtom* aAttribute, + const nsAString& aValue, nsIPrincipal* aPrincipal = nullptr); + + /** + * GetInlineProperty() gets aggregate properties of the current selection. + * All object in the current selection are scanned and their attributes are + * represented in a list of Property object. + * TODO: Make this return Result<Something> instead of bool out arguments. + * + * @param aHTMLProperty the property to get on the selection + * @param aAttribute the attribute of the property, if applicable. + * May be null. + * Example: aHTMLProperty=nsGkAtoms::font, + * aAttribute=nsGkAtoms::color + * @param aValue if aAttribute is not null, the value of the + * attribute. May be null. + * Example: aHTMLProperty=nsGkAtoms::font, + * aAttribute=nsGkAtoms::color, + * aValue="0x00FFFF" + * @param aFirst [OUT] true if the first text node in the + * selection has the property + * @param aAny [OUT] true if any of the text nodes in the + * selection have the property + * @param aAll [OUT] true if all of the text nodes in the + * selection have the property + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetInlineProperty( + nsStaticAtom& aHTMLProperty, nsAtom* aAttribute, const nsAString& aValue, + bool* aFirst, bool* aAny, bool* aAll) const; + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetInlinePropertyWithAttrValue( + nsStaticAtom& aHTMLProperty, nsAtom* aAttribute, const nsAString& aValue, + bool* aFirst, bool* aAny, bool* aAll, nsAString& outValue); + + /** + * RemoveInlinePropertyAsAction() removes a property which changes inline + * style of text. E.g., bold, italic, super and sub. + * + * @param aHTMLProperty Tag name whcih represents the inline style you want + * to remove. E.g., nsGkAtoms::strong, nsGkAtoms::b, + * etc. If nsGkAtoms::href, <a> element which has + * href attribute will be removed. + * If nsGkAtoms::name, <a> element which has non-empty + * name attribute will be removed. + * @param aAttribute If aHTMLProperty is nsGkAtoms::font, aAttribute should + * be nsGkAtoms::fase, nsGkAtoms::size, nsGkAtoms::color + * or nsGkAtoms::bgcolor. Otherwise, set nullptr. + * Must not use nsGkAtoms::_empty here. + * @param aPrincipal Set subject principal if it may be called by JS. If + * set to nullptr, will be treated as called by system. + */ + MOZ_CAN_RUN_SCRIPT nsresult RemoveInlinePropertyAsAction( + nsStaticAtom& aHTMLProperty, nsStaticAtom* aAttribute, + nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult + RemoveAllInlinePropertiesAsAction(nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult + IncreaseFontSizeAsAction(nsIPrincipal* aPrincipal = nullptr); + + MOZ_CAN_RUN_SCRIPT nsresult + DecreaseFontSizeAsAction(nsIPrincipal* aPrincipal = nullptr); + + /** + * GetFontColorState() returns foreground color information in first + * range of Selection. + * If first range of Selection is collapsed and there is a cache of style for + * new text, aIsMixed is set to false and aColor is set to the cached color. + * If first range of Selection is collapsed and there is no cached color, + * this returns the color of the node, aIsMixed is set to false and aColor is + * set to the color. + * If first range of Selection is not collapsed, this collects colors of + * each node in the range. If there are two or more colors, aIsMixed is set + * to true and aColor is truncated. If only one color is set to all of the + * range, aIsMixed is set to false and aColor is set to the color. + * If there is no Selection ranges, aIsMixed is set to false and aColor is + * truncated. + * + * @param aIsMixed Must not be nullptr. This is set to true + * if there is two or more colors in first + * range of Selection. + * @param aColor Returns the color if only one color is set to + * all of first range in Selection. Otherwise, + * returns empty string. + * @return Returns error only when illegal cases, e.g., + * Selection instance has gone, first range + * Selection is broken. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + GetFontColorState(bool* aIsMixed, nsAString& aColor); + + /** + * Detach aComposerCommandsUpdater from this. + */ + void Detach(const ComposerCommandsUpdater& aComposerCommandsUpdater); + + nsStaticAtom& DefaultParagraphSeparatorTagName() const { + return HTMLEditor::ToParagraphSeparatorTagName(mDefaultParagraphSeparator); + } + ParagraphSeparator GetDefaultParagraphSeparator() const { + return mDefaultParagraphSeparator; + } + void SetDefaultParagraphSeparator(ParagraphSeparator aSep) { + mDefaultParagraphSeparator = aSep; + } + static nsStaticAtom& ToParagraphSeparatorTagName( + ParagraphSeparator aSeparator) { + switch (aSeparator) { + case ParagraphSeparator::div: + return *nsGkAtoms::div; + case ParagraphSeparator::p: + return *nsGkAtoms::p; + case ParagraphSeparator::br: + return *nsGkAtoms::br; + default: + MOZ_ASSERT_UNREACHABLE("New paragraph separator isn't handled here"); + return *nsGkAtoms::div; + } + } + + /** + * Modifies the table containing the selection according to the + * activation of an inline table editing UI element + * @param aUIAnonymousElement [IN] the inline table editing UI element + */ + MOZ_CAN_RUN_SCRIPT nsresult + DoInlineTableEditingAction(const Element& aUIAnonymousElement); + + /** + * GetInclusiveAncestorByTagName() looks for an element node whose name + * matches aTagName from aNode or anchor node of Selection to <body> element. + * + * @param aTagName The tag name which you want to look for. + * Must not be nsGkAtoms::_empty. + * If nsGkAtoms::list, the result may be <ul>, <ol> or + * <dl> element. + * If nsGkAtoms::td, the result may be <td> or <th>. + * If nsGkAtoms::href, the result may be <a> element + * which has "href" attribute with non-empty value. + * If nsGkAtoms::anchor, the result may be <a> which + * has "name" attribute with non-empty value. + * @param aContent Start node to look for the result. + * @return If an element which matches aTagName, returns + * an Element. Otherwise, nullptr. + */ + Element* GetInclusiveAncestorByTagName(const nsStaticAtom& aTagName, + nsIContent& aContent) const; + + /** + * Compute editing host for aContent. If this editor isn't active in the DOM + * window, this returns nullptr. + */ + enum class LimitInBodyElement { No, Yes }; + [[nodiscard]] Element* ComputeEditingHost( + const nsIContent& aContent, + LimitInBodyElement aLimitInBodyElement = LimitInBodyElement::Yes) const { + return ComputeEditingHostInternal(&aContent, aLimitInBodyElement); + } + + /** + * Compute editing host for the focus node of the Selection. If this editor + * isn't active in the DOM window, this returns nullptr. + */ + [[nodiscard]] Element* ComputeEditingHost( + LimitInBodyElement aLimitInBodyElement = LimitInBodyElement::Yes) const { + return ComputeEditingHostInternal(nullptr, aLimitInBodyElement); + } + + /** + * Return true if we're in designMode. + */ + bool IsInDesignMode() const; + + /** + * Return true if entire the document is editable (although the document + * may have non-editable nodes, e.g., + * <body contenteditable><div contenteditable="false"></div></body> + */ + bool EntireDocumentIsEditable() const; + + /** + * Basically, this always returns true if we're for `contenteditable` or + * `designMode` editor in web apps. However, e.g., Composer of SeaMonkey + * can make the editor not tabbable. + */ + bool IsTabbable() const { return IsInteractionAllowed(); } + + /** + * NotifyEditingHostMaybeChanged() is called when new element becomes + * contenteditable when the document already had contenteditable elements. + */ + void NotifyEditingHostMaybeChanged(); + + /** Insert a string as quoted text + * (whose representation is dependant on the editor type), + * replacing the selected text (if any). + * + * @param aQuotedText The actual text to be quoted + * @parem aNodeInserted Return the node which was inserted. + */ + MOZ_CAN_RUN_SCRIPT // USED_BY_COMM_CENTRAL + nsresult + InsertAsQuotation(const nsAString& aQuotedText, nsINode** aNodeInserted); + + MOZ_CAN_RUN_SCRIPT nsresult InsertHTMLAsAction( + const nsAString& aInString, nsIPrincipal* aPrincipal = nullptr); + + /** + * Refresh positions of resizers. If you change size of target of resizers, + * you need to refresh position of resizers with calling this. + */ + MOZ_CAN_RUN_SCRIPT nsresult RefreshResizers(); + + bool IsWrapHackEnabled() const { + return (mFlags & nsIEditor::eEditorEnableWrapHackMask) != 0; + } + + /** + * Return true if this is in the plaintext mail composer mode of + * Thunderbird or something. + * NOTE: This is different from contenteditable="plaintext-only" + */ + bool IsPlaintextMailComposer() const { + const bool isPlaintextMode = + (mFlags & nsIEditor::eEditorPlaintextMask) != 0; + MOZ_ASSERT_IF(IsTextEditor(), isPlaintextMode); + return isPlaintextMode; + } + + protected: // May be called by friends. + /**************************************************************************** + * Some friend classes are allowed to call the following protected methods. + * However, those methods won't prepare caches of some objects which are + * necessary for them. So, if you call them from friend classes, you need + * to make sure that AutoEditActionDataSetter is created. + ****************************************************************************/ + + /** + * InsertBRElement() creates a <br> element and inserts it before + * aPointToInsert. + * + * @param aWithTransaction Whether the inserting is new element is undoable + * or not. WithTransaction::No is useful only when + * the new element is inserted into a new element + * which has not been connected yet. + * @param aPointToInsert The DOM point where should be <br> node inserted + * before. + * @param aSelect If eNone, returns a point to put caret which is + * suggested by InsertNodeTransaction. + * If eNext, returns a point after the new <br> + * element. + * If ePrevious, returns a point at the new <br> + * element. + * @return The new <br> node and suggesting point to put + * caret which respects aSelect. + */ + MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> InsertBRElement( + WithTransaction aWithTransaction, const EditorDOMPoint& aPointToInsert, + EDirection aSelect = eNone); + + /** + * Delete text in the range in aTextNode. If aTextNode is not editable, this + * does nothing. + * + * @param aTextNode The text node which should be modified. + * @param aOffset Start offset of removing text in aTextNode. + * @param aLength Length of removing text. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult> + DeleteTextWithTransaction(dom::Text& aTextNode, uint32_t aOffset, + uint32_t aLength); + + /** + * Replace text in the range with aStringToInsert. If there is a DOM range + * exactly same as the replacing range, it'll be collapsed to + * {aTextNode, aOffset} because of the order of deletion and insertion. + * Therefore, the callers may need to handle `Selection` even when callers + * do not want to update `Selection`. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertTextResult, nsresult> + ReplaceTextWithTransaction(dom::Text& aTextNode, uint32_t aOffset, + uint32_t aLength, + const nsAString& aStringToInsert); + + /** + * Insert aStringToInsert to aPointToInsert. If the point is not editable, + * this returns error. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertTextResult, nsresult> + InsertTextWithTransaction(Document& aDocument, + const nsAString& aStringToInsert, + const EditorDOMPoint& aPointToInsert) final; + + /** + * CopyLastEditableChildStyles() clones inline container elements into + * aPreviousBlock to aNewBlock to keep using same style in it. + * + * @param aPreviousBlock The previous block element. All inline + * elements which are last sibling of each level + * are cloned to aNewBlock. + * @param aNewBlock New block container element. All children of + * this is deleted first. + * @param aEditingHost The editing host. + * @return If succeeded, returns a suggesting point to put + * caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + CopyLastEditableChildStylesWithTransaction(Element& aPreviousBlock, + Element& aNewBlock, + const Element& aEditingHost); + + /** + * RemoveBlockContainerWithTransaction() removes aElement from the DOM tree + * but moves its all children to its parent node and if its parent needs <br> + * element to have at least one line-height, this inserts <br> element + * automatically. + * + * @param aElement Block element to be removed. + * @return If succeeded, returns a suggesting point to put + * caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + RemoveBlockContainerWithTransaction(Element& aElement); + + MOZ_CAN_RUN_SCRIPT nsresult RemoveAttributeOrEquivalent( + Element* aElement, nsAtom* aAttribute, bool aSuppressTransaction) final; + MOZ_CAN_RUN_SCRIPT nsresult SetAttributeOrEquivalent( + Element* aElement, nsAtom* aAttribute, const nsAString& aValue, + bool aSuppressTransaction) final; + using EditorBase::RemoveAttributeOrEquivalent; + using EditorBase::SetAttributeOrEquivalent; + + /** + * Returns container element of ranges in Selection. If Selection is + * collapsed, returns focus container node (or its parent element). + * If Selection selects only one element node, returns the element node. + * If Selection is only one range, returns common ancestor of the range. + * XXX If there are two or more Selection ranges, this returns parent node + * of start container of a range which starts with different node from + * start container of the first range. + */ + Element* GetSelectionContainerElement() const; + + /** + * DeleteTableCellContentsWithTransaction() removes any contents in cell + * elements. If two or more cell elements are selected, this removes + * all selected cells' contents. Otherwise, this removes contents of + * a cell which contains first selection range. This does not return + * error even if selection is not in cell element, just does nothing. + */ + MOZ_CAN_RUN_SCRIPT nsresult DeleteTableCellContentsWithTransaction(); + + /** + * extracts an element from the normal flow of the document and + * positions it, and puts it back in the normal flow. + * @param aElement [IN] the element + * @param aEnabled [IN] true to absolutely position the element, + * false to put it back in the normal flow + */ + MOZ_CAN_RUN_SCRIPT nsresult SetPositionToAbsoluteOrStatic(Element& aElement, + bool aEnabled); + + /** + * adds aChange to the z-index of an arbitrary element. + * @param aElement [IN] the element + * @param aChange [IN] relative change to apply to current z-index of + * the element + * @return The new z-index of the element + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<int32_t, nsresult> + AddZIndexWithTransaction(nsStyledElement& aStyledElement, int32_t aChange); + + /** + * Join together any adjacent editable text nodes in the range. + */ + MOZ_CAN_RUN_SCRIPT nsresult CollapseAdjacentTextNodes(nsRange& aRange); + + static dom::Element* GetLinkElement(nsINode* aNode); + + /** + * Helper routines for font size changing. + */ + enum class FontSize { incr, decr }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + SetFontSizeOnTextNode(Text& aTextNode, uint32_t aStartOffset, + uint32_t aEndOffset, FontSize aIncrementOrDecrement); + + enum class SplitAtEdges { + // SplitNodeDeepWithTransaction() won't split container element + // nodes at their edges. I.e., when split point is start or end of + // container, it won't be split. + eDoNotCreateEmptyContainer, + // SplitNodeDeepWithTransaction() always splits containers even + // if the split point is at edge of a container. E.g., if split point is + // start of an inline element, empty inline element is created as a new left + // node. + eAllowToCreateEmptyContainer, + }; + + /** + * SplitAncestorStyledInlineElementsAtRangeEdges() splits all ancestor inline + * elements in the block at aRange if given style matches with some of them. + * + * @param aRange Ancestor inline elements of the start and end + * boundaries will be split. + * @param aStyle The style which you want to split. + * RemoveAllStyles instance is allowed to split any + * inline elements. + * @param aSplitAtEdges Whether this should split elements at start or + * end of inline elements or not. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitRangeOffResult, nsresult> + SplitAncestorStyledInlineElementsAtRangeEdges(const EditorDOMRange& aRange, + const EditorInlineStyle& aStyle, + SplitAtEdges aSplitAtEdges); + + /** + * SplitAncestorStyledInlineElementsAt() splits ancestor inline elements at + * aPointToSplit if specified style matches with them. + * + * @param aPointToSplit The point to split style at. + * @param aStyle The style which you want to split. + * RemoveAllStyles instance is allowed to split any + * inline elements. + * @param aSplitAtEdges Whether this should split elements at start or + * end of inline elements or not. + * @return The result of SplitNodeDeepWithTransaction() + * with topmost split element. If this didn't + * find inline elements to be split, Handled() + * returns false. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + SplitAncestorStyledInlineElementsAt(const EditorDOMPoint& aPointToSplit, + const EditorInlineStyle& aStyle, + SplitAtEdges aSplitAtEdges); + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetInlinePropertyBase( + const EditorInlineStyle& aStyle, const nsAString* aValue, bool* aFirst, + bool* aAny, bool* aAll, nsAString* outValue) const; + + /** + * ClearStyleAt() splits parent elements to remove the specified style. + * If this splits some parent elements at near their start or end, such + * empty elements will be removed. Then, remove the specified style + * from the point and returns DOM point to put caret. + * + * @param aPoint The point to clear style at. + * @param aStyleToRemove The style which you want to clear. + * @param aSpecifiedStyle Whether the class and style attributes should + * be preserved or discarded. + * @return A candidate position to put caret. If there is + * AutoTransactionsConserveSelection instances, this stops + * suggesting caret point only in some cases. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + ClearStyleAt(const EditorDOMPoint& aPoint, + const EditorInlineStyle& aStyleToRemove, + SpecifiedStyle aSpecifiedStyle); + + MOZ_CAN_RUN_SCRIPT nsresult SetPositionToAbsolute(Element& aElement); + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetPositionToStatic(Element& aElement); + + /** + * OnModifyDocument() is called when the editor is changed. This should + * be called only by runnable in HTMLEditor::OnDocumentModified() to call + * HTMLEditor::OnModifyDocument() with AutoEditActionDataSetter instance. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult OnModifyDocument(); + + /** + * DoSplitNode() inserts aNewNode and moves all content before or after + * aStartOfRightNode to aNewNode. + * + * @param aStartOfRightNode The point to split. The container will keep + * having following or previous content of this. + * @param aNewNode The new node called. The previous or following + * content of aStartOfRightNode will be moved into + * this node. + */ + MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> DoSplitNode( + const EditorDOMPoint& aStartOfRightNode, nsIContent& aNewNode); + + /** + * DoJoinNodes() merges contents in aContentToRemove to aContentToKeep and + * remove aContentToRemove from the DOM tree. aContentToRemove and + * aContentToKeep must have same parent. Additionally, if one of + * aContentToRemove or aContentToKeep is a text node, the other must be a + * text node. + * + * @param aContentToKeep The node that will remain after the join. + * @param aContentToRemove The node that will be joined with aContentToKeep. + * There is no requirement that the two nodes be of + * the same type. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + DoJoinNodes(nsIContent& aContentToKeep, nsIContent& aContentToRemove); + + /** + * Routines for managing the preservation of selection across + * various editor actions. + */ + bool ArePreservingSelection() const; + void PreserveSelectionAcrossActions(); + MOZ_CAN_RUN_SCRIPT nsresult RestorePreservedSelection(); + void StopPreservingSelection(); + + /** + * Called when JoinNodesTransaction::DoTransaction() did its transaction. + * Note that this is not called when undoing nor redoing. + * + * @param aTransaction The transaction which did join nodes. + * @param aDoJoinNodesResult Result of the doing join nodes. + */ + MOZ_CAN_RUN_SCRIPT void DidJoinNodesTransaction( + const JoinNodesTransaction& aTransaction, nsresult aDoJoinNodesResult); + + protected: // edit sub-action handler + /** + * CanHandleHTMLEditSubAction() checks whether there is at least one + * selection range or not, and whether the first range is editable. + * If it's not editable, `Canceled()` of the result returns true. + * If `Selection` is in odd situation, returns an error. + * + * XXX I think that `IsSelectionEditable()` is better name, but it's already + * in `EditorBase`... + */ + enum class CheckSelectionInReplacedElement { Yes, OnlyWhenNotInSameNode }; + Result<EditActionResult, nsresult> CanHandleHTMLEditSubAction( + CheckSelectionInReplacedElement aCheckSelectionInReplacedElement = + CheckSelectionInReplacedElement::Yes) const; + + /** + * EnsureCaretNotAfterInvisibleBRElement() makes sure that caret is NOT after + * padding `<br>` element for preventing insertion after padding `<br>` + * element at empty last line. + * NOTE: This method should be called only when `Selection` is collapsed + * because `Selection` is a pain to work with when not collapsed. + * (no good way to extend start or end of selection), so we need to + * ignore those types of selections. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + EnsureCaretNotAfterInvisibleBRElement(); + + /** + * MaybeCreatePaddingBRElementForEmptyEditor() creates padding <br> element + * for empty editor if there is no children. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + MaybeCreatePaddingBRElementForEmptyEditor(); + + /** + * EnsureNoPaddingBRElementForEmptyEditor() removes padding <br> element + * for empty editor if there is. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + EnsureNoPaddingBRElementForEmptyEditor(); + + /** + * ReflectPaddingBRElementForEmptyEditor() scans the tree from the root + * element and sets mPaddingBRElementForEmptyEditor if exists, or otherwise + * nullptr. Can be used to manage undo/redo. + */ + [[nodiscard]] nsresult ReflectPaddingBRElementForEmptyEditor(); + + /** + * PrepareInlineStylesForCaret() consider inline styles from top level edit + * sub-action and setting it to `mPendingStylesToApplyToNewContent` and clear + * inline style cache if necessary. + * NOTE: This method should be called only when `Selection` is collapsed. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult PrepareInlineStylesForCaret(); + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + HandleInsertText(EditSubAction aEditSubAction, + const nsAString& aInsertionString, + SelectionHandling aSelectionHandling) final; + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertDroppedDataTransferAsAction( + AutoEditActionDataSetter& aEditActionData, + dom::DataTransfer& aDataTransfer, const EditorDOMPoint& aDroppedAt, + nsIPrincipal* aSourcePrincipal) final; + + /** + * GetInlineStyles() retrieves the style of aElement and modifies each item of + * aPendingStyleCacheArray. This might cause flushing layout at retrieving + * computed values of CSS properties. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetInlineStyles( + Element& aElement, AutoPendingStyleCacheArray& aPendingStyleCacheArray); + + /** + * CacheInlineStyles() caches style of aElement into mCachedPendingStyles of + * TopLevelEditSubAction. This may cause flushing layout at retrieving + * computed value of CSS properties. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + CacheInlineStyles(Element& aElement); + + /** + * ReapplyCachedStyles() restores some styles which are disappeared during + * handling edit action and it should be restored. This may cause flushing + * layout at retrieving computed value of CSS properties. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ReapplyCachedStyles(); + + /** + * CreateStyleForInsertText() sets CSS properties which are stored in + * PendingStyles to proper element node. + * + * @param aPointToInsertText The point to insert text. + * @param aEditingHost The editing host. + * @return A suggest point to put caret or unset point. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + CreateStyleForInsertText(const EditorDOMPoint& aPointToInsertText, + const Element& aEditingHost); + + /** + * GetMostDistantAncestorMailCiteElement() returns most-ancestor mail cite + * element. "mail cite element" is <pre> element when it's in plaintext editor + * mode or an element with which calling HTMLEditUtils::IsMailCite() returns + * true. + * + * @param aNode The start node to look for parent mail cite elements. + */ + Element* GetMostDistantAncestorMailCiteElement(const nsINode& aNode) const; + + /** + * HandleInsertParagraphInMailCiteElement() splits aMailCiteElement at + * aPointToSplit. + * + * @param aMailCiteElement The mail-cite element which should be split. + * @param aPointToSplit The point to split. + * @param aEditingHost The editing host. + * @return Candidate caret position where is at inserted + * <br> element into the split point. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + HandleInsertParagraphInMailCiteElement(Element& aMailCiteElement, + const EditorDOMPoint& aPointToSplit, + const Element& aEditingHost); + + /** + * HandleInsertBRElement() inserts a <br> element into aPointToBreak. + * This may split container elements at the point and/or may move following + * <br> element to immediately after the new <br> element if necessary. + * + * @param aPointToBreak The point where new <br> element will be + * inserted before. + * @param aEditingHost Current active editing host. + * @return If succeeded, returns new <br> element and + * candidate caret point. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + HandleInsertBRElement(const EditorDOMPoint& aPointToBreak, + const Element& aEditingHost); + + /** + * HandleInsertLinefeed() inserts a linefeed character into aInsertToBreak. + * + * @param aInsertToBreak The point where new linefeed character will be + * inserted before. + * @param aEditingHost Current active editing host. + * @return A suggest point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + HandleInsertLinefeed(const EditorDOMPoint& aInsertToBreak, + const Element& aEditingHost); + + /** + * Splits inclusive inline ancestors at both start and end of aRangeItem. If + * this splits at every point, this modifies aRangeItem to point each split + * point (typically, at right node). + * + * @param aRangeItem [in/out] One or two DOM points where should be + * split. Will be modified to split point if + * they're split. + * @param aBlockInlineCheck [in] Whether this method considers block vs. + * inline with computed style or the default style. + * @param aEditingHost [in] The editing host. + * @param aAncestorLimiter [in/optional] If specified, this stops splitting + * ancestors when meets this node. + * @return A suggest point to put caret if succeeded, but + * it may be unset. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + SplitInlineAncestorsAtRangeBoundaries( + RangeItem& aRangeItem, BlockInlineCheck aBlockInlineCheck, + const Element& aEditingHost, + const nsIContent* aAncestorLimiter = nullptr); + + /** + * SplitElementsAtEveryBRElement() splits before all <br> elements in + * aMostAncestorToBeSplit. All <br> nodes will be moved before right node + * at splitting its parent. Finally, this returns left node, first <br> + * element, next left node, second <br> element... and right-most node. + * + * @param aMostAncestorToBeSplit Most-ancestor element which should + * be split. + * @param aOutArrayOfNodes First left node, first <br> element, + * Second left node, second <br> 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 <br> element + * is first leaf node of + * aMostAncestorToBeSplit, starting from + * the first <br> element. + * @return A suggest point to put caret if + * succeeded, but it may unset. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + SplitElementsAtEveryBRElement( + nsIContent& aMostAncestorToBeSplit, + nsTArray<OwningNonNull<nsIContent>>& 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 + * <br> elements. + * + * @return A suggest point to put caret if + * succeeded, but it may unset. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + MaybeSplitElementsAtEveryBRElement( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + EditSubAction aEditSubAction); + + /** + * CreateRangeIncludingAdjuscentWhiteSpaces() creates an nsRange instance + * which may be expanded from the given range to include adjuscent + * white-spaces. If this fails handling something, returns nullptr. + */ + template <typename EditorDOMRangeType> + already_AddRefed<nsRange> CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMRangeType& aRange); + template <typename EditorDOMPointType1, typename EditorDOMPointType2> + already_AddRefed<nsRange> CreateRangeIncludingAdjuscentWhiteSpaces( + const EditorDOMPointType1& aStartPoint, + const EditorDOMPointType2& aEndPoint); + + /** + * GetRangeExtendedToHardLineEdgesForBlockEditAction() returns an extended + * range if aRange should be extended before handling a block level editing. + * If aRange start and/or end point <br> or something non-editable point, they + * should be moved to nearest text node or something where the other methods + * easier to handle edit action. + */ + [[nodiscard]] Result<EditorRawDOMRange, nsresult> + GetRangeExtendedToHardLineEdgesForBlockEditAction( + const nsRange* aRange, const Element& aEditingHost) const; + + /** + * InitializeInsertingElement is a callback type of methods which inserts + * an element into the DOM tree. This is called immediately before inserting + * aNewElement into the DOM tree. + * + * @param aHTMLEditor The HTML editor which modifies the DOM tree. + * @param aNewElement The new element which will be or was inserted into + * the DOM tree. + * @param aPointToInsert The position aNewElement will be or was inserted. + */ + using InitializeInsertingElement = + std::function<nsresult(HTMLEditor& aHTMLEditor, Element& aNewElement, + const EditorDOMPoint& aPointToInsert)>; + static InitializeInsertingElement DoNothingForNewElement; + static InitializeInsertingElement InsertNewBRElement; + + /** + * Helper methods to implement InitializeInsertingElement. + */ + MOZ_CAN_RUN_SCRIPT static Result<CreateElementResult, nsresult> + AppendNewElementToInsertingElement( + HTMLEditor& aHTMLEditor, const nsStaticAtom& aTagName, + Element& aNewElement, + const InitializeInsertingElement& aInitializer = DoNothingForNewElement); + MOZ_CAN_RUN_SCRIPT static Result<CreateElementResult, nsresult> + AppendNewElementWithBRToInsertingElement(HTMLEditor& aHTMLEditor, + const nsStaticAtom& aTagName, + Element& aNewElement); + + /** + * Create an element node whose name is aTag at before aPointToInsert. When + * this succeed to create an element node, this inserts the element to + * aPointToInsert. + * + * @param aWithTransaction Whether the inserting is new element is undoable + * or not. WithTransaction::No is useful only when + * the new element is inserted into a new element + * which has not been connected yet. + * @param aTagName The element name to create. + * @param aPointToInsert The insertion point of new element. + * If this refers end of the container or after, + * the transaction will append the element to the + * container. + * Otherwise, will insert the element before the + * child node referred by this. + * Note that this point will be invalid once this + * method inserts the new element. + * @param aInitializer A function to initialize the new element before + * connecting the element into the DOM tree. Note + * that this should not touch outside given element + * because doing it would break range updater's + * result. + * @return The created new element node and candidate caret + * position. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + CreateAndInsertElement( + WithTransaction aWithTransaction, const nsAtom& aTagName, + const EditorDOMPoint& aPointToInsert, + const InitializeInsertingElement& aInitializer = DoNothingForNewElement); + + /** + * Callback of CopyAttributes(). + * + * @param aHTMLEditor The HTML editor. + * @param aSrcElement The element which have the attribute. + * @param aDestElement The element which will have the attribute. + * @param aAttr [in] The attribute which will be copied. + * @param aValue [in/out] The attribute value which will be copied. + * Once updated, the new value is used. + * @return true if the attribute should be copied, otherwise, + * false. + */ + using AttributeFilter = std::function<bool( + HTMLEditor& aHTMLEditor, Element& aSrcElement, Element& aDestElement, + const dom::Attr& aAttr, nsString& aValue)>; + static AttributeFilter CopyAllAttributes; + static AttributeFilter CopyAllAttributesExceptId; + static AttributeFilter CopyAllAttributesExceptDir; + static AttributeFilter CopyAllAttributesExceptIdAndDir; + + /** + * Copy all attributes of aSrcElement to aDestElement as-is. Different from + * EditorBase::CloneAttributesWithTransaction(), this does not use + * SetAttributeOrEquivalent() nor does not clear existing attributes of + * aDestElement. + * + * @param aWithTransaction Whether recoding with transactions or not. + * @param aDestElement The element will have attributes. + * @param aSrcElement The element whose attributes will be copied. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CopyAttributes( + WithTransaction aWithTransaction, Element& aDestElement, + Element& aSrcElement, const AttributeFilter& = CopyAllAttributes); + + /** + * MaybeSplitAncestorsForInsertWithTransaction() does nothing if container of + * aStartOfDeepestRightNode can have an element whose tag name is aTag. + * Otherwise, looks for an ancestor node which is or is in active editing + * host and can have an element whose name is aTag. If there is such + * ancestor, its descendants are split. + * + * Note that this may create empty elements while splitting ancestors. + * + * @param aTag The name of element to be inserted + * after calling this method. + * @param aStartOfDeepestRightNode The start point of deepest right node. + * This point must be in aEditingHost. + * @param aEditingHost The editing host. + * @return When succeeded, SplitPoint() returns + * the point to insert the element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + MaybeSplitAncestorsForInsertWithTransaction( + const nsAtom& aTag, const EditorDOMPoint& aStartOfDeepestRightNode, + const Element& aEditingHost); + + /** + * InsertElementWithSplittingAncestorsWithTransaction() is a wrapper of + * MaybeSplitAncestorsForInsertWithTransaction() and CreateAndInsertElement(). + * I.e., will create an element whose tag name is aTagName and split ancestors + * if it's necessary, then, insert it. + * + * @param aTagName The tag name which you want to insert new + * element at aPointToInsert. + * @param aPointToInsert The insertion point. New element will be + * inserted before here. + * @param aBRElementNextToSplitPoint + * Whether <br> element should be deleted or + * kept if and only if a <br> element follows + * split point. + * @param aEditingHost The editing host with which we're handling it. + * @param aInitializer A function to initialize the new element before + * connecting the element into the DOM tree. Note + * that this should not touch outside given element + * because doing it would break range updater's + * result. + * @return If succeeded, returns the new element node and + * suggesting point to put caret. + */ + enum class BRElementNextToSplitPoint { Keep, Delete }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + InsertElementWithSplittingAncestorsWithTransaction( + const nsAtom& aTagName, const EditorDOMPoint& aPointToInsert, + BRElementNextToSplitPoint aBRElementNextToSplitPoint, + const Element& aEditingHost, + const InitializeInsertingElement& aInitializer = DoNothingForNewElement); + + /** + * Split aElementToSplit at two points, before aStartOfMiddleElement and after + * aEndOfMiddleElement. If they are very start or very end of aBlockElement, + * this won't create empty block. + * + * @param aElementToSplit An element which will be split. + * @param aStartOfMiddleElement Start node of middle block element. + * @param aEndOfMiddleElement End node of middle block element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitRangeOffFromNodeResult, nsresult> + SplitRangeOffFromElement(Element& aElementToSplit, + nsIContent& aStartOfMiddleElement, + nsIContent& aEndOfMiddleElement); + + /** + * RemoveBlockContainerElementWithTransactionBetween() splits the nodes + * at aStartOfRange and aEndOfRange, then, removes the middle element which + * was split off from aBlockContainerElement and moves the ex-children to + * where the middle element was. I.e., all nodes between aStartOfRange and + * aEndOfRange (including themselves) will be unwrapped from + * aBlockContainerElement. + * + * @param aBlockContainerElement The node which will be split. + * @param aStartOfRange The first node which will be unwrapped + * from aBlockContainerElement. + * @param aEndOfRange The last node which will be unwrapped from + * aBlockContainerElement. + * @param aBlockInlineCheck Whether this method considers block vs. + * inline with computed style or the default + * style. + * @return The left content is new created left + * element of aBlockContainerElement. + * The right content is split element, + * i.e., must be aBlockContainerElement. + * The middle content is nullptr since + * removing it is the job of this method. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitRangeOffFromNodeResult, nsresult> + RemoveBlockContainerElementWithTransactionBetween( + Element& aBlockContainerElement, nsIContent& aStartOfRange, + nsIContent& aEndOfRange, BlockInlineCheck aBlockInlineCheck); + + /** + * WrapContentsInBlockquoteElementsWithTransaction() inserts at least one + * <blockquote> element and moves nodes in aArrayOfContents into new + * <blockquote> elements. If aArrayOfContents includes a table related element + * except <table>, this calls itself recursively to insert <blockquote> into + * the cell. + * + * @param aArrayOfContents Nodes which will be moved into created + * <blockquote> elements. + * @param aEditingHost The editing host. + * @return A blockquote element which is created at last + * and a suggest of caret position if succeeded. + * The caret suggestion may be unset if there is + * no suggestion. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + WrapContentsInBlockquoteElementsWithTransaction( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + const Element& aEditingHost); + + /** + * Our traditional formatBlock was same as XUL cmd_paragraphState command. + * However, the behavior is pretty different from the others and aligning + * the XUL command behavior may break Thunderbird a lot because it handles + * <blockquote> in a special path and <div> (generic block element) is not + * treated as a format node and these things may be used for designing + * current roles of the elements in the email composer of Thunderbird. + * Therefore, we create a new mode for HTMLFormatBlockCommand to align + * the behavior to the others but does not harm Thunderbird. + */ + enum class FormatBlockMode { + // Document.execCommand("formatBlock"). Cannot set new format to "normal" + // nor "". So, the paths to handle these ones are not used in this mode. + HTMLFormatBlockCommand, + // cmd_paragraphState. Can set new format to "normal" or "" to remove + // ancestor format blocks. + XULParagraphStateCommand, + }; + + /** + * RemoveBlockContainerElementsWithTransaction() removes all format blocks, + * table related element, etc in aArrayOfContents from the DOM tree. If + * aArrayOfContents has a format node, it will be removed and its contents + * will be moved to where it was. + * If aArrayOfContents has a table related element, <li>, <blockquote> or + * <div>, it will be removed and its contents will be moved to where it was. + * + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + * + * @return A suggest point to put caret if succeeded, but it may be + * unset if there is no suggestion. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + RemoveBlockContainerElementsWithTransaction( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + FormatBlockMode aFormatBlockMode, BlockInlineCheck aBlockInlineCheck); + + /** + * CreateOrChangeFormatContainerElement() formats all nodes in + * aArrayOfContents with block elements whose name is aNewFormatTagName. + * + * If aArrayOfContents has an inline element, a block element is created and + * the inline element and following inline elements are moved into the new + * block element. + * If aArrayOfContents has <br> elements, they'll be removed from the DOM tree + * and new block element will be created when there are some remaining inline + * elements. + * If aArrayOfContents has a block element, this calls itself with children of + * the block element. Then, new block element will be created when there are + * some remaining inline elements. + * + * @param aArrayOfContents Must be descendants of a node. + * @param aNewFormatTagName The element name of new block elements. + * @param aFormatBlockMode The replacing block element target type is for + * whether HTML formatBLock command or XUL + * paragraphState command. + * @param aEditingHost The editing host. + * @return The latest created new block element and a + * suggest point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + CreateOrChangeFormatContainerElement( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + const nsStaticAtom& aNewFormatTagName, FormatBlockMode aFormatBlockMode, + const Element& aEditingHost); + + /** + * FormatBlockContainerWithTransaction() is implementation of "formatBlock" + * command of `Document.execCommand()`. This applies block style or removes + * it. + * + * @param aSelectionRanges The ranges which are cloned by selection or + * updated from it with doing something before + * calling this. + * @param aNewFormatTagName New block tag name. + * If nsGkAtoms::normal or nsGkAtoms::_empty, + * RemoveBlockContainerElementsWithTransaction() + * will be called. + * If nsGkAtoms::blockquote, + * WrapContentsInBlockquoteElementsWithTransaction() + * will be called. + * Otherwise, CreateOrChangeBlockContainerElement() + * will be called. + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + * @param aEditingHost The editing host. + * @return If selection should be finally collapsed in a + * created block element, this returns the element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<RefPtr<Element>, nsresult> + FormatBlockContainerWithTransaction(AutoRangeArray& aSelectionRanges, + const nsStaticAtom& aNewFormatTagName, + FormatBlockMode aFormatBlockMode, + const Element& aEditingHost); + + /** + * Determine if aPointToInsert is start of a hard line and end of the line + * (i.e, in an empty line) and the line ends with block boundary, inserts a + * `<br>` element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult> + InsertBRElementIfHardLineIsEmptyAndEndsWithBlockBoundary( + const EditorDOMPoint& aPointToInsert); + + /** + * Insert padding `<br>` 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 `<br>` element for empty last line if + * selection is collapsed and container of the range needs it. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + MaybeInsertPaddingBRElementForEmptyLastLineAtSelection(); + + /** + * SplitParagraphWithTransaction() splits the parent block, aParentDivOrP, at + * aStartOfRightNode. + * + * @param aParentDivOrP The parent block to be split. This must be <p> + * or <div> element. + * @param aStartOfRightNode The point to be start of right node after + * split. This must be descendant of + * aParentDivOrP. + * @param aMayBecomeVisibleBRElement + * Next <br> element of the split point if there + * is. Otherwise, nullptr. If this is not nullptr, + * the <br> element may be removed if it becomes + * visible. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + SplitParagraphWithTransaction(Element& aParentDivOrP, + const EditorDOMPoint& aStartOfRightNode, + dom::HTMLBRElement* aMayBecomeVisibleBRElement); + + /** + * HandleInsertParagraphInParagraph() does the right thing for Enter key + * press or 'insertParagraph' command in aParentDivOrP. aParentDivOrP will + * be split **around** aCandidatePointToSplit. If this thinks that it should + * be handled to insert a <br> instead, this returns "not handled". + * + * @param aParentDivOrP The parent block. This must be <p> or <div> + * element. + * @param aCandidatePointToSplit + * The point where the caller want to split + * aParentDivOrP. However, in some cases, this is not + * used as-is. E.g., this method avoids to create new + * empty <a href> in the right paragraph. So this may + * be adjusted to proper position around it. + * @param aEditingHost The editing host. + * @return If the caller should default to inserting <br> + * element, returns "not handled". + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + HandleInsertParagraphInParagraph(Element& aParentDivOrP, + const EditorDOMPoint& aCandidatePointToSplit, + const Element& aEditingHost); + + /** + * HandleInsertParagraphInHeadingElement() handles insertParagraph command + * (i.e., handling Enter key press) in a heading element. This splits + * aHeadingElement element at aPointToSplit. 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 aHeadingElement The heading element to be split. + * @param aPointToSplit The point to split aHeadingElement. + * @return New paragraph element, meaning right heading + * element if aHeadingElement is split, or newly + * created or existing paragraph element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertParagraphResult, nsresult> + HandleInsertParagraphInHeadingElement(Element& aHeadingElement, + const EditorDOMPoint& aPointToSplit); + + /** + * HandleInsertParagraphInListItemElement() handles insertParagraph command + * (i.e., handling Enter key press) in a list item element. + * + * @param aListItemElement The list item which has the following point. + * @param aPointToSplit The point to split aListItemElement. + * @param aEditingHost The editing host. + * @return New paragraph element, meaning right list item + * element if aListItemElement is split, or newly + * created paragraph element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertParagraphResult, nsresult> + HandleInsertParagraphInListItemElement(Element& aListItemElement, + const EditorDOMPoint& aPointToSplit, + const Element& aEditingHost); + + /** + * InsertParagraphSeparatorAsSubAction() handles insertPargraph commad + * (i.e., handling Enter key press) with the above helper methods. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + InsertParagraphSeparatorAsSubAction(const Element& aEditingHost); + + /** + * InsertLineBreakAsSubAction() inserts a new <br> element or a linefeed + * character at selection. If there is non-collapsed selection ranges, the + * selected ranges is deleted first. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertLineBreakAsSubAction(); + + /** + * ChangeListElementType() replaces child list items of aListElement with + * new list item element whose tag name is aNewListItemTag. + * Note that if there are other list elements as children of aListElement, + * this calls itself recursively even though it's invalid structure. + * + * @param aListElement The list element whose list items will be + * replaced. + * @param aNewListTag New list tag name. + * @param aNewListItemTag New list item tag name. + * @return New list element or an error code if it fails. + * New list element may be aListElement if its + * tag name is same as aNewListTag. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + ChangeListElementType(Element& aListElement, nsAtom& aListType, + nsAtom& aItemType); + + class AutoListElementCreator; + + [[nodiscard]] static bool IsFormatElement(FormatBlockMode aFormatBlockMode, + const nsIContent& aContent); + + /** + * MakeOrChangeListAndListItemAsSubAction() handles create list commands with + * current selection. If + * + * @param aListElementOrListItemElementTagName + * The new list element tag name or + * new list item tag name. + * If the former, list item tag name will + * be computed automatically. Otherwise, + * list tag name will be computed. + * @param aBulletType If this is not empty string, it's set + * to `type` attribute of new list item + * elements. Otherwise, existing `type` + * attributes will be removed. + * @param aSelectAllOfCurrentList Yes if this should treat all of + * ancestor list element at selection. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + MakeOrChangeListAndListItemAsSubAction( + const nsStaticAtom& aListElementOrListItemElementTagName, + const nsAString& aBulletType, + SelectAllOfCurrentList aSelectAllOfCurrentList); + + /** + * DeleteTextAndTextNodesWithTransaction() removes text or text nodes in + * the given range. + */ + enum class TreatEmptyTextNodes { + // KeepIfContainerOfRangeBoundaries: + // Will remove empty text nodes middle of the range, but keep empty + // text nodes which are containers of range boundaries. + KeepIfContainerOfRangeBoundaries, + // Remove: + // Will remove all empty text nodes. + Remove, + // RemoveAllEmptyInlineAncestors: + // Will remove all empty text nodes and its inline ancestors which + // become empty due to removing empty text nodes. + RemoveAllEmptyInlineAncestors, + }; + template <typename EditorDOMPointType> + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult> + DeleteTextAndTextNodesWithTransaction( + const EditorDOMPointType& aStartPoint, + const EditorDOMPointType& aEndPoint, + TreatEmptyTextNodes aTreatEmptyTextNodes); + + /** + * JoinNodesWithTransaction() joins aLeftContent and aRightContent. Content + * of aLeftContent will be merged into aRightContent. Actual implemenation of + * this method is JoinNodesImpl(). So, see its explanation for the detail. + * + * @param aLeftContent Will be removed from the DOM tree. + * @param aRightContent The node which will be new container of the content + * of aLeftContent. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<JoinNodesResult, nsresult> + JoinNodesWithTransaction(nsIContent& aLeftContent, nsIContent& aRightContent); + + /** + * JoinNearestEditableNodesWithTransaction() joins two editable nodes which + * are themselves or the nearest editable node of aLeftNode and aRightNode. + * XXX This method's behavior is odd. For example, if user types Backspace + * key at the second editable paragraph in this case: + * <div contenteditable> + * <p>first editable paragraph</p> + * <p contenteditable="false">non-editable paragraph</p> + * <p>second editable paragraph</p> + * </div> + * The first editable paragraph's content will be moved into the second + * editable paragraph and the non-editable paragraph becomes the first + * paragraph of the editor. I don't think that it's expected behavior of + * any users... + * + * @param aLeftNode The node which will be removed. + * @param aRightNode The node which will be inserted the content of + * aLeftNode. + * @param aNewFirstChildOfRightNode + * [out] The point at the first child of aRightNode. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + JoinNearestEditableNodesWithTransaction( + nsIContent& aLeftNode, nsIContent& aRightNode, + EditorDOMPoint* aNewFirstChildOfRightNode); + + /** + * ReplaceContainerAndCloneAttributesWithTransaction() creates new element + * whose name is aTagName, copies all attributes from aOldContainer to the + * new element, moves all children in aOldContainer to the new element, then, + * removes aOldContainer from the DOM tree. + * + * @param aOldContainer The element node which should be replaced + * with new element. + * @param aTagName The name of new element node. + */ + [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + ReplaceContainerAndCloneAttributesWithTransaction(Element& aOldContainer, + const nsAtom& aTagName); + + /** + * ReplaceContainerWithTransaction() creates new element whose name is + * aTagName, sets aAttributes of the new element to aAttributeValue, moves + * all children in aOldContainer to the new element, then, removes + * aOldContainer from the DOM tree. + * + * @param aOldContainer The element node which should be replaced + * with new element. + * @param aTagName The name of new element node. + * @param aAttribute Attribute name to be set to the new element. + * @param aAttributeValue Attribute value to be set to aAttribute. + */ + [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + ReplaceContainerWithTransaction(Element& aOldContainer, + const nsAtom& aTagName, + const nsAtom& aAttribute, + const nsAString& aAttributeValue); + + /** + * ReplaceContainerWithTransaction() creates new element whose name is + * aTagName, moves all children in aOldContainer to the new element, then, + * removes aOldContainer from the DOM tree. + * + * @param aOldContainer The element node which should be replaced + * with new element. + * @param aTagName The name of new element node. + */ + [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + ReplaceContainerWithTransaction(Element& aOldContainer, + const nsAtom& aTagName); + + /** + * RemoveContainerWithTransaction() removes aElement from the DOM tree and + * moves all its children to the parent of aElement. + * + * @param aElement The element to be removed. + * @return A suggestion point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + RemoveContainerWithTransaction(Element& aElement); + + /** + * InsertContainerWithTransaction() creates new element whose name is + * aWrapperTagName, moves aContentToBeWrapped into the new element, then, + * inserts the new element into where aContentToBeWrapped was. + * NOTE: This method does not check if aContentToBeWrapped is valid child + * of the new element. So, callers need to guarantee it. + * + * @param aContentToBeWrapped The content which will be wrapped with new + * element. + * @param aWrapperTagName Element name of new element which will wrap + * aContent and be inserted into where aContent + * was. + * @param aInitializer A callback to initialize new element before + * inserting to the DOM tree. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + InsertContainerWithTransaction( + nsIContent& aContentToBeWrapped, const nsAtom& aWrapperTagName, + const InitializeInsertingElement& aInitializer = DoNothingForNewElement); + + /** + * MoveNodeWithTransaction() moves aContentToMove to aPointToInsert. + * + * @param aContentToMove The node to be moved. + * @param aPointToInsert The point where aContentToMove will be inserted. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<MoveNodeResult, nsresult> + MoveNodeWithTransaction(nsIContent& aContentToMove, + const EditorDOMPoint& aPointToInsert); + + /** + * MoveNodeToEndWithTransaction() moves aContentToMove to end of + * aNewContainer. + * + * @param aContentToMove The node to be moved. + * @param aNewContainer The new container which will contain aContentToMove + * as its last child. + */ + [[nodiscard]] inline MOZ_CAN_RUN_SCRIPT Result<MoveNodeResult, nsresult> + MoveNodeToEndWithTransaction(nsIContent& aContentToMove, + nsINode& aNewContainer); + + /** + * MoveNodeOrChildrenWithTransaction() moves aContent to aPointToInsert. If + * cannot insert aContent due to invalid relation, moves only its children + * recursively and removes aContent from the DOM tree. + * + * @param aContent Content which should be moved. + * @param aPointToInsert The point to be inserted aContent or its + * descendants. + * @param aPreserveWhiteSpaceStyle + * If yes and if it's possible to keep white-space + * style, this method will set `style` attribute to + * moving node or creating new <span> element. + * @param aRemoveIfCommentNode + * If yes, this removes a comment node instead of + * moving it to the destination. Note that this + * does not remove comment nodes in moving nodes + * because it requires additional scan. + */ + enum class PreserveWhiteSpaceStyle { No, Yes }; + friend std::ostream& operator<<( + std::ostream& aStream, + const PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle); + enum class RemoveIfCommentNode { No, Yes }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<MoveNodeResult, nsresult> + MoveNodeOrChildrenWithTransaction( + nsIContent& aContentToMove, const EditorDOMPoint& aPointToInsert, + PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle, + RemoveIfCommentNode aRemoveIfCommentNode); + + /** + * CanMoveNodeOrChildren() returns true if + * `MoveNodeOrChildrenWithTransaction()` can move or delete at least a + * descendant of aElement into aNewContainer. I.e., when this returns true, + * `MoveNodeOrChildrenWithTransaction()` must return "handled". + */ + Result<bool, nsresult> CanMoveNodeOrChildren( + const nsIContent& aContent, const nsINode& aNewContainer) const; + + /** + * MoveChildrenWithTransaction() moves the children of aElement to + * aPointToInsert. If cannot insert some children due to invalid relation, + * calls MoveNodeOrChildrenWithTransaction() to remove the children but keep + * moving its children. + * + * @param aElement Container element whose children should be + * moved. + * @param aPointToInsert The point to be inserted children of aElement + * or its descendants. + * @param aPreserveWhiteSpaceStyle + * If yes and if it's possible to keep white-space + * style, this method will set `style` attribute to + * moving node or creating new <span> element. + * @param aRemoveIfCommentNode + * If yes, this removes a comment node instead of + * moving it to the destination. Note that this + * does not remove comment nodes in moving nodes + * because it requires additional scan. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<MoveNodeResult, nsresult> + MoveChildrenWithTransaction(Element& aElement, + const EditorDOMPoint& aPointToInsert, + PreserveWhiteSpaceStyle aPreserveWhiteSpaceStyle, + RemoveIfCommentNode aRemoveIfCommentNode); + + /** + * CanMoveChildren() returns true if `MoveChildrenWithTransaction()` can move + * at least a descendant of aElement into aNewContainer. I.e., when this + * returns true, `MoveChildrenWithTransaction()` return "handled". + */ + Result<bool, nsresult> CanMoveChildren(const Element& aElement, + const nsINode& aNewContainer) const; + + /** + * MoveAllChildren() moves all children of aContainer to before + * aPointToInsert.GetChild(). + * See explanation of MoveChildrenBetween() for the detail of the behavior. + * + * @param aContainer The container node whose all children should + * be moved. + * @param aPointToInsert The insertion point. The container must not + * be a data node like a text node. + */ + [[nodiscard]] nsresult MoveAllChildren( + nsINode& aContainer, const EditorRawDOMPoint& aPointToInsert); + + /** + * MoveChildrenBetween() moves all children between aFirstChild and aLastChild + * to before aPointToInsert.GetChild(). If some children are moved to + * different container while this method moves other children, they are just + * ignored. If the child node referred by aPointToInsert is moved to different + * container while this method moves children, returns error. + * + * @param aFirstChild The first child which should be moved to + * aPointToInsert. + * @param aLastChild The last child which should be moved. This + * must be a sibling of aFirstChild and it should + * be positioned after aFirstChild in the DOM tree + * order. + * @param aPointToInsert The insertion point. The container must not + * be a data node like a text node. + */ + [[nodiscard]] nsresult MoveChildrenBetween( + nsIContent& aFirstChild, nsIContent& aLastChild, + const EditorRawDOMPoint& aPointToInsert); + + /** + * MovePreviousSiblings() moves all siblings before aChild (i.e., aChild + * won't be moved) to before aPointToInsert.GetChild(). + * See explanation of MoveChildrenBetween() for the detail of the behavior. + * + * @param aChild The node which is next sibling of the last + * node to be moved. + * @param aPointToInsert The insertion point. The container must not + * be a data node like a text node. + */ + [[nodiscard]] nsresult MovePreviousSiblings( + nsIContent& aChild, const EditorRawDOMPoint& aPointToInsert); + + /** + * MoveInclusiveNextSiblings() moves aChild and all siblings after it to + * before aPointToInsert.GetChild(). + * See explanation of MoveChildrenBetween() for the detail of the behavior. + * + * @param aChild The node which is first node to be moved. + * @param aPointToInsert The insertion point. The container must not + * be a data node like a text node. + */ + [[nodiscard]] nsresult MoveInclusiveNextSiblings( + nsIContent& aChild, const EditorRawDOMPoint& aPointToInsert); + + /** + * SplitNodeWithTransaction() creates a transaction to create a new node + * (left node) identical to an existing node (right node), and split the + * contents between the same point in both nodes, then, execute the + * transaction. + * + * @param aStartOfRightNode The point to split. Its container will be + * the right node, i.e., become the new node's + * next sibling. And the point will be start + * of the right node. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + SplitNodeWithTransaction(const EditorDOMPoint& aStartOfRightNode); + + /** + * SplitNodeDeepWithTransaction() splits aMostAncestorToSplit deeply. + * + * @param aMostAncestorToSplit The most ancestor node which should be + * split. + * @param aStartOfDeepestRightNode The start point of deepest right node. + * This point must be descendant of + * aMostAncestorToSplit. + * @param aSplitAtEdges Whether the caller allows this to + * create empty container element when + * split point is start or end of an + * element. + * @return SplitPoint() returns split point in + * aMostAncestorToSplit. The point must + * be good to insert something if the + * caller want to do it. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult> + SplitNodeDeepWithTransaction(nsIContent& aMostAncestorToSplit, + const EditorDOMPoint& aDeepestStartOfRightNode, + SplitAtEdges aSplitAtEdges); + + /** + * RemoveEmptyInclusiveAncestorInlineElements() removes empty inclusive + * ancestor inline elements in inclusive ancestor block element of aContent. + * + * @param aContent Must be an empty content. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + RemoveEmptyInclusiveAncestorInlineElements(nsIContent& aContent); + + /** + * DeleteTextAndNormalizeSurroundingWhiteSpaces() deletes text between + * aStartToDelete and immediately before aEndToDelete and return new caret + * position. If surrounding characters are white-spaces, this normalize them + * too. Finally, inserts `<br>` element if it's required. + * Note that if you wants only normalizing white-spaces, you can set same + * point to both aStartToDelete and aEndToDelete. Then, this tries to + * normalize white-space sequence containing previous character of + * aStartToDelete. + */ + enum class DeleteDirection { + Forward, + Backward, + }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult> + DeleteTextAndNormalizeSurroundingWhiteSpaces( + const EditorDOMPointInText& aStartToDelete, + const EditorDOMPointInText& aEndToDelete, + TreatEmptyTextNodes aTreatEmptyTextNodes, + DeleteDirection aDeleteDirection); + + /** + * ExtendRangeToDeleteWithNormalizingWhiteSpaces() is a helper method of + * DeleteTextAndNormalizeSurroundingWhiteSpaces(). This expands + * aStartToDelete and/or aEndToDelete if there are white-spaces which need + * normalizing. + * + * @param aStartToDelete [In/Out] Start to delete. If this point + * follows white-spaces, this may be modified. + * @param aEndToDelete [In/Out] Next point of last content to be + * deleted. If this point is a white-space, + * this may be modified. + * @param aNormalizedWhiteSpacesInStartNode + * [Out] If container text node of aStartToDelete + * should be modified, this offers new string + * in the range in the text node. + * @param aNormalizedWhiteSpacesInEndNode + * [Out] If container text node of aEndToDelete + * is different from the container of + * aStartToDelete and it should be modified, this + * offers new string in the range in the text node. + */ + void ExtendRangeToDeleteWithNormalizingWhiteSpaces( + EditorDOMPointInText& aStartToDelete, EditorDOMPointInText& aEndToDelete, + nsAString& aNormalizedWhiteSpacesInStartNode, + nsAString& aNormalizedWhiteSpacesInEndNode) const; + + /** + * CharPointType let the following helper methods of + * ExtendRangeToDeleteWithNormalizingWhiteSpaces() know what type of + * character will be previous or next char point after deletion. + */ + enum class CharPointType { + TextEnd, // Start or end of the text (hardline break or replaced inline + // element) + ASCIIWhiteSpace, // One of ASCII white-spaces (collapsible white-space) + NoBreakingSpace, // NBSP + VisibleChar, // Non-white-space characters + PreformattedChar, // Any character except a linefeed in a preformatted + // node. + PreformattedLineBreak, // Preformatted linebreak + }; + + /** + * GetPreviousCharPointType() and GetCharPointType() get type of + * previous/current char point from current DOM tree. In other words, if the + * point will be deleted, you cannot use these methods. + */ + template <typename EditorDOMPointType> + static CharPointType GetPreviousCharPointType( + const EditorDOMPointType& aPoint); + template <typename EditorDOMPointType> + static CharPointType GetCharPointType(const EditorDOMPointType& aPoint); + + /** + * CharPointData let the following helper methods of + * ExtendRangeToDeleteWithNormalizingWhiteSpaces() know what type of + * character will be previous or next char point and the point is + * in same or different text node after deletion. + */ + class MOZ_STACK_CLASS CharPointData final { + public: + static CharPointData InDifferentTextNode(CharPointType aCharPointType) { + CharPointData result; + result.mIsInDifferentTextNode = true; + result.mType = aCharPointType; + return result; + } + static CharPointData InSameTextNode(CharPointType aCharPointType) { + CharPointData result; + // Let's mark this as in different text node if given one indicates + // that there is end of text because it means that adjacent content + // from point of text node view is another element. + result.mIsInDifferentTextNode = aCharPointType == CharPointType::TextEnd; + result.mType = aCharPointType; + return result; + } + + bool AcrossTextNodeBoundary() const { return mIsInDifferentTextNode; } + bool IsCollapsibleWhiteSpace() const { + return mType == CharPointType::ASCIIWhiteSpace || + mType == CharPointType::NoBreakingSpace; + } + CharPointType Type() const { return mType; } + + private: + CharPointData() = default; + + CharPointType mType; + bool mIsInDifferentTextNode; + }; + + /** + * GetPreviousCharPointDataForNormalizingWhiteSpaces() and + * GetInclusiveNextCharPointDataForNormalizingWhiteSpaces() is helper methods + * of ExtendRangeToDeleteWithNormalizingWhiteSpaces(). This retrieves + * previous or inclusive next editable char point and returns its data. + */ + CharPointData GetPreviousCharPointDataForNormalizingWhiteSpaces( + const EditorDOMPointInText& aPoint) const; + CharPointData GetInclusiveNextCharPointDataForNormalizingWhiteSpaces( + const EditorDOMPointInText& aPoint) const; + + /** + * GenerateWhiteSpaceSequence() generates white-space sequence which won't + * be collapsed. + * + * @param aResult [out] White space sequence which won't be + * collapsed, but wrapable. + * @param aLength Length of generating white-space sequence. + * Must be 1 or larger. + * @param aPreviousCharPointData + * Specify the previous char point where it'll be + * inserted. Currently, for keepin this method + * simple, does not support to generate a part + * of white-space sequence in a text node. So, + * if the type is white-space, it must indicate + * different text nodes white-space. + * @param aNextCharPointData Specify the next char point where it'll be + * inserted. Same as aPreviousCharPointData, + * this must node indidate white-space in same + * text node. + */ + static void GenerateWhiteSpaceSequence( + nsAString& aResult, uint32_t aLength, + const CharPointData& aPreviousCharPointData, + const CharPointData& aNextCharPointData); + + /** + * ComputeTargetRanges() computes actual delete ranges which will be deleted + * unless the following `beforeinput` event is canceled. + * + * @param aDirectionAndAmount The direction and amount of deletion. + * @param aRangesToDelete [In/Out] The ranges to be deleted, + * typically, initialized with the + * selection ranges. This may be modified + * if selection ranges should be extened. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + ComputeTargetRanges(nsIEditor::EDirection aDirectionAndAmount, + AutoRangeArray& aRangesToDelete) const; + + /** + * This method handles "delete selection" commands. + * + * @param aDirectionAndAmount Direction of the deletion. + * @param aStripWrappers Must be eStrip or eNoStrip. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + HandleDeleteSelection(nsIEditor::EDirection aDirectionAndAmount, + nsIEditor::EStripWrappers aStripWrappers) final; + + class AutoDeleteRangesHandler; + class AutoMoveOneLineHandler; + + /** + * DeleteMostAncestorMailCiteElementIfEmpty() deletes most ancestor + * mail cite element (`<blockquote type="cite">` or + * `<span _moz_quote="true">`, 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 <li>, <dt> or <dd> 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 <li>, <dl> or <dt> as a child, the element is removed + * but its descendants are moved to where the list item element was. + * If aListElement has another <ul>, <ol> or <dl> 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 <ul>, <ol> or <dl> element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + DestroyListStructureRecursively(Element& aListElement); + + /** + * RemoveListAtSelectionAsSubAction() removes list elements and list item + * elements at Selection. And move contents in them where the removed list + * was. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + RemoveListAtSelectionAsSubAction(const Element& aEditingHost); + + /** + * ChangeMarginStart() changes margin of aElement to indent or outdent. + * If it's rtl text, margin-right will be changed. Otherwise, margin-left. + * XXX This is not aware of vertical writing-mode. + * + * @param aElement The element whose start margin should be + * changed. + * @param aChangeMargin Whether increase or decrease the margin. + * @param aEditingHost The editing host. + * @return May suggest a suggest point to put caret. + */ + enum class ChangeMargin { Increase, Decrease }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + ChangeMarginStart(Element& aElement, ChangeMargin aChangeMargin, + const Element& aEditingHost); + + /** + * HandleCSSIndentAroundRanges() indents around aRanges with CSS. + * + * @param aRanges The ranges where the content should be indented. + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleCSSIndentAroundRanges( + AutoRangeArray& aRanges, const Element& aEditingHost); + + /** + * HandleCSSIndentAroundRanges() indents around aRanges with HTML. + * + * @param aRanges The ranges where the content should be indented. + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleHTMLIndentAroundRanges( + AutoRangeArray& aRanges, const Element& aEditingHost); + + /** + * HandleIndentAtSelection() indents around Selection with HTML or CSS. + * + * @param aEditingHost The editing host. + */ + // TODO: Make this take AutoRangeArray instead of retrieving `Selection` + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + HandleIndentAtSelection(const Element& aEditingHost); + + /** + * OutdentPartOfBlock() outdents the nodes between aStartOfOutdent and + * aEndOfOutdent. This splits the range off from aBlockElement first. + * Then, removes the middle element if aIsBlockIndentedWithCSS is false. + * Otherwise, decreases the margin of the middle element. + * + * @param aBlockElement A block element which includes both + * aStartOfOutdent and aEndOfOutdent. + * @param aStartOfOutdent First node which is descendant of + * aBlockElement will be outdented. + * @param aEndOfOutdent Last node which is descandant of + * aBlockElement will be outdented. + * @param aBlockIndentedWith `CSS` if aBlockElement is indented with + * CSS margin property. + * `HTML` if aBlockElement is `<blockquote>` + * or something. + * @param aEditingHost The editing host. + * @return The left content is new created element + * splitting before aStartOfOutdent. + * The right content is existing element. + * The middle content is outdented element + * if aBlockIndentedWith is `CSS`. + * Otherwise, nullptr. + */ + enum class BlockIndentedWith { CSS, HTML }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitRangeOffFromNodeResult, nsresult> + OutdentPartOfBlock(Element& aBlockElement, nsIContent& aStartOfOutdent, + nsIContent& aEndOfOutdent, + BlockIndentedWith aBlockIndentedWith, + const Element& aEditingHost); + + /** + * HandleOutdentAtSelectionInternal() outdents contents around Selection. + * This method creates AutoSelectionRestorer. Therefore, each caller + * needs to check if the editor is still available even if this returns + * NS_OK. + * NOTE: Call `HandleOutdentAtSelection()` instead. + * + * @param aEditingHost The editing host. + * @return The left content is left content of last + * outdented element. + * The right content is right content of last + * outdented element. + * The middle content is middle content of last + * outdented element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitRangeOffFromNodeResult, nsresult> + HandleOutdentAtSelectionInternal(const Element& aEditingHost); + + /** + * HandleOutdentAtSelection() outdents contents around Selection. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + HandleOutdentAtSelection(const Element& aEditingHost); + + /** + * AlignBlockContentsWithDivElement() sets align attribute of <div> element + * which is only child of aBlockElement to aAlignType. If aBlockElement + * has 2 or more children or does not have a `<div>` element, inserts a + * new `<div>` element into aBlockElement and move all children of + * aBlockElement into the new `<div>` element. + * + * @param aBlockElement The element node whose contents should be + * aligned to aAlignType. This should be + * an element which can have `<div>` element + * as its child. + * @param aAlignType New value of align attribute of `<div>` + * element. + * @return A candidate position to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + AlignBlockContentsWithDivElement(Element& aBlockElement, + const nsAString& aAlignType); + + /** + * AlignContentsInAllTableCellsAndListItems() calls + * AlignBlockContentsWithDivElement() for aligning contents in every list + * item element and table cell element in aElement. + * + * @param aElement The node which is or whose descendants should + * be aligned to aAlignType. + * @param aAlignType New value of `align` attribute of `<div>`. + * @return A candidate position to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, 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<OwningNonNull<nsIContent>>& aArrayOfContents, + nsTArray<bool>& aTransitionArray); + + /** + * EnsureHardLineBeginsWithFirstChildOf() inserts `<br>` element before + * first child of aRemovingContainerElement if it will not be start of a + * hard line after removing aRemovingContainerElement. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + EnsureHardLineBeginsWithFirstChildOf(Element& aRemovingContainerElement); + + /** + * EnsureHardLineEndsWithLastChildOf() inserts `<br>` element after last + * child of aRemovingContainerElement if it will not be end of a hard line + * after removing aRemovingContainerElement. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + EnsureHardLineEndsWithLastChildOf(Element& aRemovingContainerElement); + + /** + * RemoveAlignFromDescendants() removes align attributes, text-align + * properties and <center> elements in aElement. + * + * @param aElement Alignment information of the node and/or its + * descendants will be removed. + * NOTE: aElement must not be a `<table>` element. + * @param aAlignType New align value to be set only when it's in + * CSS mode and this method meets <table> or <hr>. + * XXX This is odd and not clear when you see caller of + * this method. Do you have better idea? + * @param aEditTarget If `OnlyDescendantsExceptTable`, modifies only + * descendants of aElement. + * If `NodeAndDescendantsExceptTable`, modifies `aElement` + * and its descendants. + * @return A candidate point to put caret. + */ + enum class EditTarget { + OnlyDescendantsExceptTable, + NodeAndDescendantsExceptTable + }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + RemoveAlignFromDescendants(Element& aElement, const nsAString& aAlignType, + EditTarget aEditTarget); + + /** + * SetBlockElementAlign() resets `align` attribute, `text-align` property + * of descendants of aBlockOrHRElement except `<table>` 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 `<hr>` element. + * If we're not in CSS mode, this element has + * to support `align` attribute (i.e., + * `HTMLEditUtils::SupportsAlignAttr()` must + * return true). + * @param aAlignType Boundary or "center" which contents should be + * aligned on. + * @param aEditTarget If `OnlyDescendantsExceptTable`, modifies only + * descendants of aBlockOrHRElement. + * If `NodeAndDescendantsExceptTable`, modifies + * aBlockOrHRElement and its descendants. + * @return A candidate point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + SetBlockElementAlign(Element& aBlockOrHRElement, const nsAString& aAlignType, + EditTarget aEditTarget); + + /** + * InsertDivElementToAlignContents() inserts a new <div> element (which has + * only a padding <br> element) to aPointToInsert for a placeholder whose + * contents will be aligned. + * + * @param aPointToInsert A point to insert new empty <div>. + * @param aAlignType New align attribute value where the contents + * should be aligned to. + * @param aEditingHost The editing host. + * @return New <div> element which has only a padding <br> + * element and is styled to align contents. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + InsertDivElementToAlignContents(const EditorDOMPoint& aPointToInsert, + const nsAString& aAlignType, + const Element& aEditingHost); + + /** + * AlignNodesAndDescendants() make contents of nodes in aArrayOfContents and + * their descendants aligned to aAlignType. + * + * @param aAlignType New align attribute value where the contents + * should be aligned to. + * @param aEditingHost The editing host. + * @return Last created <div> element which should contain + * caret and candidate position which may be + * outside the <div> element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + AlignNodesAndDescendants( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + const nsAString& aAlignType, const Element& aEditingHost); + + /** + * AlignContentsAtRanges() aligns contents around aRanges to aAlignType. + * + * @param aRanges The ranges where should be aligned. + * @param aAlignType New align attribute value where the contents + * should be aligned to. + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + AlignContentsAtRanges(AutoRangeArray& aRanges, const nsAString& aAlignType, + const Element& aEditingHost); + + /** + * AlignAsSubAction() handles "align" command with `Selection`. + * + * @param aAlignType New align attribute value where the contents + * should be aligned to. + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + AlignAsSubAction(const nsAString& aAlignType, const Element& aEditingHost); + + /** + * AdjustCaretPositionAndEnsurePaddingBRElement() may adjust caret + * position to nearest editable content and if padding `<br>` 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 `<body>` element or document element when `Selection` crosses + * `<body>` element's boundary. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + EnsureSelectionInBodyOrDocumentElement(); + + /** + * InsertBRElementToEmptyListItemsAndTableCellsInRange() inserts + * `<br>` 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 `<br>` element, the node will be removed + * but <br> element is moved to where the mail-cite node was. + * XXX This method is expensive if aRange is too wide and may remove + * unexpected empty element, e.g., it was created by JS, but we haven't + * touched it. Cannot we remove this method and make guarantee that + * empty nodes won't be created? + * + * @param aRange Must be positioned. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + RemoveEmptyNodesIn(const EditorDOMRange& aRange); + + /** + * SetSelectionInterlinePosition() may set interline position if caret is + * positioned around `<br>` or block boundary. Don't call this when + * `Selection` is not collapsed. + */ + void SetSelectionInterlinePosition(); + + /** + * Called by `HTMLEditor::OnEndHandlingTopLevelEditSubAction()`. This may + * adjust Selection, remove unnecessary empty nodes, create `<br>` elements + * if needed, etc. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + OnEndHandlingTopLevelEditSubActionInternal(); + + /** + * MoveSelectedContentsToDivElementToMakeItAbsolutePosition() looks for + * a `<div>` element in selection first. If not, creates new `<div>` + * element. Then, move all selected contents into the target `<div>` + * 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 `<div>` element which should be + * changed to absolute positioned. + * @param aEditingHost The editing host. + */ + // TODO: Rewrite this with `Result<RefPtr<Element>, nsresult>`. + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + MoveSelectedContentsToDivElementToMakeItAbsolutePosition( + RefPtr<Element>* aTargetElement, const Element& aEditingHost); + + /** + * SetSelectionToAbsoluteAsSubAction() move selected contents to first + * selected `<div>` element or newly created `<div>` element and make + * the `<div>` element positioned absolutely. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + SetSelectionToAbsoluteAsSubAction(const Element& aEditingHost); + + /** + * SetSelectionToStaticAsSubAction() sets the `position` property of a + * selection parent's block whose `position` is `absolute` to `static`. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + SetSelectionToStaticAsSubAction(); + + /** + * AddZIndexAsSubAction() adds aChange to `z-index` of nearest parent + * absolute-positioned element from current selection. + * + * @param aChange Amount to change `z-index`. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + 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 void OnStartToHandleTopLevelEditSubAction( + EditSubAction aTopLevelEditSubAction, + nsIEditor::EDirection aDirectionOfTopLevelEditSubAction, + ErrorResult& aRv) final; + MOZ_CAN_RUN_SCRIPT nsresult OnEndHandlingTopLevelEditSubAction() final; + + protected: // Shouldn't be used by friend classes + virtual ~HTMLEditor(); + + /** + * InitEditorContentAndSelection() may insert `<br>` elements and padding + * `<br>` elements if they are required for `<body>` or document element. + * And collapse selection at the end if there is no selection ranges. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InitEditorContentAndSelection(); + + /** + * Collapse `Selection` to the last leaf content of the <body> or the document + * element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + CollapseSelectionToEndOfLastLeafNodeOfDocument() const; + + MOZ_CAN_RUN_SCRIPT nsresult SelectAllInternal() final; + + [[nodiscard]] Element* ComputeEditingHostInternal( + const nsIContent* aContent, LimitInBodyElement aLimitInBodyElement) const; + + /** + * Creates a range with just the supplied node and appends that to the + * selection. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + AppendContentToSelectionAsRange(nsIContent& aContent); + + /** + * When you are using AppendContentToSelectionAsRange(), call this first to + * start a new selection. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ClearSelection(); + + /** + * SelectContentInternal() sets Selection to aContentToSelect to + * aContentToSelect + 1 in parent of aContentToSelect. + * + * @param aContentToSelect The content which should be selected. + */ + MOZ_CAN_RUN_SCRIPT nsresult + SelectContentInternal(nsIContent& aContentToSelect); + + /** + * GetInclusiveAncestorByTagNameAtSelection() looks for an element node whose + * name matches aTagName from anchor node of Selection to <body> element. + * + * @param aTagName The tag name which you want to look for. + * Must not be nsGkAtoms::_empty. + * If nsGkAtoms::list, the result may be <ul>, <ol> or + * <dl> element. + * If nsGkAtoms::td, the result may be <td> or <th>. + * If nsGkAtoms::href, the result may be <a> element + * which has "href" attribute with non-empty value. + * If nsGkAtoms::anchor, the result may be <a> 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 <body> element. + * + * @param aTagName The tag name which you want to look for. + * Must not be nsGkAtoms::_empty. + * If nsGkAtoms::list, the result may be <ul>, <ol> or + * <dl> element. + * If nsGkAtoms::td, the result may be <td> or <th>. + * If nsGkAtoms::href, the result may be <a> element + * which has "href" attribute with non-empty value. + * If nsGkAtoms::anchor, the result may be <a> which + * has "name" attribute with non-empty value. + * @param aContent Start node to look for the element. This should + * not be an orphan node. + * @return If an element which matches aTagName, returns + * an Element. Otherwise, nullptr. + */ + Element* GetInclusiveAncestorByTagNameInternal( + const nsStaticAtom& aTagName, const nsIContent& aContent) const; + + /** + * GetSelectedElement() returns a "selected" element node. "selected" means: + * - there is only one selection range + * - the range starts from an element node or in an element + * - the range ends at immediately after same element + * - and the range does not include any other element nodes. + * Additionally, only when aTagName is nsGkAtoms::href, this thinks that an + * <a> element which has non-empty "href" attribute includes the range, the + * <a> 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 <a> element which + * has non-empty "href" attribute or nullptr. + * If nsGkAtoms::anchor, this returns an <a> 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<Element> GetSelectedElement(const nsAtom* aTagName, + ErrorResult& aRv); + + /** + * GetFirstTableRowElement() returns the first <tr> element in the most + * nearest ancestor of aTableOrElementInTable or itself. + * When aTableOrElementInTable is neither <table> nor in a <table> element, + * returns NS_ERROR_FAILURE. However, if <table> does not have <tr> element, + * returns nullptr. + * + * @param aTableOrElementInTable <table> element or another element. + * If this is a <table> element, returns + * first <tr> element in it. Otherwise, + * returns first <tr> element in nearest + * ancestor <table> element. + */ + Result<RefPtr<Element>, nsresult> GetFirstTableRowElement( + const Element& aTableOrElementInTable) const; + + /** + * GetNextTableRowElement() returns next <tr> element of aTableRowElement. + * This won't cross <table> element boundary but may cross table section + * elements like <tbody>. + * Note that if given element is <tr> but there is no next <tr> element, this + * returns nullptr but does not return error. + * + * @param aTableRowElement A <tr> element. + */ + Result<RefPtr<Element>, nsresult> GetNextTableRowElement( + const Element& aTableRowElement) const; + + struct CellData; + + /** + * CellIndexes store both row index and column index of a table cell. + */ + struct MOZ_STACK_CLASS CellIndexes final { + int32_t mRow; + int32_t mColumn; + + /** + * This constructor initializes mRowIndex and mColumnIndex with indexes of + * aCellElement. + * + * @param aCellElement An <td> or <th> element. + */ + MOZ_CAN_RUN_SCRIPT CellIndexes(Element& aCellElement, PresShell* aPresShell) + : mRow(-1), mColumn(-1) { + Update(aCellElement, aPresShell); + } + + /** + * Update mRowIndex and mColumnIndex with indexes of aCellElement. + * + * @param See above. + */ + MOZ_CAN_RUN_SCRIPT void Update(Element& aCellElement, + PresShell* aPresShell); + + /** + * This constructor initializes mRowIndex and mColumnIndex with indexes of + * cell element which contains anchor of Selection. + * + * @param aHTMLEditor The editor which creates the instance. + * @param aSelection The Selection for the editor. + */ + MOZ_CAN_RUN_SCRIPT CellIndexes(HTMLEditor& aHTMLEditor, + Selection& aSelection) + : mRow(-1), mColumn(-1) { + Update(aHTMLEditor, aSelection); + } + + /** + * Update mRowIndex and mColumnIndex with indexes of cell element which + * contains anchor of Selection. + * + * @param See above. + */ + MOZ_CAN_RUN_SCRIPT void Update(HTMLEditor& aHTMLEditor, + Selection& aSelection); + + bool operator==(const CellIndexes& aOther) const { + return mRow == aOther.mRow && mColumn == aOther.mColumn; + } + bool operator!=(const CellIndexes& aOther) const { + return mRow != aOther.mRow || mColumn != aOther.mColumn; + } + + [[nodiscard]] bool isErr() const { return mRow < 0 || mColumn < 0; } + + private: + CellIndexes() : mRow(-1), mColumn(-1) {} + CellIndexes(int32_t aRowIndex, int32_t aColumnIndex) + : mRow(aRowIndex), mColumn(aColumnIndex) {} + + friend struct CellData; + }; + + struct MOZ_STACK_CLASS CellData final { + MOZ_KNOWN_LIVE RefPtr<Element> mElement; + // Current indexes which this is initialized with. + CellIndexes mCurrent; + // First column/row indexes of the cell. When current position is spanned + // from other column/row, this value becomes different from mCurrent. + CellIndexes mFirst; + // Computed rowspan/colspan values which are specified to the cell. + // Note that if the cell has larger rowspan/colspan value than actual + // table size, these values are the larger values. + int32_t mRowSpan = -1; + int32_t mColSpan = -1; + // Effective rowspan/colspan value at the index. For example, if first + // cell element in first row has rowspan="3", then, if this is initialized + // with 0-0 indexes, effective rowspan is 3. However, if this is + // initialized with 1-0 indexes, effective rowspan is 2. + int32_t mEffectiveRowSpan = -1; + int32_t mEffectiveColSpan = -1; + // mIsSelected is set to true if mElement itself or its parent <tr> or + // <table> is selected. Otherwise, e.g., the cell just contains selection + // range, this is set to false. + bool mIsSelected = false; + + CellData() = delete; + + /** + * This returns an instance which is initialized with a <table> element and + * both row and column index to specify a cell element. + */ + [[nodiscard]] static CellData AtIndexInTableElement( + const HTMLEditor& aHTMLEditor, const Element& aTableElement, + int32_t aRowIndex, int32_t aColumnIndex); + [[nodiscard]] static CellData AtIndexInTableElement( + const HTMLEditor& aHTMLEditor, const Element& aTableElement, + const CellIndexes& aIndexes) { + MOZ_ASSERT(!aIndexes.isErr()); + return AtIndexInTableElement(aHTMLEditor, aTableElement, aIndexes.mRow, + aIndexes.mColumn); + } + + /** + * Treated as error if fails to compute current index or first index of the + * cell. Note that even if the cell is not found due to no corresponding + * frame at current index, it's not an error situation. + */ + [[nodiscard]] bool isOk() const { return !isErr(); } + [[nodiscard]] bool isErr() const { return mFirst.isErr(); } + + /** + * FailedOrNotFound() returns true if this failed to initialize/update + * or succeeded but found no cell element. + */ + [[nodiscard]] bool FailedOrNotFound() const { return isErr() || !mElement; } + + /** + * IsSpannedFromOtherRowOrColumn(), IsSpannedFromOtherColumn and + * IsSpannedFromOtherRow() return true if there is no cell element + * at the index because of spanning from other row and/or column. + */ + [[nodiscard]] bool IsSpannedFromOtherRowOrColumn() const { + return mElement && mCurrent != mFirst; + } + [[nodiscard]] bool IsSpannedFromOtherColumn() const { + return mElement && mCurrent.mColumn != mFirst.mColumn; + } + [[nodiscard]] bool IsSpannedFromOtherRow() const { + return mElement && mCurrent.mRow != mFirst.mRow; + } + [[nodiscard]] bool IsNextColumnSpannedFromOtherColumn() const { + return mElement && mCurrent.mColumn + 1 < NextColumnIndex(); + } + + /** + * NextColumnIndex() and NextRowIndex() return column/row index of + * next cell. Note that this does not check whether there is next + * cell or not actually. + */ + [[nodiscard]] int32_t NextColumnIndex() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mCurrent.mColumn + mEffectiveColSpan; + } + [[nodiscard]] int32_t NextRowIndex() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mCurrent.mRow + mEffectiveRowSpan; + } + + /** + * LastColumnIndex() and LastRowIndex() return column/row index of + * column/row which is spanned by the cell. + */ + [[nodiscard]] int32_t LastColumnIndex() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return NextColumnIndex() - 1; + } + [[nodiscard]] int32_t LastRowIndex() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return NextRowIndex() - 1; + } + + /** + * NumberOfPrecedingColmuns() and NumberOfPrecedingRows() return number of + * preceding columns/rows if current index is spanned from other column/row. + * Otherwise, i.e., current point is not spanned form other column/row, + * returns 0. + */ + [[nodiscard]] int32_t NumberOfPrecedingColmuns() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mCurrent.mColumn - mFirst.mColumn; + } + [[nodiscard]] int32_t NumberOfPrecedingRows() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mCurrent.mRow - mFirst.mRow; + } + + /** + * NumberOfFollowingColumns() and NumberOfFollowingRows() return + * number of remaining columns/rows if the cell spans to other + * column/row. + */ + [[nodiscard]] int32_t NumberOfFollowingColumns() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mEffectiveColSpan - 1; + } + [[nodiscard]] int32_t NumberOfFollowingRows() const { + if (NS_WARN_IF(FailedOrNotFound())) { + return -1; + } + return mEffectiveRowSpan - 1; + } + + private: + explicit CellData(int32_t aCurrentRowIndex, int32_t aCurrentColumnIndex, + int32_t aFirstRowIndex, int32_t aFirstColumnIndex) + : mCurrent(aCurrentRowIndex, aCurrentColumnIndex), + mFirst(aFirstRowIndex, aFirstColumnIndex) {} + explicit CellData(Element& aElement, int32_t aRowIndex, + int32_t aColumnIndex, nsTableCellFrame& aTableCellFrame, + nsTableWrapperFrame& aTableWrapperFrame); + + [[nodiscard]] static CellData Error(int32_t aRowIndex, + int32_t aColumnIndex) { + return CellData(aRowIndex, aColumnIndex, -1, -1); + } + [[nodiscard]] static CellData NotFound(int32_t aRowIndex, + int32_t aColumnIndex) { + return CellData(aRowIndex, aColumnIndex, aRowIndex, aColumnIndex); + } + }; + + /** + * TableSize stores and computes number of rows and columns of a <table> + * element. + */ + struct MOZ_STACK_CLASS TableSize final { + int32_t mRowCount; + int32_t mColumnCount; + + TableSize() = delete; + + /** + * @param aHTMLEditor The editor which creates the instance. + * @param aTableOrElementInTable If a <table> element, computes number + * of rows and columns of it. + * If another element in a <table> element, + * computes number of rows and columns + * of nearest ancestor <table> element. + * Otherwise, i.e., non-<table> element + * not in <table>, returns error. + */ + [[nodiscard]] static Result<TableSize, nsresult> Create( + HTMLEditor& aHTMLEditor, Element& aTableOrElementInTable); + + [[nodiscard]] bool IsEmpty() const { return !mRowCount || !mColumnCount; } + + private: + TableSize(int32_t aRowCount, int32_t aColumCount) + : mRowCount(aRowCount), mColumnCount(aColumCount) {} + }; + + /** + * GetTableCellElementAt() returns a <td> or <th> element of aTableElement + * if there is a cell at the indexes. + * + * @param aTableElement Must be a <table> 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 <table>. + * Returns nullptr without error if the indexes + * are out of bounds. + */ + [[nodiscard]] inline Element* GetTableCellElementAt( + Element& aTableElement, const CellIndexes& aCellIndexes) const; + [[nodiscard]] Element* GetTableCellElementAt(Element& aTableElement, + int32_t aRowIndex, + int32_t aColumnIndex) const; + + /** + * GetSelectedOrParentTableElement() returns <td>, <th>, <tr> or <table> + * 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 <table>, returns it. + * #3 if the first selection range does not select a cell and + * the selection anchor refers a <tr>, returns it. + * #4 if the first selection range does not select a cell and + * the selection anchor refers a <td>, returns it. + * #5 otherwise, nearest ancestor <td> or <th> element of the + * selection anchor if there is. + * In #1 and #4, *aIsCellSelected will be set to true (i.e,, when + * a selection range selects a cell element). + */ + Result<RefPtr<Element>, nsresult> GetSelectedOrParentTableElement( + bool* aIsCellSelected = nullptr) const; + + /** + * GetFirstSelectedCellElementInTable() returns <td> or <th> element at + * first selection (using GetSelectedOrParentTableElement). If found cell + * element is not in <table> or <tr> element, this returns nullptr. + */ + Result<RefPtr<Element>, nsresult> GetFirstSelectedCellElementInTable() const; + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePaste( + AutoEditActionDataSetter& aEditActionData, int32_t aClipboardType) final; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePasteAsQuotation( + AutoEditActionDataSetter& aEditActionData, int32_t aClipboardType) final; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + HandlePasteTransferable(AutoEditActionDataSetter& aEditActionData, + nsITransferable& aTransferable) final; + + /** + * PasteInternal() pasts text with replacing selected content. + * This tries to dispatch ePaste event first. If its defaultPrevent() is + * called, this does nothing but returns NS_OK. + * + * @param aClipboardType nsIClipboard::kGlobalClipboard or + * nsIClipboard::kSelectionClipboard. + */ + MOZ_CAN_RUN_SCRIPT nsresult PasteInternal(int32_t aClipboardType); + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + InsertWithQuotationsAsSubAction(const nsAString& aQuotedText) final; + + /** + * InsertAsCitedQuotationInternal() inserts a <blockquote> element whose + * cite attribute is aCitation and whose content is aQuotedText. + * Note that this shouldn't be called when IsPlaintextMailComposer() is true. + * + * @param aQuotedText HTML source if aInsertHTML is true. Otherwise, + * plain text. This is inserted into new <blockquote> + * element. + * @param aCitation cite attribute value of new <blockquote> 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 <blockquote> 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 aContent The content node to insert. + * @param aPointToInsert Insertion point. + * @param aSplitAtEdges Splitting can result in empty nodes? + */ + template <typename NodeType> + [[nodiscard]] MOZ_CAN_RUN_SCRIPT + Result<CreateNodeResultBase<NodeType>, nsresult> + InsertNodeIntoProperAncestorWithTransaction( + NodeType& aContent, const EditorDOMPoint& aPointToInsert, + SplitAtEdges aSplitAtEdges); + + /** + * InsertTextWithQuotationsInternal() replaces selection with new content. + * First, this method splits aStringToInsert to multiple chunks which start + * with non-linebreaker except first chunk and end with a linebreaker except + * last chunk. Then, each chunk starting with ">" is inserted after wrapping + * with <span _moz_quote="true">, and each chunk not starting with ">" is + * inserted as normal text. + */ + MOZ_CAN_RUN_SCRIPT nsresult + InsertTextWithQuotationsInternal(const nsAString& aStringToInsert); + + /** + * ReplaceContainerWithTransactionInternal() is implementation of + * ReplaceContainerWithTransaction() and + * ReplaceContainerAndCloneAttributesWithTransaction(). + * + * @param aOldContainer The element which will be replaced with new + * element. + * @param aTagName The name of new element node. + * @param aAttribute Attribute name which will be set to the new + * element. This will be ignored if + * aCloneAllAttributes is set to true. + * @param aAttributeValue Attribute value which will be set to + * aAttribute. + * @param aCloneAllAttributes If true, all attributes of aOldContainer will + * be copied to the new element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + ReplaceContainerWithTransactionInternal(Element& aOldContainer, + const nsAtom& aTagName, + const nsAtom& aAttribute, + const nsAString& aAttributeValue, + bool aCloneAllAttributes); + + /** + * DeleteSelectionAndCreateElement() creates a element whose name is aTag. + * And insert it into the DOM tree after removing the selected content. + * + * @param aTag The element name to be created. + * @param aInitializer A function to initialize the new element before + * or after (depends on the pref) connecting the + * element into the DOM tree. Note that this should + * not touch outside given element because doing it + * would break range updater's result. + */ + MOZ_CAN_RUN_SCRIPT Result<RefPtr<Element>, nsresult> + DeleteSelectionAndCreateElement( + nsAtom& aTag, + const InitializeInsertingElement& aInitializer = DoNothingForNewElement); + + /** + * This method first deletes the selection, if it's not collapsed. Then if + * the selection lies in a CharacterData node, it splits it. If the + * selection is at this point collapsed in a CharacterData node, it's + * adjusted to be collapsed right before or after the node instead (which is + * always possible, since the node was split). + */ + MOZ_CAN_RUN_SCRIPT nsresult DeleteSelectionAndPrepareToCreateNode(); + + /** + * PrepareToInsertBRElement() returns a point where new <br> element should + * be inserted. If aPointToInsert points middle of a text node, this method + * splits the text node and returns the point before right node. + * + * @param aPointToInsert Candidate point to insert new <br> element. + * @return Computed point to insert new <br> element. + * If something failed, this return error. + */ + MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> PrepareToInsertBRElement( + const EditorDOMPoint& aPointToInsert); + + /** + * IndentAsSubAction() indents the content around Selection. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + IndentAsSubAction(const Element& aEditingHost); + + /** + * OutdentAsSubAction() outdents the content around Selection. + * + * @param aEditingHost The editing host. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + OutdentAsSubAction(const Element& aEditingHost); + + MOZ_CAN_RUN_SCRIPT nsresult LoadHTML(const nsAString& aInputString); + + /** + * UpdateMetaCharsetWithTransaction() scans all <meta> elements in the + * document and if and only if there is a <meta> element having `httpEquiv` + * attribute and whose value includes `content-type`, updates its `content` + * attribute value to aCharacterSet. + */ + MOZ_CAN_RUN_SCRIPT bool UpdateMetaCharsetWithTransaction( + Document& aDocument, const nsACString& aCharacterSet); + + /** + * SetInlinePropertiesAsSubAction() stores new styles with + * mPendingStylesToApplyToNewContent if `Selection` is collapsed. Otherwise, + * applying the styles to all selected contents. + * + * @param aStylesToSet The styles which should be applied to the + * selected content. + */ + template <size_t N> + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAsSubAction( + const AutoTArray<EditorInlineStyleAndValue, N>& aStylesToSet); + + /** + * SetInlinePropertiesAroundRanges() applying the styles to the ranges even if + * the ranges are collapsed. + */ + template <size_t N> + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAroundRanges( + AutoRangeArray& aRanges, + const AutoTArray<EditorInlineStyleAndValue, N>& aStylesToSet, + const Element& aEditingHost); + + /** + * RemoveInlinePropertiesAsSubAction() removes specified styles from + * mPendingStylesToApplyToNewContent if `Selection` is collapsed. Otherwise, + * removing the style. + * + * @param aStylesToRemove Styles to remove from the selected contents. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveInlinePropertiesAsSubAction( + const nsTArray<EditorInlineStyle>& aStylesToRemove); + + /** + * Helper method to call RemoveInlinePropertiesAsSubAction(). If you want to + * remove other elements to remove the style completely, this will append + * related elements of aStyleToRemove and aStyleToRemove itself to the array. + * E.g., nsGkAtoms::strong and nsGkAtoms::b will be appended if aStyleToRemove + * is nsGkAtoms::b. + */ + void AppendInlineStyleAndRelatedStyle( + const EditorInlineStyle& aStyleToRemove, + nsTArray<EditorInlineStyle>& aStylesToRemove) const; + + /** + * ReplaceHeadContentsWithSourceWithTransaction() replaces all children of + * <head> element with given source code. This is undoable. + * + * @param aSourceToInsert HTML source fragment to replace the children + * of <head> 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); + + /** + * This sets background on the appropriate container element (table, cell,) + * or calls to set the page background. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetBlockBackgroundColorWithCSSAsSubAction(const nsAString& aColor); + MOZ_CAN_RUN_SCRIPT nsresult + SetHTMLBackgroundColorWithTransaction(const nsAString& aColor); + + MOZ_CAN_RUN_SCRIPT_BOUNDARY void InitializeSelectionAncestorLimit( + nsIContent& aAncestorLimit) const final; + + /** + * Make the given selection span the entire document. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SelectEntireDocument() final; + + /** + * Use this to assure that selection is set after attribute nodes when + * trying to collapse selection at begining of a block node + * e.g., when setting at beginning of a table cell + * This will stop at a table, however, since we don't want to + * "drill down" into nested tables. + */ + MOZ_CAN_RUN_SCRIPT void CollapseSelectionToDeepestNonTableFirstChild( + nsINode* aNode); + /** + * MaybeCollapseSelectionAtFirstEditableNode() may collapse selection at + * proper position to staring to edit. If there is a non-editable node + * before any editable text nodes or inline elements which can have text + * nodes as their children, collapse selection at start of the editing + * host. If there is an editable text node which is not collapsed, collapses + * selection at the start of the text node. If there is an editable inline + * element which cannot have text nodes as its child, collapses selection at + * before the element node. Otherwise, collapses selection at start of the + * editing host. + * + * @param aIgnoreIfSelectionInEditingHost + * This method does nothing if selection is in the + * editing host except if it's collapsed at start of + * the editing host. + * Note that if selection ranges were outside of + * current selection limiter, selection was collapsed + * at the start of the editing host therefore, if + * you call this with setting this to true, you can + * keep selection ranges if user has already been + * changed. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + MaybeCollapseSelectionAtFirstEditableNode( + bool aIgnoreIfSelectionInEditingHost) const; + + class BlobReader final { + using AutoEditActionDataSetter = EditorBase::AutoEditActionDataSetter; + + public: + MOZ_CAN_RUN_SCRIPT BlobReader(dom::BlobImpl* aBlob, HTMLEditor* aHTMLEditor, + SafeToInsertData aSafeToInsertData, + const EditorDOMPoint& aPointToInsert, + DeleteSelectedContent aDeleteSelectedContent); + + 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<dom::BlobImpl> mBlob; + RefPtr<HTMLEditor> mHTMLEditor; + RefPtr<dom::DataTransfer> mDataTransfer; + EditorDOMPoint mPointToInsert; + EditAction mEditAction; + SafeToInsertData mSafeToInsertData; + DeleteSelectedContent mDeleteSelectedContent; + bool mNeedsToDispatchBeforeInputEvent; + }; + + void CreateEventListeners() final; + nsresult InstallEventListeners() final; + + bool ShouldReplaceRootElement() const; + MOZ_CAN_RUN_SCRIPT void NotifyRootChanged(); + Element* GetBodyElement() const; + + /** + * Get the focused node of this editor. + * @return If the editor has focus, this returns the focused node. + * Otherwise, returns null. + */ + nsINode* GetFocusedNode() const; + + already_AddRefed<Element> GetInputEventTargetElement() const final; + + /** + * Return TRUE if aElement is a table-related elemet and caret was set. + */ + MOZ_CAN_RUN_SCRIPT bool SetCaretInTableCell(dom::Element* aElement); + + /** + * HandleTabKeyPressInTable() handles "Tab" key press in table if selection + * is in a `<table>` element. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult> + 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 <td> elements at aPointToInsert. + * Note that this simply inserts <td> elements, i.e., colspan and rowspan + * around the cell containing selection are not modified. So, for example, + * adding a cell to rectangular table changes non-rectangular table. + * And if the cell containing selection is at left of row-spanning cell, + * it may be moved to right side of the row-spanning cell after inserting + * some cell elements before it. Similarly, colspan won't be adjusted + * for keeping table rectangle. + * Finally, puts caret into previous cell of the insertion point or the + * first inserted cell if aPointToInsert is start of the row. + * + * @param aPointToInsert The place to insert one or more cell + * elements. The container must be a + * <tr> element. + * @param aNumberOfCellsToInsert Number of cells to insert. + * @return The first inserted cell element and + * start of the last inserted cell element + * as a point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateElementResult, nsresult> + InsertTableCellsWithTransaction(const EditorDOMPoint& aPointToInsert, + int32_t aNumberOfCellsToInsert); + + /** + * InsertTableColumnsWithTransaction() inserts cell elements to every rows + * at same column index as the cell specified by aPointToInsert. + * + * @param aNumberOfColumnsToInsert Number of columns to insert. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertTableColumnsWithTransaction( + const EditorDOMPoint& aPointToInsert, int32_t aNumberOfColumnsToInsert); + + /** + * InsertTableRowsWithTransaction() inserts <tr> elements before or after + * aCellElement. When aCellElement spans rows and aInsertPosition is + * eAfterSelectedCell, new rows will be inserted after the most-bottom row + * which contains the cell. + * + * @param aCellElement The cell element pinting where this will + * insert a row before or after. + * @param aNumberOfRowsToInsert Number of rows to insert. + * @param aInsertPosition Before or after the target cell which + * contains first selection range. + */ + MOZ_CAN_RUN_SCRIPT nsresult InsertTableRowsWithTransaction( + Element& aCellElement, int32_t aNumberOfRowsToInsert, + InsertPosition aInsertPosition); + + /** + * Insert a new cell after or before supplied aCell. + * Optional: If aNewCell supplied, returns the newly-created cell (addref'd, + * of course) + * This doesn't change or use the current selection. + */ + MOZ_CAN_RUN_SCRIPT nsresult InsertCell(Element* aCell, int32_t aRowSpan, + int32_t aColSpan, bool aAfter, + bool aIsHeader, Element** aNewCell); + + /** + * DeleteSelectedTableColumnsWithTransaction() removes cell elements which + * belong to same columns of selected cell elements. + * If only one cell element is selected or first selection range is + * in a cell, removes cell elements which belong to same column. + * If 2 or more cell elements are selected, removes cell elements which + * belong to any of all selected columns. In this case, + * aNumberOfColumnsToDelete is ignored. + * If there is no selection ranges, returns error. + * If selection is not in a cell element, this does not return error, + * just does nothing. + * WARNING: This does not remove <col> nor <colgroup> 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 <col> nor <colgroup> elements. + * + * @param aTableElement The <table> 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 <tr> elements. + * If only one cell element is selected or first selection range is + * in a cell, removes <tr> elements starting from a <tr> element + * containing the selected cell or first selection range. + * If 2 or more cell elements are selected, all <tr> 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 <tr> element whose index in + * the <table> is aRowIndex. + * This method adjusts rowspan attribute value if the <tr> element contains + * cells which spans rows. + * + * @param aTableElement The <table> element which contains the + * <tr> element which you want to remove. + * @param aRowIndex Index of the <tr> 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 <tr> or <table>, this removes the <tr> or the + * <table> 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<Element> aTargetCell, + RefPtr<Element> aCellToMerge, + bool aDeleteCellToMerge); + + /** + * DeleteTableElementAndChildren() removes aTableElement (and its children) + * from the DOM tree with transaction. + * + * @param aTableElement The <table> element which you want to remove. + */ + MOZ_CAN_RUN_SCRIPT nsresult + DeleteTableElementAndChildrenWithTransaction(Element& aTableElement); + + MOZ_CAN_RUN_SCRIPT nsresult SetColSpan(Element* aCell, int32_t aColSpan); + MOZ_CAN_RUN_SCRIPT nsresult SetRowSpan(Element* aCell, int32_t aRowSpan); + + /** + * Helper used to get nsTableWrapperFrame for a table. + */ + static nsTableWrapperFrame* GetTableFrame(const Element* aTable); + + /** + * GetNumberOfCellsInRow() returns number of actual cell elements in the row. + * If some cells appear by "rowspan" in other rows, they are ignored. + * + * @param aTableElement The <table> element. + * @param aRowIndex Valid row index in aTableElement. This method + * counts cell elements in the row. + * @return -1 if this meets unexpected error. + * Otherwise, number of cells which this method found. + */ + int32_t GetNumberOfCellsInRow(Element& aTableElement, int32_t aRowIndex); + + /** + * Test if all cells in row or column at given index are selected. + */ + bool AllCellsInRowSelected(Element* aTable, int32_t aRowIndex, + int32_t aNumberOfColumns); + bool AllCellsInColumnSelected(Element* aTable, int32_t aColIndex, + int32_t aNumberOfRows); + + bool IsEmptyCell(Element* aCell); + + /** + * Most insert methods need to get the same basic context data. + * Any of the pointers may be null if you don't need that datum (for more + * efficiency). + * Input: *aCell is a known cell, + * if null, cell is obtained from the anchor node of the selection. + * Returns NS_EDITOR_ELEMENT_NOT_FOUND if cell is not found even if aCell is + * null. + */ + MOZ_CAN_RUN_SCRIPT nsresult GetCellContext(Element** aTable, Element** aCell, + nsINode** aCellParent, + int32_t* aCellOffset, + int32_t* aRowIndex, + int32_t* aColIndex); + + nsresult GetCellSpansAt(Element* aTable, int32_t aRowIndex, int32_t aColIndex, + int32_t& aActualRowSpan, int32_t& aActualColSpan); + + MOZ_CAN_RUN_SCRIPT nsresult SplitCellIntoColumns( + Element* aTable, int32_t aRowIndex, int32_t aColIndex, + int32_t aColSpanLeft, int32_t aColSpanRight, Element** aNewCell); + + MOZ_CAN_RUN_SCRIPT nsresult SplitCellIntoRows( + Element* aTable, int32_t aRowIndex, int32_t aColIndex, + int32_t aRowSpanAbove, int32_t aRowSpanBelow, Element** aNewCell); + + MOZ_CAN_RUN_SCRIPT nsresult CopyCellBackgroundColor(Element* aDestCell, + Element* aSourceCell); + + /** + * Reduce rowspan/colspan when cells span into nonexistent rows/columns. + */ + MOZ_CAN_RUN_SCRIPT nsresult FixBadRowSpan(Element* aTable, int32_t aRowIndex, + int32_t& aNewRowCount); + MOZ_CAN_RUN_SCRIPT nsresult FixBadColSpan(Element* aTable, int32_t aColIndex, + int32_t& aNewColCount); + + /** + * XXX NormalizeTableInternal() is broken. If it meets a cell which has + * bigger or smaller rowspan or colspan than actual number of cells, + * this always failed to scan the table. Therefore, this does nothing + * when the table should be normalized. + * + * @param aTableOrElementInTable An element which is in a <table> element + * or <table> element itself. Otherwise, + * this returns NS_OK but does nothing. + */ + MOZ_CAN_RUN_SCRIPT nsresult + NormalizeTableInternal(Element& aTableOrElementInTable); + + /** + * Fallback method: Call this after using ClearSelection() and you + * failed to set selection to some other content in the document. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetSelectionAtDocumentStart(); + + // Methods for handling plaintext quotations + MOZ_CAN_RUN_SCRIPT nsresult PasteAsPlaintextQuotation(int32_t aSelectionType); + + /** + * Insert a string as quoted text, replacing the selected text (if any). + * @param aQuotedText The string to insert. + * @param aAddCites Whether to prepend extra ">" to each line + * (usually true, unless those characters + * have already been added.) + * @return aNodeInserted The node spanning the insertion, if applicable. + * If aAddCites is false, this will be null. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsPlaintextQuotation( + const nsAString& aQuotedText, bool aAddCites, nsINode** aNodeInserted); + + /** + * InsertObject() inserts given object at aPointToInsert. + * + * @param aType one of kFileMime, kJPEGImageMime, kJPGImageMime, + * kPNGImageMime, kGIFImageMime. + */ + MOZ_CAN_RUN_SCRIPT nsresult InsertObject( + const nsACString& aType, nsISupports* aObject, + SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert, + DeleteSelectedContent aDeleteSelectedContent); + + class HTMLTransferablePreparer; + nsresult PrepareHTMLTransferable(nsITransferable** aTransferable) const; + + enum class HavePrivateHTMLFlavor { No, Yes }; + MOZ_CAN_RUN_SCRIPT nsresult InsertFromTransferableAtSelection( + nsITransferable* aTransferable, const nsAString& aContextStr, + const nsAString& aInfoStr, HavePrivateHTMLFlavor aHavePrivateHTMLFlavor); + + /** + * InsertFromDataTransfer() is called only when user drops data into + * this editor. Don't use this method for other purposes. + * + * @param aIndex index of aDataTransfer's item to insert. + */ + MOZ_CAN_RUN_SCRIPT nsresult InsertFromDataTransfer( + const dom::DataTransfer* aDataTransfer, uint32_t aIndex, + nsIPrincipal* aSourcePrincipal, const EditorDOMPoint& aDroppedAt, + DeleteSelectedContent aDeleteSelectedContent); + + static HavePrivateHTMLFlavor ClipboardHasPrivateHTMLFlavor( + nsIClipboard* clipboard); + + /** + * CF_HTML: + * <https://docs.microsoft.com/en-us/windows/win32/dataxchg/html-clipboard-format>. + * + * @param[in] aCfhtml a CF_HTML string as defined above. + * @param[out] aStuffToPaste the fragment, excluding context. + * @param[out] aCfcontext the context, excluding the fragment, including a + * marker (`kInsertionCookie`) indicating where the + * fragment begins. + */ + nsresult ParseCFHTML(const nsCString& aCfhtml, char16_t** aStuffToPaste, + char16_t** aCfcontext); + + /** + * AutoHTMLFragmentBoundariesFixer fixes both edges of topmost child contents + * which are created with SubtreeContentIterator. + */ + class MOZ_STACK_CLASS AutoHTMLFragmentBoundariesFixer final { + public: + /** + * @param aArrayOfTopMostChildContents + * [in/out] The topmost child contents which will be + * inserted into the DOM tree. Both edges, i.e., + * first node and last node in this array will be + * checked whether they can be inserted into + * another DOM tree. If not, it'll replaces some + * orphan nodes around nodes with proper parent. + */ + explicit AutoHTMLFragmentBoundariesFixer( + nsTArray<OwningNonNull<nsIContent>>& 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 + * `<table>` element, looks for topmost list element or `<table>` element + * with `CollectTableAndAnyListElementsOfInclusiveAncestorsAt()` and + * `GetMostDistantAncestorListOrTableElement()`. Then, checks + * whether some nodes are in aArrayOfTopMostChildContents are the topmost + * list/table element or its descendant and if so, removes the nodes from + * aArrayOfTopMostChildContents and inserts the list/table element instead. + * Then, aArrayOfTopMostChildContents won't start/end with list-item nor + * table cells. + */ + enum class StartOrEnd { start, end }; + void EnsureBeginsOrEndsWithValidContent( + StartOrEnd aStartOrEnd, + nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents) + const; + + /** + * CollectTableAndAnyListElementsOfInclusiveAncestorsAt() collects list + * elements and table related elements from the inclusive ancestors + * (https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor) of aNode. + */ + static void CollectTableAndAnyListElementsOfInclusiveAncestorsAt( + nsIContent& aContent, + nsTArray<OwningNonNull<Element>>& aOutArrayOfListAndTableElements); + + /** + * GetMostDistantAncestorListOrTableElement() returns a list or a + * `<table>` element which is in + * aInclusiveAncestorsTableOrListElements and they are actually + * valid ancestor of at least one of aArrayOfTopMostChildContents. + */ + static Element* GetMostDistantAncestorListOrTableElement( + const nsTArray<OwningNonNull<nsIContent>>& aArrayOfTopMostChildContents, + const nsTArray<OwningNonNull<Element>>& + aInclusiveAncestorsTableOrListElements); + + /** + * FindReplaceableTableElement() is a helper method of + * EnsureBeginsOrEndsWithValidContent(). If aNodeMaybeInTableElement is + * a descendant of aTableElement, returns aNodeMaybeInTableElement or its + * nearest ancestor whose tag name is `<td>`, `<th>`, `<tr>`, `<thead>`, + * `<tfoot>`, `<tbody>` or `<caption>`. + * + * @param aTableElement Must be a `<table>` element. + * @param aContentMaybeInTableElement A node which may be in aTableElement. + */ + Element* FindReplaceableTableElement( + Element& aTableElement, nsIContent& aContentMaybeInTableElement) const; + + /** + * IsReplaceableListElement() is a helper method of + * EnsureBeginsOrEndsWithValidContent(). If aNodeMaybeInListElement is a + * descendant of aListElement, returns true. Otherwise, false. + * + * @param aListElement Must be a list element. + * @param aContentMaybeInListElement A node which may be in aListElement. + */ + bool IsReplaceableListElement(Element& aListElement, + nsIContent& aContentMaybeInListElement) const; + }; + + /** + * MakeDefinitionListItemWithTransaction() replaces parent list of current + * selection with <dl> or create new <dl> element and creates a definition + * list item whose name is aTagName. + * + * @param aTagName Must be nsGkAtoms::dt or nsGkAtoms::dd. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + MakeDefinitionListItemWithTransaction(nsAtom& aTagName); + + /** + * FormatBlockContainerAsSubAction() inserts a block element whose name + * is aTagName at selection. If selection is not collapsed and aTagName is + * nsGkAtoms::normal or nsGkAtoms::_empty, this removes block containers. + * + * @param aTagName A block level element name. Must NOT be + * nsGkAtoms::dt nor nsGkAtoms::dd. + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + */ + MOZ_CAN_RUN_SCRIPT nsresult FormatBlockContainerAsSubAction( + const nsStaticAtom& aTagName, FormatBlockMode aFormatBlockMode); + + /** + * Increase/decrease the font size of selection. + */ + MOZ_CAN_RUN_SCRIPT nsresult + IncrementOrDecrementFontSizeAsSubAction(FontSize aIncrementOrDecrement); + + /** + * Wrap aContent in <big> or <small> element and make children of + * <font size=n> wrap with <big> or <small> too. Note that if there is + * opposite element for aIncrementOrDecrement, their children will be just + * unwrapped. + * + * @param aDir Whether increase or decrease the font size of aContent. + * @param aContent The content node whose font size will be changed. + * @return A suggest point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + SetFontSizeWithBigOrSmallElement(nsIContent& aContent, + FontSize aIncrementOrDecrement); + + /** + * Adjust font size of font element children recursively with handling + * <big> and <small> elements. + * + * @param aDir Whether increase or decrease the font size of aContent. + * @param aContent The content node whose font size will be changed. + * All descendants will be handled recursively. + * @return A suggest point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + SetFontSizeOfFontElementChildren(nsIContent& aContent, + FontSize aIncrementOrDecrement); + + /** + * Get extended range to select element whose all children are selected by + * aRange. + */ + EditorRawDOMRange GetExtendedRangeWrappingEntirelySelectedElements( + const EditorRawDOMRange& aRange) const; + + /** + * Get extended range to select ancestor <a name> elements. + */ + EditorRawDOMRange GetExtendedRangeWrappingNamedAnchor( + const EditorRawDOMRange& aRange) const; + + // Declared in HTMLEditorNestedClasses.h and defined in HTMLStyleEditor.cpp + class AutoInlineStyleSetter; + + /** + * RemoveStyleInside() removes elements which represent aStyleToRemove + * and removes CSS style. This handles aElement and all its descendants + * (including leaf text nodes) recursively. + * TODO: Rename this to explain that this maybe remove aElement from the DOM + * tree. + * + * @param aSpecifiedStyle Whether the class and style attributes should + * be preserved or discarded. + * @return A suggest point to put caret. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + RemoveStyleInside(Element& aElement, const EditorInlineStyle& aStyleToRemove, + SpecifiedStyle aSpecifiedStyle); + + /** + * CollectEditableLeafTextNodes() collects text nodes in aElement. + */ + void CollectEditableLeafTextNodes( + Element& aElement, nsTArray<OwningNonNull<Text>>& aLeafTextNodes) const; + + /** + * IsRemovableParentStyleWithNewSpanElement() checks whether aStyle of parent + * block can be removed from aContent with creating `<span>` 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<bool, nsresult>` + * is not reasonable because code for accessing the result becomes + * messy. However, anybody must forget to check `Destroyed()` after + * calling this. Which is the way to smart to make every caller + * must check the editor state? + */ + MOZ_CAN_RUN_SCRIPT Result<bool, nsresult> + IsRemovableParentStyleWithNewSpanElement( + nsIContent& aContent, const EditorInlineStyle& aStyle) const; + + /** + * HasStyleOrIdOrClassAttribute() returns true when at least one of + * `style`, `id` or `class` attribute value of aElement is not empty. + */ + static bool HasStyleOrIdOrClassAttribute(Element& aElement); + + /** + * Whether the outer window of the DOM event target has focus or not. + */ + bool OurWindowHasFocus() const; + + class HTMLWithContextInserter; + + /** + * This function is used to insert a string of HTML input optionally with some + * context information into the editable field. The HTML input either comes + * from a transferable object created as part of a drop/paste operation, or + * from the InsertHTML method. We may want the HTML input to be sanitized + * (for example, if it's coming from a transferable object), in which case + * aTrustedInput should be set to false, otherwise, the caller should set it + * to true, which means that the HTML will be inserted in the DOM verbatim. + */ + enum class InlineStylesAtInsertionPoint { + Preserve, // If you want the paste to be affected by local style, e.g., + // for the insertHTML command, use "Preserve" + Clear, // If you want the paste to be keep its own style, e.g., pasting + // from clipboard, use "Clear" + }; + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertHTMLWithContextAsSubAction( + const nsAString& aInputString, const nsAString& aContextStr, + const nsAString& aInfoStr, const nsAString& aFlavor, + SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert, + DeleteSelectedContent aDeleteSelectedContent, + InlineStylesAtInsertionPoint aInlineStylesAtInsertionPoint); + + /** + * sets the position of an element; warning it does NOT check if the + * element is already positioned or not and that's on purpose. + * @param aStyledElement [IN] the element + * @param aX [IN] the x position in pixels. + * @param aY [IN] the y position in pixels. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetTopAndLeftWithTransaction( + nsStyledElement& aStyledElement, int32_t aX, int32_t aY); + + /** + * Reset a selected cell or collapsed selection (the caret) after table + * editing. + * + * @param aTable A table in the document. + * @param aRow The row ... + * @param aCol ... and column defining the cell where we will try to + * place the caret. + * @param aSelected If true, we select the whole cell instead of setting + * caret. + * @param aDirection If cell at (aCol, aRow) is not found, search for + * previous cell in the same column (aPreviousColumn) or + * row (ePreviousRow) or don't search for another cell + * (aNoSearch). If no cell is found, caret is place just + * before table; and if that fails, at beginning of + * document. Thus we generally don't worry about the + * return value and can use the + * AutoSelectionSetterAfterTableEdit stack-based object to + * insure we reset the caret in a table-editing method. + */ + MOZ_CAN_RUN_SCRIPT void SetSelectionAfterTableEdit(Element* aTable, + int32_t aRow, int32_t aCol, + int32_t aDirection, + bool aSelected); + + void RemoveListenerAndDeleteRef(const nsAString& aEvent, + nsIDOMEventListener* aListener, + bool aUseCapture, ManualNACPtr aElement, + PresShell* aPresShell); + void DeleteRefToAnonymousNode(ManualNACPtr aContent, PresShell* aPresShell); + + /** + * RefreshEditingUI() may refresh editing UIs for current Selection, focus, + * etc. If this shows or hides some UIs, it causes reflow. So, this is + * not safe method. + */ + MOZ_CAN_RUN_SCRIPT nsresult RefreshEditingUI(); + + /** + * Returns the offset of an element's frame to its absolute containing block. + */ + nsresult GetElementOrigin(Element& aElement, int32_t& aX, int32_t& aY); + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetPositionAndDimensions( + Element& aElement, int32_t& aX, int32_t& aY, int32_t& aW, int32_t& aH, + int32_t& aBorderLeft, int32_t& aBorderTop, int32_t& aMarginLeft, + int32_t& aMarginTop); + + bool IsInObservedSubtree(nsIContent* aChild); + + void UpdateRootElement(); + + /** + * SetAllResizersPosition() moves all resizers to proper position. + * If the resizers are hidden or replaced with another set of resizers + * while this is running, this returns error. So, callers shouldn't + * keep handling the resizers if this returns error. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetAllResizersPosition(); + + /** + * Shows active resizers around an element's frame + * @param aResizedElement [IN] a DOM Element + */ + MOZ_CAN_RUN_SCRIPT nsresult ShowResizersInternal(Element& aResizedElement); + + /** + * Hide resizers if they are visible. If this is called while there is no + * visible resizers, this does not return error, but does nothing. + */ + nsresult HideResizersInternal(); + + /** + * RefreshResizersInternal() moves resizers to proper position. This does + * nothing if there is no resizing target. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RefreshResizersInternal(); + + ManualNACPtr CreateResizer(int16_t aLocation, nsIContent& aParentContent); + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetAnonymousElementPositionWithoutTransaction(nsStyledElement& aStyledElement, + int32_t aX, int32_t aY); + + ManualNACPtr CreateShadow(nsIContent& aParentContent, + Element& aOriginalObject); + + /** + * SetShadowPosition() moves the shadow element to proper position. + * + * @param aShadowElement Must be mResizingShadow or mPositioningShadow. + * @param aElement The element which has the shadow. + * @param aElementX Left of aElement. + * @param aElementY Top of aElement. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetShadowPosition(Element& aShadowElement, Element& aElement, + int32_t aElementLeft, int32_t aElementTop); + + ManualNACPtr CreateResizingInfo(nsIContent& aParentContent); + MOZ_CAN_RUN_SCRIPT nsresult SetResizingInfoPosition(int32_t aX, int32_t aY, + int32_t aW, int32_t aH); + + enum class ResizeAt { + eX, + eY, + eWidth, + eHeight, + }; + [[nodiscard]] int32_t GetNewResizingIncrement(int32_t aX, int32_t aY, + ResizeAt aResizeAt) const; + + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult StartResizing(Element& aHandle); + int32_t GetNewResizingX(int32_t aX, int32_t aY); + int32_t GetNewResizingY(int32_t aX, int32_t aY); + int32_t GetNewResizingWidth(int32_t aX, int32_t aY); + int32_t GetNewResizingHeight(int32_t aX, int32_t aY); + void HideShadowAndInfo(); + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetFinalSizeWithTransaction(int32_t aX, int32_t aY); + void SetResizeIncrements(int32_t aX, int32_t aY, int32_t aW, int32_t aH, + bool aPreserveRatio); + + /** + * HideAnonymousEditingUIs() forcibly hides all editing UIs (resizers, + * inline-table-editing UI, absolute positioning UI). + */ + void HideAnonymousEditingUIs(); + + /** + * HideAnonymousEditingUIsIfUnnecessary() hides all editing UIs if some of + * visible UIs are now unnecessary. + */ + void HideAnonymousEditingUIsIfUnnecessary(); + + /** + * sets the z-index of an element. + * @param aElement [IN] the element + * @param aZorder [IN] the z-index + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + SetZIndexWithTransaction(nsStyledElement& aElement, int32_t aZIndex); + + /** + * shows a grabber attached to an arbitrary element. The grabber is an image + * positioned on the left hand side of the top border of the element. Draggin + * and dropping it allows to change the element's absolute position in the + * document. See chrome://editor/content/images/grabber.gif + * @param aElement [IN] the element + */ + MOZ_CAN_RUN_SCRIPT nsresult ShowGrabberInternal(Element& aElement); + + /** + * Setting grabber to proper position for current mAbsolutelyPositionedObject. + * For example, while an element has grabber, the element may be resized + * or repositioned by script or something. Then, you need to reset grabber + * position with this. + */ + [[nodiscard]] 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 SnapToGrid(int32_t& newX, int32_t& newY) const; + nsresult GrabberClicked(); + MOZ_CAN_RUN_SCRIPT nsresult EndMoving(); + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + GetTemporaryStyleForFocusedPositionedElement(Element& aElement, + nsAString& aReturn); + + /** + * Shows inline table editing UI around a <table> 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 <td> or <th> element. + */ + MOZ_CAN_RUN_SCRIPT nsresult + ShowInlineTableEditingUIInternal(Element& aCellElement); + + /** + * Hide all inline table editing UI. + */ + void HideInlineTableEditingUIInternal(); + + /** + * RefreshInlineTableEditingUIInternal() moves inline table editing UI to + * proper position. This returns error if the UI is hidden or replaced + * during moving. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult + RefreshInlineTableEditingUIInternal(); + + enum class ContentNodeIs { Inserted, Appended }; + MOZ_CAN_RUN_SCRIPT void DoContentInserted(nsIContent* aChild, + ContentNodeIs aContentNodeIs); + + /** + * Returns an anonymous Element of type aTag, + * child of aParentContent. If aIsCreatedHidden is true, the class + * "hidden" is added to the created element. If 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 aGlobal The global object under which the read should happen. + * @param aBlobReader The blob reader object to be notified when finished. + */ + static nsresult SlurpBlob(dom::Blob* aBlob, nsIGlobalObject* aGlobal, + BlobReader* aBlobReader); + + /** + * 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. + */ + [[nodiscard]] inline already_AddRefed<RangeItem> + GetSelectedRangeItemForTopLevelEditSubAction() const; + + /** + * For saving allocation cost in the constructor of + * EditorBase::TopLevelEditSubActionData, we should reuse same nsRange + * instance with all top level edit sub actions. + * The instance is always cleared when TopLevelEditSubActionData is + * destructed, but AbstractRange::mOwner keeps grabbing the owner document + * so that we need to make it in the cycle collection. + */ + [[nodiscard]] inline already_AddRefed<nsRange> + GetChangedRangeForTopLevelEditSubAction() const; + + MOZ_CAN_RUN_SCRIPT void DidDoTransaction( + TransactionManager& aTransactionManager, nsITransaction& aTransaction, + nsresult aDoTransactionResult) { + if (mComposerCommandsUpdater) { + RefPtr<ComposerCommandsUpdater> updater(mComposerCommandsUpdater); + updater->DidDoTransaction(aTransactionManager); + } + } + + MOZ_CAN_RUN_SCRIPT void DidUndoTransaction( + TransactionManager& aTransactionManager, nsITransaction& aTransaction, + nsresult aUndoTransactionResult) { + if (mComposerCommandsUpdater) { + RefPtr<ComposerCommandsUpdater> updater(mComposerCommandsUpdater); + updater->DidUndoTransaction(aTransactionManager); + } + } + + MOZ_CAN_RUN_SCRIPT void DidRedoTransaction( + TransactionManager& aTransactionManager, nsITransaction& aTransaction, + nsresult aRedoTransactionResult) { + if (mComposerCommandsUpdater) { + RefPtr<ComposerCommandsUpdater> updater(mComposerCommandsUpdater); + updater->DidRedoTransaction(aTransactionManager); + } + } + + protected: + /** + * IndentListChildWithTransaction() is a helper method of + * Handle(CSS|HTML)IndentAtSelectionInternal(). + * + * @param aSubListElement [in/out] Specify a sub-list element of the + * container of aPointInListElement or nullptr. + * When there is no proper sub-list element to + * move aContentMovingToSubList, this method + * inserts a new sub-list element and update this + * to it. + * @param aPointInListElement A point in a list element whose child should + * be indented. If this method creates new list + * element into the list element, this inserts + * the new list element to this point. + * @param aContentMovingToSubList + * A content node which is a child of a list + * element and should be moved into a sub-list + * element. + * @param aEditingHost The editing host. + * @return A candidate caret position. + */ + [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> + IndentListChildWithTransaction(RefPtr<Element>* aSubListElement, + const EditorDOMPoint& aPointInListElement, + nsIContent& aContentMovingToSubList, + const Element& aEditingHost); + + /** + * Stack based helper class for saving/restoring selection. Note that this + * assumes that the nodes involved are still around afterwords! + */ + class AutoSelectionRestorer final { + public: + AutoSelectionRestorer() = delete; + explicit AutoSelectionRestorer(const AutoSelectionRestorer& aOther) = + delete; + AutoSelectionRestorer(AutoSelectionRestorer&& aOther) = delete; + + /** + * Constructor responsible for remembering all state needed to restore + * aSelection. + * XXX This constructor and the destructor should be marked as + * `MOZ_CAN_RUN_SCRIPT`, but it's impossible due to this may be used + * with `Maybe`. + */ + MOZ_CAN_RUN_SCRIPT_BOUNDARY explicit AutoSelectionRestorer( + HTMLEditor& aHTMLEditor); + + /** + * Destructor restores mSelection to its former state + */ + MOZ_CAN_RUN_SCRIPT_BOUNDARY ~AutoSelectionRestorer(); + + /** + * Abort() cancels to restore the selection. + */ + void Abort(); + + bool MaybeRestoreSelectionLater() const { return !!mHTMLEditor; } + + protected: + // The lifetime must be guaranteed by the creator of this instance. + MOZ_KNOWN_LIVE HTMLEditor* mHTMLEditor = nullptr; + }; + + /** + * Stack based helper class for calling EditorBase::EndTransactionInternal(). + * NOTE: This does not suppress multiple input events. In most cases, + * only one "input" event should be fired for an edit action rather + * than per edit sub-action. In such case, you should use + * EditorBase::AutoPlaceholderBatch instead. + */ + class MOZ_RAII AutoTransactionBatch final { + public: + /** + * @param aRequesterFuncName function name which wants to end the batch. + * This won't be stored nor exposed to selection listeners etc, used only + * for logging. This MUST be alive when the destructor runs. + */ + MOZ_CAN_RUN_SCRIPT explicit AutoTransactionBatch( + HTMLEditor& aHTMLEditor, const char* aRequesterFuncName) + : mHTMLEditor(aHTMLEditor), mRequesterFuncName(aRequesterFuncName) { + MOZ_KnownLive(mHTMLEditor).BeginTransactionInternal(mRequesterFuncName); + } + + MOZ_CAN_RUN_SCRIPT ~AutoTransactionBatch() { + MOZ_KnownLive(mHTMLEditor).EndTransactionInternal(mRequesterFuncName); + } + + protected: + // The lifetime must be guaranteed by the creator of this instance. + MOZ_KNOWN_LIVE HTMLEditor& mHTMLEditor; + const char* const mRequesterFuncName; + }; + + RefPtr<PendingStyles> mPendingStylesToApplyToNewContent; + RefPtr<ComposerCommandsUpdater> mComposerCommandsUpdater; + + // Used by TopLevelEditSubActionData::mSelectedRange. + mutable RefPtr<RangeItem> mSelectedRangeForTopLevelEditSubAction; + // Used by TopLevelEditSubActionData::mChangedRange. + mutable RefPtr<nsRange> mChangedRangeForTopLevelEditSubAction; + + RefPtr<Runnable> mPendingRootElementUpdatedRunner; + RefPtr<Runnable> mPendingDocumentModifiedRunner; + + // mPaddingBRElementForEmptyEditor should be used for placing caret + // at proper position when editor is empty. + RefPtr<dom::HTMLBRElement> mPaddingBRElementForEmptyEditor; + + bool mCRInParagraphCreatesParagraph; + + // resizing + bool mIsObjectResizingEnabled; + bool mIsResizing; + bool mPreserveRatio; + bool mResizedObjectIsAnImage; + + // absolute positioning + bool mIsAbsolutelyPositioningEnabled; + bool mResizedObjectIsAbsolutelyPositioned; + bool mGrabberClicked; + bool mIsMoving; + + bool mSnapToGridEnabled; + + // inline table editing + bool mIsInlineTableEditingEnabled; + + bool mIsCSSPrefChecked; + + // resizing + ManualNACPtr mTopLeftHandle; + ManualNACPtr mTopHandle; + ManualNACPtr mTopRightHandle; + ManualNACPtr mLeftHandle; + ManualNACPtr mRightHandle; + ManualNACPtr mBottomLeftHandle; + ManualNACPtr mBottomHandle; + ManualNACPtr mBottomRightHandle; + + RefPtr<Element> mActivatedHandle; + + ManualNACPtr mResizingShadow; + ManualNACPtr mResizingInfo; + + RefPtr<Element> 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<Element> mAbsolutelyPositionedObject; + ManualNACPtr mGrabber; + ManualNACPtr mPositioningShadow; + + int32_t mGridSize; + + // inline table editing + RefPtr<Element> mInlineEditedCell; + + ManualNACPtr mAddColumnBeforeButton; + ManualNACPtr mRemoveColumnButton; + ManualNACPtr mAddColumnAfterButton; + + ManualNACPtr mAddRowBeforeButton; + ManualNACPtr mRemoveRowButton; + ManualNACPtr mAddRowAfterButton; + + void AddMouseClickListener(Element* aElement); + void RemoveMouseClickListener(Element* aElement); + + bool mDisabledLinkHandling = false; + bool mOldLinkHandlingEnabled = false; + + bool mHasBeforeInputBeenCanceled = false; + + ParagraphSeparator mDefaultParagraphSeparator; + + friend class AlignStateAtSelection; // CollectEditableTargetNodes, + // CollectNonEditableNodes + friend class AutoRangeArray; // RangeUpdaterRef, SplitNodeWithTransaction, + // SplitInlineAncestorsAtRangeBoundaries + friend class AutoSelectionSetterAfterTableEdit; // SetSelectionAfterEdit + friend class + AutoSetTemporaryAncestorLimiter; // InitializeSelectionAncestorLimit + friend class CSSEditUtils; // DoTransactionInternal, HasAttributes, + // RemoveContainerWithTransaction + friend class EditorBase; // ComputeTargetRanges, + // GetChangedRangeForTopLevelEditSubAction, + // GetSelectedRangeItemForTopLevelEditSubAction, + // MaybeCreatePaddingBRElementForEmptyEditor, + // PrepareToInsertBRElement, + // ReflectPaddingBRElementForEmptyEditor, + // RefreshEditingUI, + // RemoveEmptyInclusiveAncestorInlineElements, + // mComposerUpdater, mHasBeforeInputBeenCanceled + friend class JoinNodesTransaction; // DidJoinNodesTransaction, DoJoinNodes, + // DoSplitNode, // RangeUpdaterRef + friend class ListElementSelectionState; // CollectEditTargetNodes, + // CollectNonEditableNodes + friend class ListItemElementSelectionState; // CollectEditTargetNodes, + // CollectNonEditableNodes + friend class MoveNodeTransaction; // AllowsTransactionsToChangeSelection, + // CollapseSelectionTo, MarkElementDirty, + // RangeUpdaterRef + friend class ParagraphStateAtSelection; // CollectChildren, + // CollectEditTargetNodes, + // CollectListChildren, + // CollectNonEditableNodes, + // CollectTableChildren + friend class SlurpBlobEventListener; // BlobReader + friend class SplitNodeTransaction; // DoJoinNodes, DoSplitNode + friend class TransactionManager; // DidDoTransaction, DidRedoTransaction, + // DidUndoTransaction + friend class + WhiteSpaceVisibilityKeeper; // AutoMoveOneLineHandler + // CanMoveChildren, + // ChangeListElementType, + // DeleteNodeWithTransaction, + // DeleteTextAndTextNodesWithTransaction, + // JoinNearestEditableNodesWithTransaction, + // MoveChildrenWithTransaction, + // SplitAncestorStyledInlineElementsAt, + // TreatEmptyTextNodes +}; + +/** + * ListElementSelectionState class gets which list element is selected right + * now. + */ +class MOZ_STACK_CLASS ListElementSelectionState final { + public: + ListElementSelectionState() = delete; + ListElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv); + + bool IsOLElementSelected() const { return mIsOLElementSelected; } + bool IsULElementSelected() const { return mIsULElementSelected; } + bool IsDLElementSelected() const { return mIsDLElementSelected; } + bool IsNotOneTypeListElementSelected() const { + return (mIsOLElementSelected + mIsULElementSelected + mIsDLElementSelected + + mIsOtherContentSelected) > 1; + } + + private: + bool mIsOLElementSelected = false; + bool mIsULElementSelected = false; + bool mIsDLElementSelected = false; + bool mIsOtherContentSelected = false; +}; + +/** + * ListItemElementSelectionState class gets which list item element is selected + * right now. + */ +class MOZ_STACK_CLASS ListItemElementSelectionState final { + public: + ListItemElementSelectionState() = delete; + ListItemElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv); + + bool IsLIElementSelected() const { return mIsLIElementSelected; } + bool IsDTElementSelected() const { return mIsDTElementSelected; } + bool IsDDElementSelected() const { return mIsDDElementSelected; } + bool IsNotOneTypeDefinitionListItemElementSelected() const { + return (mIsDTElementSelected + mIsDDElementSelected + + mIsOtherElementSelected) > 1; + } + + private: + bool mIsLIElementSelected = false; + bool mIsDTElementSelected = false; + bool mIsDDElementSelected = false; + bool mIsOtherElementSelected = false; +}; + +/** + * AlignStateAtSelection class gets alignment at selection. + * XXX This currently returns only first alignment. + */ +class MOZ_STACK_CLASS AlignStateAtSelection final { + public: + AlignStateAtSelection() = delete; + MOZ_CAN_RUN_SCRIPT AlignStateAtSelection(HTMLEditor& aHTMLEditor, + ErrorResult& aRv); + + nsIHTMLEditor::EAlignment AlignmentAtSelectionStart() const { + return mFirstAlign; + } + bool IsSelectionRangesFound() const { return mFoundSelectionRanges; } + + private: + nsIHTMLEditor::EAlignment mFirstAlign = nsIHTMLEditor::eLeft; + bool mFoundSelectionRanges = false; +}; + +/** + * ParagraphStateAtSelection class gets format block types around selection. + */ +class MOZ_STACK_CLASS ParagraphStateAtSelection final { + public: + using FormatBlockMode = HTMLEditor::FormatBlockMode; + + ParagraphStateAtSelection() = delete; + /** + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + */ + ParagraphStateAtSelection(HTMLEditor& aHTMLEditor, + FormatBlockMode aFormatBlockMode, ErrorResult& aRv); + + /** + * GetFirstParagraphStateAtSelection() returns: + * - nullptr if there is no format blocks nor inline nodes. + * - nsGkAtoms::_empty if first node is not in any format block. + * - a tag name of format block at first node. + * XXX See the private method explanations. If selection ranges contains + * non-format block first, it'll be check after its siblings. Therefore, + * this may return non-first paragraph state. + */ + nsAtom* GetFirstParagraphStateAtSelection() const { + return mIsMixed && mIsInDLElement ? nsGkAtoms::dl + : mFirstParagraphState.get(); + } + + /** + * If selected nodes are not in same format node nor only in no-format blocks, + * this returns true. + */ + bool IsMixed() const { return mIsMixed && !mIsInDLElement; } + + private: + using EditorType = EditorBase::EditorType; + + [[nodiscard]] static bool IsFormatElement(FormatBlockMode aFormatBlockMode, + const nsIContent& aContent); + + /** + * AppendDescendantFormatNodesAndFirstInlineNode() appends descendant + * format blocks and first inline child node in aNonFormatBlockElement to + * the last of the array (not inserting where aNonFormatBlockElement is, + * so that the node order becomes randomly). + * + * @param aArrayOfContents [in/out] Found descendant format blocks + * and first inline node in each non-format + * block will be appended to this. + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + * @param aNonFormatBlockElement Must be a non-format block element. + */ + static void AppendDescendantFormatNodesAndFirstInlineNode( + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents, + FormatBlockMode aFormatBlockMode, dom::Element& aNonFormatBlockElement); + + /** + * CollectEditableFormatNodesInSelection() collects only editable nodes + * around selection ranges (with `AutoRangeArray::ExtendRangesToWrapLines()` + * and `HTMLEditor::CollectEditTargetNodes()`, see its document for the + * detail). If it includes list, list item or table related elements, they + * will be replaced their children. + * + * @param aFormatBlockMode Whether HTML formatBlock command or XUL + * paragraphState command. + */ + static nsresult CollectEditableFormatNodesInSelection( + HTMLEditor& aHTMLEditor, FormatBlockMode aFormatBlockMode, + const dom::Element& aEditingHost, + nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents); + + RefPtr<nsAtom> mFirstParagraphState; + bool mIsInDLElement = false; + bool mIsMixed = false; +}; + +} // namespace mozilla + +mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() { + MOZ_DIAGNOSTIC_ASSERT(IsHTMLEditor()); + return static_cast<mozilla::HTMLEditor*>(this); +} + +const mozilla::HTMLEditor* nsIEditor::AsHTMLEditor() const { + MOZ_DIAGNOSTIC_ASSERT(IsHTMLEditor()); + return static_cast<const mozilla::HTMLEditor*>(this); +} + +mozilla::HTMLEditor* nsIEditor::GetAsHTMLEditor() { + return AsEditorBase()->IsHTMLEditor() ? AsHTMLEditor() : nullptr; +} + +const mozilla::HTMLEditor* nsIEditor::GetAsHTMLEditor() const { + return AsEditorBase()->IsHTMLEditor() ? AsHTMLEditor() : nullptr; +} + +#endif // #ifndef mozilla_HTMLEditor_h |