f8da424b74
Unfortunately, this patch becomes big because this includes multiple utility
methods to normalize white-spaces and touching a lot of places.
In some edge cases, this starts failing when the new white-space normalizer is
enabled.
```
FAIL execCommand("forwarddelete", false, ""): "a [] | b" - assert_equals: Modified text is wrong expected "a " but got "a "
FAIL execCommand("forwarddelete", false, ""): "a [] | b" - assert_equals: Modified text is wrong expected "a " but got "a "
FAIL execCommand("forwarddelete", false, ""): "a []b| c" - assert_equals: Modified text is wrong expected "a " but got "a "
FAIL execCommand("forwarddelete", false, ""): "a [] <span style=white-space:pre;> </span>" - assert_equals: expected "a <span style=\"white-space:pre;\"> </span>" but got "a <span style=\"white-space:pre;\"> </span>"
```
In these failures, we normalize the trailing white-spaces of the preceding
`Text` too, but Chrome does not do that. However, in some cases, they do
in similar cases. Therefore, it's hard to align all cases due to the handling
order difference. Additionally, these failure results are not odd. So, these
new failures are acceptable.
```
FAIL execCommand("forwarddelete", false, ""): "<span>abc[] <span> def</span></span>" - assert_equals: expected "<span>abc<span> def</span></span>" but got "<span>abc<span> def</span></span>"
FAIL execCommand("forwarddelete", false, ""): "<span><span>abc[] </span> def</span>" - assert_equals: expected "<span><span>abc</span> def</span>" but got "<span><span>abc</span> def</span>"
FAIL execCommand("forwarddelete", false, ""): "<span>abc[] </span><span> def</span>" - assert_equals: expected "<span>abc</span><span> def</span>" but got "<span>abc</span><span> def</span>"
FAIL execCommand("forwarddelete", false, ""): "<span>abc[] </span><span> def</span>" - assert_equals: expected "<span>abc </span><span> def</span>" but got "<span>abc </span><span> def</span>"
```
In these failures, we don't normalize the leading white-spaces of the following
`Text`. However, Chrome does so in some other cases. So, it's hard to align
the behavior in these cases too. The new normalizer ensures that the preceding
`Text` ends with a visible char. Therefore, the following `Text` won't starts
with new invisible white-spaces. Therefore, these failures are also acceptable.
```
FAIL execCommand("forwarddelete", false, ""): "<span style=white-space:pre;> [] </span> a" - assert_equals: expected "<span style=\"white-space:pre;\"> </span> a" but got "<span style=\"white-space:pre;\"> </span> a"
```
In this failure, we don't normalize the following `Text` but Chrome does it.
However, I don't think we should do it because this updates the `Text` which
is preformatted. Therefore, this is also acceptable.
So, I think that we can accept all new failures.
Differential Revision: https://phabricator.services.mozilla.com/D239468
4944 lines
214 KiB
C++
4944 lines
214 KiB
C++
/* -*- 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 nsRange;
|
|
class nsStaticAtom;
|
|
class nsStyledElement;
|
|
class nsTableCellFrame;
|
|
class nsTableWrapperFrame;
|
|
template <class E>
|
|
class nsTArray;
|
|
|
|
namespace mozilla {
|
|
class AlignStateAtSelection;
|
|
class AutoSelectionSetterAfterTableEdit;
|
|
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(nsIClipboard::ClipboardType 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 aDataTransfer The object containing the data to use for the
|
|
* paste operation. May be nullptr, in which case
|
|
* this will just get the data from the clipboard.
|
|
* @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(nsIClipboard::ClipboardType aClipboardType,
|
|
DispatchPasteEvent aDispatchPasteEvent,
|
|
DataTransfer* aDataTransfer = nullptr,
|
|
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);
|
|
|
|
enum class InsertElementOption {
|
|
// Delete selection if set, otherwise, insert aElement at start or end of
|
|
// selection.
|
|
DeleteSelection,
|
|
// Whether split all inline ancestors or not.
|
|
SplitAncestorInlineElements,
|
|
};
|
|
using InsertElementOptions = EnumSet<InsertElementOption>;
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertElementAtSelectionAsAction(
|
|
Element* aElement, const InsertElementOptions aOptions,
|
|
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 this editor was notified of focus, but has not been notified
|
|
* of the blur.
|
|
*/
|
|
[[nodiscard]] bool HasFocus() const { return mHasFocus; }
|
|
|
|
/**
|
|
* Return true if this editor is in the designMode.
|
|
*/
|
|
[[nodiscard]] bool IsInDesignMode() const { return mIsInDesignMode; }
|
|
|
|
/**
|
|
* 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.
|
|
****************************************************************************/
|
|
|
|
enum class LineBreakType : bool {
|
|
BRElement, // <br>
|
|
Linefeed, // Preformatted linefeed
|
|
};
|
|
friend std::ostream& operator<<(std::ostream& aStream,
|
|
const LineBreakType aLineBreakType) {
|
|
switch (aLineBreakType) {
|
|
case LineBreakType::BRElement:
|
|
return aStream << "LineBreakType::BRElement";
|
|
case LineBreakType::Linefeed:
|
|
return aStream << "LineBreakType::BRElement";
|
|
}
|
|
MOZ_ASSERT_UNREACHABLE("Invalid LineBreakType");
|
|
return aStream;
|
|
}
|
|
|
|
/**
|
|
* Return preferred line break when you insert a line break in aNode (if
|
|
* aNode is a Text node, this assumes that line break will be inserted to
|
|
* its parent element).
|
|
*
|
|
* @param aNode The node where you want to insert a line break.
|
|
* This should be a inclusive descendant of
|
|
* aEditingHost because if it's not connected, we can
|
|
* not refer the proper style information.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
Maybe<LineBreakType> GetPreferredLineBreakType(
|
|
const nsINode& aNode, const Element& aEditingHost) const;
|
|
|
|
/**
|
|
* InsertLineBreak() creates a <br> element or a Text node which has only
|
|
* preformatted linefeed and inserts it at 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 aLineBreakType Whether a <br> element or a linefeed should be
|
|
* used.
|
|
* @param aPointToInsert The DOM point where a <br> element or a Text
|
|
* node should be inserted.
|
|
* @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> or Text node and suggesting point
|
|
* to put caret with respecting aSelect.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT Result<CreateLineBreakResult, nsresult> InsertLineBreak(
|
|
WithTransaction aWithTransaction, LineBreakType aLineBreakType,
|
|
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);
|
|
|
|
struct NormalizedStringToInsertText;
|
|
|
|
/**
|
|
* Insert text to aPointToInsert or replace text in the range stored by aData
|
|
* in the text node specified by aPointToInsert with the normalized string
|
|
* stored by aData. So, aPointToInsert must be in a `Text` node if
|
|
* aData.ReplaceLength() is not 0.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertTextResult, nsresult>
|
|
InsertOrReplaceTextWithTransaction(const EditorDOMPoint& aPointToInsert,
|
|
const NormalizedStringToInsertText& aData);
|
|
|
|
struct ReplaceWhiteSpacesData;
|
|
|
|
/**
|
|
* Replace or insert white-spaces of aData to aTextNode.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertTextResult, nsresult>
|
|
ReplaceTextWithTransaction(dom::Text& aTextNode,
|
|
const ReplaceWhiteSpacesData& aData);
|
|
|
|
/**
|
|
* Insert aStringToInsert to aPointToInsert. If the point is not editable,
|
|
* this returns error.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<InsertTextResult, nsresult>
|
|
InsertTextWithTransaction(const nsAString& aStringToInsert,
|
|
const EditorDOMPoint& aPointToInsert,
|
|
InsertTextTo aInsertTextTo) 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 adjacent editable text nodes in the range except preformatted
|
|
* linefeed only nodes.
|
|
*/
|
|
[[nodiscard]] 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.
|
|
* @param aEditingHost The editing host.
|
|
* @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, const Element& aEditingHost);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult SetPositionToAbsolute(Element& aElement);
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
SetPositionToStatic(Element& aElement);
|
|
|
|
class DocumentModifiedEvent final : public Runnable {
|
|
public:
|
|
explicit DocumentModifiedEvent(HTMLEditor& aHTMLEditor)
|
|
: Runnable("DocumentModifiedEvent"), mHTMLEditor(aHTMLEditor) {}
|
|
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() {
|
|
Unused << MOZ_KnownLive(mHTMLEditor)->OnModifyDocument(*this);
|
|
return NS_OK;
|
|
}
|
|
|
|
const nsTArray<EditorDOMPointInText>& NewInvisibleWhiteSpacesRef() const {
|
|
return mNewInvisibleWhiteSpaces;
|
|
}
|
|
|
|
void MaybeAppendNewInvisibleWhiteSpace(
|
|
const nsIContent* aContentWillBeRemoved);
|
|
|
|
private:
|
|
~DocumentModifiedEvent() = default;
|
|
|
|
const OwningNonNull<HTMLEditor> mHTMLEditor;
|
|
nsTArray<EditorDOMPointInText> mNewInvisibleWhiteSpaces;
|
|
};
|
|
|
|
/**
|
|
* OnModifyDocument() is called when the editor is changed. This should
|
|
* be called only by DocumentModifiedEvent when AutoEditActionDataSetter
|
|
* instance is in the stack.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
OnModifyDocument(const DocumentModifiedEvent& aRunner);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* 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(const Element& aEditingHost);
|
|
|
|
/**
|
|
* 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(const nsAString& aInsertionString,
|
|
InsertTextFor aPurpose) final;
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertDroppedDataTransferAsAction(
|
|
AutoEditActionDataSetter& aEditActionData, 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.
|
|
* @return Candidate caret position where is at inserted
|
|
* <br> element into the split point.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult>
|
|
HandleInsertParagraphInMailCiteElement(Element& aMailCiteElement,
|
|
const EditorDOMPoint& aPointToSplit);
|
|
|
|
/**
|
|
* 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 aPointToBreak.
|
|
*
|
|
* @param aPointToBreak 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& aPointToBreak,
|
|
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 aNamespaceID [in] The namespace ID of aAttrName.
|
|
* @param aAttrName [in] The attribute name which will be copied.
|
|
* @param aValue [in/out] The attribute value which will be copied.
|
|
* Once updated, the new value is used.
|
|
* @return true if the attribute should be copied, otherwise,
|
|
* false.
|
|
*/
|
|
using AttributeFilter = std::function<bool(
|
|
HTMLEditor& aHTMLEditor, Element& aSrcElement, Element& aDestElement,
|
|
int32_t aNamespaceID, const nsAtom& aAttrName, 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(
|
|
AutoClonedSelectionRangeArray& aSelectionRanges,
|
|
const nsStaticAtom& aNewFormatTagName, FormatBlockMode aFormatBlockMode,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* Retrun true if the specified line break can be inserted around aContent.
|
|
* If aContent is an Element, this checks whether the element can have the
|
|
* line break.
|
|
* If aContent is a Text, this check whether its container element can have
|
|
* the line break.
|
|
*/
|
|
[[nodiscard]] static bool CanInsertLineBreak(LineBreakType aLineBreakType,
|
|
const nsIContent& aContent);
|
|
|
|
/**
|
|
* If aPointToInsert is between line breaks or block boundaries, this
|
|
* puts a <br> element to make an empty line between them.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateLineBreakResult, nsresult>
|
|
InsertPaddingBRElementToMakeEmptyLineVisibleIfNeeded(
|
|
const EditorDOMPoint& aPointToInsert);
|
|
|
|
/**
|
|
* Insert a padding <br> if aPoint is in an empty block.
|
|
*
|
|
* @param aPoint The place where you want to put a padding line
|
|
* break.
|
|
* @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes empty inlines
|
|
* before inserting a line break from the inserting
|
|
* point.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateLineBreakResult, nsresult>
|
|
InsertPaddingBRElementIfInEmptyBlock(
|
|
const EditorDOMPoint& aPoint,
|
|
nsIEditor::EStripWrappers aDeleteEmptyInlines);
|
|
|
|
/**
|
|
* Insert a padding <br> element for making preceding collapsible white-spaces
|
|
* visible or the point is empty between block boundaries.
|
|
*
|
|
* @param aPoint Where you want to check. A padding <br> may be
|
|
* inserted different from this point.
|
|
* @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes empty inlines
|
|
* before inserting <br> from the inserting point.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CreateLineBreakResult, nsresult>
|
|
InsertPaddingBRElementIfNeeded(const EditorDOMPoint& aPoint,
|
|
nsIEditor::EStripWrappers aDeleteEmptyInlines,
|
|
const Element& aEditingHost);
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult>
|
|
DeleteRangesWithTransaction(
|
|
nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers,
|
|
const AutoClonedRangeArray& aRangesToDelete) override;
|
|
|
|
/**
|
|
* 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.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<SplitNodeResult, nsresult>
|
|
SplitParagraphWithTransaction(Element& aParentDivOrP,
|
|
const EditorDOMPoint& aStartOfRightNode,
|
|
dom::HTMLBRElement* aMayBecomeVisibleBRElement,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* 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.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
|
|
MakeOrChangeListAndListItemAsSubAction(
|
|
const nsStaticAtom& aListElementOrListItemElementTagName,
|
|
const nsAString& aBulletType,
|
|
SelectAllOfCurrentList aSelectAllOfCurrentList,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* DeleteTextAndTextNodesWithTransaction() removes text or text nodes in
|
|
* the given range.
|
|
*/
|
|
enum class TreatEmptyTextNodes {
|
|
// KeepIfContainerOfRangeBoundaries:
|
|
// Will remove empty text nodes middle of the range, but keep empty
|
|
// text nodes which are containers of range boundaries.
|
|
KeepIfContainerOfRangeBoundaries,
|
|
// Remove:
|
|
// Will remove all empty text nodes.
|
|
Remove,
|
|
// RemoveAllEmptyInlineAncestors:
|
|
// Will remove all empty text nodes and its inline ancestors which
|
|
// become empty due to removing empty text nodes.
|
|
RemoveAllEmptyInlineAncestors,
|
|
};
|
|
template <typename EditorDOMPointType>
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult>
|
|
DeleteTextAndTextNodesWithTransaction(
|
|
const EditorDOMPointType& aStartPoint,
|
|
const EditorDOMPointType& aEndPoint,
|
|
TreatEmptyTextNodes aTreatEmptyTextNodes);
|
|
|
|
/**
|
|
* Delete the line break with DeleteNodeTransaction or DeleteTextTransaction.
|
|
*
|
|
* @param aLineBreak The line break to be deleted.
|
|
* @param aDeleteEmptyInlines If nsIEditor::eStrip, this deletes new empty
|
|
* inline element if and only if this deletes the
|
|
* line break node.
|
|
* @param aEditingHost The editing host.
|
|
* @return The point where the line break was.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult>
|
|
DeleteLineBreakWithTransaction(const EditorLineBreak& aLineBreak,
|
|
nsIEditor::EStripWrappers aDeleteEmptyInlines,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* JoinNodesWithTransaction() joins aLeftContent and aRightContent. Content
|
|
* of aLeftContent will be merged into aRightContent. Actual implemenation of
|
|
* this method is JoinNodesImpl(). So, see its explanation for the detail.
|
|
*
|
|
* @param aLeftContent Will be removed from the DOM tree.
|
|
* @param aRightContent The node which will be new container of the content
|
|
* of aLeftContent.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<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);
|
|
|
|
/**
|
|
* DeleteEmptyInclusiveAncestorInlineElements() removes empty inclusive
|
|
* ancestor inline elements in inclusive ancestor block element of aContent.
|
|
*
|
|
* @param aContent Must be an empty content.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<CaretPoint, nsresult>
|
|
DeleteEmptyInclusiveAncestorInlineElements(nsIContent& aContent,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* DeleteTextAndNormalizeSurroundingWhiteSpaces() deletes text between
|
|
* aStartToDelete and immediately before aEndToDelete and return new caret
|
|
* position. If surrounding characters are white-spaces, this normalize them
|
|
* too. Finally, inserts `<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, const Element& aEditingHost);
|
|
|
|
enum class NormalizeSurroundingWhiteSpaces : bool { No, Yes };
|
|
friend constexpr bool operator!(NormalizeSurroundingWhiteSpaces aValue) {
|
|
return !static_cast<bool>(aValue);
|
|
}
|
|
|
|
/**
|
|
* Return a normalized string. If aPointToInsert is in a `Text` node,
|
|
* this returns a range in the `Text` to replace surrounding white-spaces at
|
|
* aPointToInsert with the normalized string if white-spaces are collapsible
|
|
* and aNormalizeSurroundingWhiteSpaces is "Yes".
|
|
*/
|
|
NormalizedStringToInsertText NormalizeWhiteSpacesToInsertText(
|
|
const EditorDOMPoint& aPointToInsert, const nsAString& aStringToInsert,
|
|
NormalizeSurroundingWhiteSpaces aNormalizeSurroundingWhiteSpaces) const;
|
|
|
|
/**
|
|
* Return normalized white-spaces of a white-space sequence which contains
|
|
* aPoint. This returns new offset of aPoint.Offset() after replacing the
|
|
* white-space sequence with normalized white-spaces.
|
|
*/
|
|
ReplaceWhiteSpacesData GetNormalizedStringAt(
|
|
const EditorDOMPointInText& aPoint) const;
|
|
|
|
/**
|
|
* Return normalized white-spaces after aPointToSplit if there are some
|
|
* collapsible white-spaces after the point.
|
|
*/
|
|
ReplaceWhiteSpacesData GetFollowingNormalizedStringToSplitAt(
|
|
const EditorDOMPointInText& aPointToSplit) const;
|
|
|
|
/**
|
|
* Return normalized white-spaces before aPointToSplit if there are some
|
|
* collapsible white-spaces before the point.
|
|
*/
|
|
ReplaceWhiteSpacesData GetPrecedingNormalizedStringToSplitAt(
|
|
const EditorDOMPointInText& aPointToSplit) const;
|
|
|
|
/**
|
|
* Return normalized surrounding white-spaces of the given range in aTextNode
|
|
* if there are some collapsible white-spaces.
|
|
*/
|
|
ReplaceWhiteSpacesData GetSurroundingNormalizedStringToDelete(
|
|
const Text& aTextNode, uint32_t aOffset, uint32_t aLength) const;
|
|
|
|
/**
|
|
* ExtendRangeToDeleteWithNormalizingWhiteSpaces() is a helper method of
|
|
* DeleteTextAndNormalizeSurroundingWhiteSpaces(). This expands
|
|
* aStartToDelete and/or aEndToDelete if there are white-spaces which need
|
|
* normalizing.
|
|
*
|
|
* @param aStartToDelete [In/Out] Start to delete. If this point
|
|
* follows white-spaces, this may be modified.
|
|
* @param aEndToDelete [In/Out] Next point of last content to be
|
|
* deleted. If this point is a white-space,
|
|
* this may be modified.
|
|
* @param aNormalizedWhiteSpacesInStartNode
|
|
* [Out] If container text node of aStartToDelete
|
|
* should be modified, this offers new string
|
|
* in the range in the text node.
|
|
* @param aNormalizedWhiteSpacesInEndNode
|
|
* [Out] If container text node of aEndToDelete
|
|
* is different from the container of
|
|
* aStartToDelete and it should be modified, this
|
|
* offers new string in the range in the text node.
|
|
*/
|
|
void ExtendRangeToDeleteWithNormalizingWhiteSpaces(
|
|
EditorDOMPointInText& aStartToDelete, EditorDOMPointInText& aEndToDelete,
|
|
nsString& aNormalizedWhiteSpacesInStartNode,
|
|
nsString& aNormalizedWhiteSpacesInEndNode) const;
|
|
|
|
/**
|
|
* CharPointType let the following helper methods of
|
|
* ExtendRangeToDeleteWithNormalizingWhiteSpaces() know what type of
|
|
* character will be previous or next char point after deletion.
|
|
*/
|
|
enum class CharPointType {
|
|
TextEnd, // Start or end of the text (hardline break or replaced inline
|
|
// element)
|
|
ASCIIWhiteSpace, // One of ASCII white-spaces (collapsible white-space)
|
|
NoBreakingSpace, // NBSP
|
|
VisibleChar, // Non-white-space characters
|
|
PreformattedChar, // Any character except a linefeed in a preformatted
|
|
// node.
|
|
PreformattedLineBreak, // Preformatted linebreak
|
|
};
|
|
|
|
/**
|
|
* GetPreviousCharPointType() and GetCharPointType() get type of
|
|
* previous/current char point from current DOM tree. In other words, if the
|
|
* point will be deleted, you cannot use these methods.
|
|
*/
|
|
template <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:
|
|
CharPointData() = delete;
|
|
|
|
static CharPointData InDifferentTextNode(CharPointType aCharPointType) {
|
|
return {aCharPointType, true};
|
|
}
|
|
static CharPointData InSameTextNode(CharPointType aCharPointType) {
|
|
// Let's mark this as in different text node if given one indicates
|
|
// that there is end of text because it means that adjacent content
|
|
// from point of text node view is another element.
|
|
return {aCharPointType, aCharPointType == CharPointType::TextEnd};
|
|
}
|
|
|
|
bool AcrossTextNodeBoundary() const { return mIsInDifferentTextNode; }
|
|
bool IsCollapsibleWhiteSpace() const {
|
|
return mType == CharPointType::ASCIIWhiteSpace ||
|
|
mType == CharPointType::NoBreakingSpace;
|
|
}
|
|
CharPointType Type() const { return mType; }
|
|
|
|
private:
|
|
CharPointData(CharPointType aType, bool aIsInDifferentTextNode)
|
|
: mType(aType), mIsInDifferentTextNode(aIsInDifferentTextNode) {}
|
|
|
|
CharPointType mType;
|
|
bool mIsInDifferentTextNode;
|
|
};
|
|
|
|
/**
|
|
* GetPreviousCharPointDataForNormalizingWhiteSpaces() and
|
|
* GetInclusiveNextCharPointDataForNormalizingWhiteSpaces() is helper methods
|
|
* of ExtendRangeToDeleteWithNormalizingWhiteSpaces(). This retrieves
|
|
* previous or inclusive next editable char point and returns its data.
|
|
*/
|
|
CharPointData GetPreviousCharPointDataForNormalizingWhiteSpaces(
|
|
const EditorDOMPointInText& aPoint) const;
|
|
CharPointData GetInclusiveNextCharPointDataForNormalizingWhiteSpaces(
|
|
const EditorDOMPointInText& aPoint) const;
|
|
|
|
enum class Linefeed : bool { Collapsible, Preformatted };
|
|
|
|
/**
|
|
* Normalize all white-spaces in aResult. aPreviousCharPointData is used only
|
|
* when the first character of aResult is an ASCII space or an NBSP.
|
|
* aNextCharPointData is used only when the last character of aResult is an
|
|
* ASCII space or an NBSP.
|
|
*/
|
|
static void NormalizeAllWhiteSpaceSequences(
|
|
nsString& aResult, const CharPointData& aPreviousCharPointData,
|
|
const CharPointData& aNextCharPointData, Linefeed aLinefeed);
|
|
|
|
/**
|
|
* GenerateWhiteSpaceSequence() generates white-space sequence which won't
|
|
* be collapsed.
|
|
*
|
|
* @param aResult [out] White space sequence which won't be
|
|
* collapsed, but wrappable.
|
|
* @param aLength Length of generating white-space sequence.
|
|
* Must be 1 or larger.
|
|
* @param aPreviousCharPointData
|
|
* Specify the previous char point where it'll be
|
|
* inserted. Currently, for keepin this method
|
|
* simple, does not support to generate a part
|
|
* of white-space sequence in a text node. So,
|
|
* if the type is white-space, it must indicate
|
|
* different text nodes white-space.
|
|
* @param aNextCharPointData Specify the next char point where it'll be
|
|
* inserted. Same as aPreviousCharPointData,
|
|
* this must node indicate white-space in same
|
|
* text node.
|
|
*/
|
|
static void GenerateWhiteSpaceSequence(
|
|
nsString& aResult, uint32_t aLength,
|
|
const CharPointData& aPreviousCharPointData,
|
|
const CharPointData& aNextCharPointData);
|
|
|
|
/**
|
|
* Replace characters starting from aOffset in aResult with normalized
|
|
* white-space sequence.
|
|
*/
|
|
static void ReplaceStringWithNormalizedWhiteSpaceSequence(
|
|
nsString& aResult, uint32_t aOffset, uint32_t aLength,
|
|
const CharPointData& aPreviousCharPointData,
|
|
const CharPointData& aNextCharPointData);
|
|
|
|
/**
|
|
* ComputeTargetRanges() computes actual delete ranges which will be deleted
|
|
* unless the following `beforeinput` event is canceled.
|
|
*
|
|
* @param aDirectionAndAmount The direction and amount of deletion.
|
|
* @param aRangesToDelete [In/Out] The ranges to be deleted,
|
|
* typically, initialized with the
|
|
* selection ranges. This may be modified
|
|
* if selection ranges should be extened.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
ComputeTargetRanges(nsIEditor::EDirection aDirectionAndAmount,
|
|
AutoClonedSelectionRangeArray& aRangesToDelete) const;
|
|
|
|
/**
|
|
* This method handles "delete selection" commands.
|
|
*
|
|
* @param aDirectionAndAmount Direction of the deletion.
|
|
* @param aStripWrappers Must be eStrip or eNoStrip.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<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(
|
|
AutoClonedSelectionRangeArray& aRanges, const Element& aEditingHost);
|
|
|
|
/**
|
|
* HandleCSSIndentAroundRanges() indents around aRanges with HTML.
|
|
*
|
|
* @param aRanges The ranges where the content should be indented.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleHTMLIndentAroundRanges(
|
|
AutoClonedSelectionRangeArray& aRanges, const Element& aEditingHost);
|
|
|
|
/**
|
|
* HandleIndentAtSelection() indents around Selection with HTML or CSS.
|
|
*
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
// TODO: Make this take AutoClonedSelectionRangeArray instead of retrieving
|
|
// `Selection`
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<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(
|
|
AutoClonedSelectionRangeArray& aRanges, const nsAString& aAlignType,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* AlignAsSubAction() handles "align" command with `Selection`.
|
|
*
|
|
* @param aAlignType New align attribute value where the contents
|
|
* should be aligned to.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<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(const nsIContent* aContentWillBeRemoved = nullptr);
|
|
|
|
protected: // Called by helper classes.
|
|
MOZ_CAN_RUN_SCRIPT void OnStartToHandleTopLevelEditSubAction(
|
|
EditSubAction aTopLevelEditSubAction,
|
|
nsIEditor::EDirection aDirectionOfTopLevelEditSubAction,
|
|
ErrorResult& aRv) final;
|
|
MOZ_CAN_RUN_SCRIPT nsresult OnEndHandlingTopLevelEditSubAction() final;
|
|
|
|
protected: // Shouldn't be used by friend classes
|
|
virtual ~HTMLEditor();
|
|
|
|
/**
|
|
* 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,
|
|
nsIClipboard::ClipboardType aClipboardType,
|
|
DataTransfer* aDataTransfer) final;
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
HandlePasteAsQuotation(AutoEditActionDataSetter& aEditActionData,
|
|
nsIClipboard::ClipboardType aClipboardType,
|
|
DataTransfer* aDataTransfer) final;
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
HandlePasteTransferable(AutoEditActionDataSetter& aEditActionData,
|
|
nsITransferable& aTransferable) final;
|
|
|
|
/**
|
|
* PasteInternal() pasts text with replacing selected content.
|
|
* This tries to dispatch ePaste event first. If its defaultPrevent() is
|
|
* called, this does nothing but returns NS_OK.
|
|
*
|
|
* @param aClipboardType nsIClipboard::kGlobalClipboard or
|
|
* nsIClipboard::kSelectionClipboard.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
PasteInternal(nsIClipboard::ClipboardType aClipboardType,
|
|
DataTransfer* aDataTransfer, const Element& aEditingHost);
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
InsertWithQuotationsAsSubAction(const nsAString& aQuotedText) final;
|
|
|
|
/**
|
|
* InsertAsCitedQuotationInternal() inserts a <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 aEditingHost The editing host.
|
|
* @param aNodeInserted [OUT] The new <blockquote> element.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsCitedQuotationInternal(
|
|
const nsAString& aQuotedText, const nsAString& aCitation,
|
|
bool aInsertHTML, const Element& aEditingHost, nsINode** aNodeInserted);
|
|
|
|
/**
|
|
* InsertNodeIntoProperAncestorWithTransaction() attempts to insert aNode
|
|
* into the document, at aPointToInsert. Checks with strict dtd to see if
|
|
* containment is allowed. If not allowed, will attempt to find a parent
|
|
* in the parent hierarchy of aPointToInsert.GetContainer() that will accept
|
|
* aNode as a child. If such a parent is found, will split the document
|
|
* tree from aPointToInsert up to parent, and then insert aNode.
|
|
* aPointToInsert is then adjusted to point to the actual location that
|
|
* aNode was inserted at. aSplitAtEdges specifies if the splitting process
|
|
* is allowed to result in empty nodes.
|
|
*
|
|
* @param aContent The content node to insert.
|
|
* @param aPointToInsert Insertion point.
|
|
* @param aSplitAtEdges Splitting can result in empty nodes?
|
|
*/
|
|
template <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, const Element& aEditingHost);
|
|
|
|
/**
|
|
* ReplaceContainerWithTransactionInternal() is implementation of
|
|
* ReplaceContainerWithTransaction() and
|
|
* ReplaceContainerAndCloneAttributesWithTransaction().
|
|
*
|
|
* @param aOldContainer The element which will be replaced with new
|
|
* element.
|
|
* @param aTagName The name of new element node.
|
|
* @param aAttribute Attribute name which will be set to the new
|
|
* element. This will be ignored if
|
|
* aCloneAllAttributes is set to true.
|
|
* @param aAttributeValue Attribute value which will be set to
|
|
* aAttribute.
|
|
* @param aCloneAllAttributes If true, all attributes of aOldContainer will
|
|
* be copied to the new element.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<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();
|
|
|
|
/**
|
|
* PrepareToInsertLineBreak() returns a point where a new line break node
|
|
* should be inserted. If aPointToInsert points middle of a text node, this
|
|
* method splits the text node and returns the point before right node.
|
|
*
|
|
* @param aLineBreakType Whether you will insert <br> or a preformatted
|
|
* linefeed.
|
|
* @param aPointToInsert Candidate point to insert new line break node.
|
|
* @return Computed point to insert new line break node.
|
|
* If something failed, this return error.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT Result<EditorDOMPoint, nsresult> PrepareToInsertLineBreak(
|
|
LineBreakType aLineBreakType, const EditorDOMPoint& aPointToInsert);
|
|
|
|
/**
|
|
* If unnecessary line break is there immediately after aPoint, this deletes
|
|
* the line break. Note that unnecessary line break means that the line break
|
|
* is a padding line break for empty line immediately before a block boundary
|
|
* and it's not a placeholder of ancestor inline elements.
|
|
*
|
|
* @param aNextOrAfterModifiedPoint If you inserted something, this should
|
|
* be next point or after the inserted
|
|
* content.
|
|
* If you deleted something, this should be
|
|
* end of the deleted range.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
EnsureNoFollowingUnnecessaryLineBreak(
|
|
const EditorDOMPoint& aNextOrAfterModifiedPoint);
|
|
|
|
/**
|
|
* 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.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
template <size_t N>
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAsSubAction(
|
|
const AutoTArray<EditorInlineStyleAndValue, N>& aStylesToSet,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* SetInlinePropertiesAroundRanges() applying the styles to the ranges even if
|
|
* the ranges are collapsed.
|
|
*/
|
|
template <size_t N>
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetInlinePropertiesAroundRanges(
|
|
AutoClonedRangeArray& aRanges,
|
|
const AutoTArray<EditorInlineStyleAndValue, N>& aStylesToSet);
|
|
|
|
/**
|
|
* RemoveInlinePropertiesAsSubAction() removes specified styles from
|
|
* mPendingStylesToApplyToNewContent if `Selection` is collapsed. Otherwise,
|
|
* removing the style.
|
|
*
|
|
* @param aStylesToRemove Styles to remove from the selected contents.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RemoveInlinePropertiesAsSubAction(
|
|
const nsTArray<EditorInlineStyle>& aStylesToRemove,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* Helper method to call RemoveInlinePropertiesAsSubAction(). If you want to
|
|
* remove other elements to remove the style completely, this will append
|
|
* related elements of aStyleToRemove and aStyleToRemove itself to the array.
|
|
* E.g., nsGkAtoms::strong and nsGkAtoms::b will be appended if aStyleToRemove
|
|
* is nsGkAtoms::b.
|
|
*/
|
|
void AppendInlineStyleAndRelatedStyle(
|
|
const EditorInlineStyle& aStyleToRemove,
|
|
nsTArray<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(
|
|
Element& aAncestorLimit) const final;
|
|
|
|
/**
|
|
* Make the given selection span the entire document.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SelectEntireDocument() final;
|
|
|
|
/**
|
|
* Use this to assure that selection is set after attribute nodes when
|
|
* trying to collapse selection at begining of a block node
|
|
* e.g., when setting at beginning of a table cell
|
|
* This will stop at a table, however, since we don't want to
|
|
* "drill down" into nested tables.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void CollapseSelectionToDeepestNonTableFirstChild(
|
|
nsINode* aNode);
|
|
/**
|
|
* MaybeCollapseSelectionAtFirstEditableNode() may collapse selection at
|
|
* proper position to staring to edit. If there is a non-editable node
|
|
* before any editable text nodes or inline elements which can have text
|
|
* nodes as their children, collapse selection at start of the editing
|
|
* host. If there is an editable text node which is not collapsed, collapses
|
|
* selection at the start of the text node. If there is an editable inline
|
|
* element which cannot have text nodes as its child, collapses selection at
|
|
* before the element node. Otherwise, collapses selection at start of the
|
|
* editing host.
|
|
*
|
|
* @param aIgnoreIfSelectionInEditingHost
|
|
* This method does nothing if selection is in the
|
|
* editing host except if it's collapsed at start of
|
|
* the editing host.
|
|
* Note that if selection ranges were outside of
|
|
* current selection limiter, selection was collapsed
|
|
* at the start of the editing host therefore, if
|
|
* you call this with setting this to true, you can
|
|
* keep selection ranges if user has already been
|
|
* changed.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
MaybeCollapseSelectionAtFirstEditableNode(
|
|
bool aIgnoreIfSelectionInEditingHost) const;
|
|
|
|
/**
|
|
* Join aLeftText and aRightText with normalizing white-spaces at the joining
|
|
* point if it's required. aRightText must be the next sibling of aLeftText.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<JoinNodesResult, nsresult>
|
|
JoinTextNodesWithNormalizeWhiteSpaces(Text& aLeftText, Text& aRightText);
|
|
|
|
class BlobReader final {
|
|
using AutoEditActionDataSetter = EditorBase::AutoEditActionDataSetter;
|
|
|
|
public:
|
|
MOZ_CAN_RUN_SCRIPT BlobReader(dom::BlobImpl* aBlob, HTMLEditor* aHTMLEditor,
|
|
SafeToInsertData aSafeToInsertData,
|
|
const EditorDOMPoint& aPointToInsert,
|
|
DeleteSelectedContent aDeleteSelectedContent,
|
|
const Element& aEditingHost);
|
|
|
|
NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(BlobReader)
|
|
NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(BlobReader)
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult OnResult(const nsACString& aResult);
|
|
nsresult OnError(const nsAString& aErrorName);
|
|
|
|
private:
|
|
~BlobReader() = default;
|
|
|
|
RefPtr<dom::BlobImpl> mBlob;
|
|
RefPtr<HTMLEditor> mHTMLEditor;
|
|
RefPtr<const Element> mEditingHost;
|
|
RefPtr<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(
|
|
nsIClipboard::ClipboardType aSelectionType, DataTransfer* aDataTransfer,
|
|
const Element& aEditingHost);
|
|
|
|
enum class AddCites { No, Yes };
|
|
/**
|
|
* Insert a string as quoted text, replacing the selected text (if any).
|
|
* @param aQuotedText The string to insert.
|
|
* @param aAddCites Whether to prepend extra ">" to each line
|
|
* (usually true, unless those characters
|
|
* have already been added.)
|
|
* @param aEditingHost The editing host.
|
|
* @return aNodeInserted The node spanning the insertion, if applicable.
|
|
* If aAddCites is false, this will be null.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertAsPlaintextQuotation(
|
|
const nsAString& aQuotedText, AddCites aAddCites,
|
|
const Element& aEditingHost, nsINode** aNodeInserted = nullptr);
|
|
|
|
/**
|
|
* InsertObject() inserts given object at aPointToInsert.
|
|
*
|
|
* @param aType one of kFileMime, kJPEGImageMime, kJPGImageMime,
|
|
* kPNGImageMime, kGIFImageMime.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertObject(
|
|
const nsACString& aType, nsISupports* aObject,
|
|
SafeToInsertData aSafeToInsertData, const EditorDOMPoint& aPointToInsert,
|
|
DeleteSelectedContent aDeleteSelectedContent,
|
|
const Element& aEditingHost);
|
|
|
|
class HTMLTransferablePreparer;
|
|
nsresult PrepareHTMLTransferable(nsITransferable** aTransferable,
|
|
const Element* aEditingHost) const;
|
|
|
|
enum class HavePrivateHTMLFlavor { No, Yes };
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertFromTransferableAtSelection(
|
|
nsITransferable* aTransferable, const nsAString& aContextStr,
|
|
const nsAString& aInfoStr, HavePrivateHTMLFlavor aHavePrivateHTMLFlavor,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* InsertFromDataTransfer() is called only when user drops data into
|
|
* this editor. Don't use this method for other purposes.
|
|
*
|
|
* @param aIndex index of aDataTransfer's item to insert.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertFromDataTransfer(
|
|
const DataTransfer* aDataTransfer, uint32_t aIndex,
|
|
nsIPrincipal* aSourcePrincipal, const EditorDOMPoint& aDroppedAt,
|
|
DeleteSelectedContent aDeleteSelectedContent,
|
|
const Element& aEditingHost);
|
|
|
|
static HavePrivateHTMLFlavor DataTransferOrClipboardHasPrivateHTMLFlavor(
|
|
DataTransfer* aDataTransfer, 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.
|
|
* @param aEditingHost The editing host.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult FormatBlockContainerAsSubAction(
|
|
const nsStaticAtom& aTagName, FormatBlockMode aFormatBlockMode,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* Increase/decrease the font size of selection.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
IncrementOrDecrementFontSizeAsSubAction(FontSize aIncrementOrDecrement);
|
|
|
|
/**
|
|
* Wrap aContent in <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,
|
|
const Element& aEditingHost);
|
|
|
|
/**
|
|
* sets the position of an element; warning it does NOT check if the
|
|
* element is already positioned or not and that's on purpose.
|
|
* @param aStyledElement [IN] the element
|
|
* @param aX [IN] the x position in pixels.
|
|
* @param aY [IN] the y position in pixels.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetTopAndLeftWithTransaction(
|
|
nsStyledElement& aStyledElement, int32_t aX, int32_t aY);
|
|
|
|
/**
|
|
* Reset a selected cell or collapsed selection (the caret) after table
|
|
* editing.
|
|
*
|
|
* @param aTable A table in the document.
|
|
* @param aRow The row ...
|
|
* @param aCol ... and column defining the cell where we will try to
|
|
* place the caret.
|
|
* @param aSelected If true, we select the whole cell instead of setting
|
|
* caret.
|
|
* @param aDirection If cell at (aCol, aRow) is not found, search for
|
|
* previous cell in the same column (aPreviousColumn) or
|
|
* row (ePreviousRow) or don't search for another cell
|
|
* (aNoSearch). If no cell is found, caret is place just
|
|
* before table; and if that fails, at beginning of
|
|
* document. Thus we generally don't worry about the
|
|
* return value and can use the
|
|
* AutoSelectionSetterAfterTableEdit stack-based object to
|
|
* insure we reset the caret in a table-editing method.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void SetSelectionAfterTableEdit(Element* aTable,
|
|
int32_t aRow, int32_t aCol,
|
|
int32_t aDirection,
|
|
bool aSelected);
|
|
|
|
void RemoveListenerAndDeleteRef(const nsAString& aEvent,
|
|
nsIDOMEventListener* aListener,
|
|
bool aUseCapture, ManualNACPtr aElement,
|
|
PresShell* aPresShell);
|
|
void DeleteRefToAnonymousNode(ManualNACPtr aContent, PresShell* aPresShell);
|
|
|
|
/**
|
|
* RefreshEditingUI() may refresh editing UIs for current Selection, focus,
|
|
* etc. If this shows or hides some UIs, it causes reflow. So, this is
|
|
* not safe method.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult RefreshEditingUI();
|
|
|
|
/**
|
|
* Returns the offset of an element's frame to its absolute containing block.
|
|
*/
|
|
nsresult GetElementOrigin(Element& aElement, int32_t& aX, int32_t& aY);
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult GetPositionAndDimensions(
|
|
Element& aElement, int32_t& aX, int32_t& aY, int32_t& aW, int32_t& aH,
|
|
int32_t& aBorderLeft, int32_t& aBorderTop, int32_t& aMarginLeft,
|
|
int32_t& aMarginTop);
|
|
|
|
bool IsInObservedSubtree(nsIContent* aChild);
|
|
|
|
void UpdateRootElement();
|
|
|
|
/**
|
|
* SetAllResizersPosition() moves all resizers to proper position.
|
|
* If the resizers are hidden or replaced with another set of resizers
|
|
* while this is running, this returns error. So, callers shouldn't
|
|
* keep handling the resizers if this returns error.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult SetAllResizersPosition();
|
|
|
|
/**
|
|
* Shows active resizers around an element's frame
|
|
* @param aResizedElement [IN] a DOM Element
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult ShowResizersInternal(Element& aResizedElement);
|
|
|
|
/**
|
|
* Hide resizers if they are visible. If this is called while there is no
|
|
* visible resizers, this does not return error, but does nothing.
|
|
*/
|
|
nsresult HideResizersInternal();
|
|
|
|
/**
|
|
* RefreshResizersInternal() moves resizers to proper position. This does
|
|
* nothing if there is no resizing target.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult RefreshResizersInternal();
|
|
|
|
ManualNACPtr CreateResizer(int16_t aLocation, nsIContent& aParentContent);
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
SetAnonymousElementPositionWithoutTransaction(nsStyledElement& aStyledElement,
|
|
int32_t aX, int32_t aY);
|
|
|
|
ManualNACPtr CreateShadow(nsIContent& aParentContent,
|
|
Element& aOriginalObject);
|
|
|
|
/**
|
|
* SetShadowPosition() moves the shadow element to proper position.
|
|
*
|
|
* @param aShadowElement Must be mResizingShadow or mPositioningShadow.
|
|
* @param aElement The element which has the shadow.
|
|
* @param aElementX Left of aElement.
|
|
* @param aElementY Top of aElement.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
SetShadowPosition(Element& aShadowElement, Element& aElement,
|
|
int32_t aElementLeft, int32_t aElementTop);
|
|
|
|
ManualNACPtr CreateResizingInfo(nsIContent& aParentContent);
|
|
MOZ_CAN_RUN_SCRIPT nsresult SetResizingInfoPosition(int32_t aX, int32_t aY,
|
|
int32_t aW, int32_t aH);
|
|
|
|
enum class ResizeAt {
|
|
eX,
|
|
eY,
|
|
eWidth,
|
|
eHeight,
|
|
};
|
|
[[nodiscard]] int32_t GetNewResizingIncrement(int32_t aX, int32_t aY,
|
|
ResizeAt aResizeAt) const;
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult StartResizing(Element& aHandle);
|
|
int32_t GetNewResizingX(int32_t aX, int32_t aY);
|
|
int32_t GetNewResizingY(int32_t aX, int32_t aY);
|
|
int32_t GetNewResizingWidth(int32_t aX, int32_t aY);
|
|
int32_t GetNewResizingHeight(int32_t aX, int32_t aY);
|
|
void HideShadowAndInfo();
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
SetFinalSizeWithTransaction(int32_t aX, int32_t aY);
|
|
void SetResizeIncrements(int32_t aX, int32_t aY, int32_t aW, int32_t aH,
|
|
bool aPreserveRatio);
|
|
|
|
/**
|
|
* HideAnonymousEditingUIs() forcibly hides all editing UIs (resizers,
|
|
* inline-table-editing UI, absolute positioning UI).
|
|
*/
|
|
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 aClass is not the empty
|
|
* string, it becomes the value of the class attribute
|
|
* @return a Element
|
|
* @param aTag [IN] desired type of the element to create
|
|
* @param aParentContent [IN] the parent node of the created anonymous
|
|
* element
|
|
* @param aClass [IN] contents of the _moz_anonclass attribute
|
|
* @param aIsCreatedHidden [IN] a boolean specifying if the class "hidden"
|
|
* is to be added to the created anonymous
|
|
* element
|
|
*/
|
|
ManualNACPtr CreateAnonymousElement(nsAtom* aTag, nsIContent& aParentContent,
|
|
const nsAString& aClass,
|
|
bool aIsCreatedHidden);
|
|
|
|
/**
|
|
* Reads a blob into memory and notifies the BlobReader object when the read
|
|
* operation is finished.
|
|
*
|
|
* @param aBlob The input blob
|
|
* @param aGlobal The global object under which the read should happen.
|
|
* @param aBlobReader The blob reader object to be notified when finished.
|
|
*/
|
|
static nsresult SlurpBlob(dom::Blob* aBlob, nsIGlobalObject* aGlobal,
|
|
BlobReader* aBlobReader);
|
|
|
|
/**
|
|
* For saving allocation cost in the constructor of
|
|
* EditorBase::TopLevelEditSubActionData, we should reuse same RangeItem
|
|
* instance with all top level edit sub actions.
|
|
* The instance is always cleared when TopLevelEditSubActionData is
|
|
* destructed and the class is stack only class so that we don't need
|
|
* to (and also should not) add the RangeItem into the cycle collection.
|
|
*/
|
|
[[nodiscard]] inline already_AddRefed<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 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<DocumentModifiedEvent> mPendingDocumentModifiedRunner;
|
|
|
|
// mPaddingBRElementForEmptyEditor should be used for placing caret
|
|
// at proper position when editor is empty.
|
|
RefPtr<dom::HTMLBRElement> mPaddingBRElementForEmptyEditor;
|
|
|
|
// This is set only when HandleInsertText appended a collapsible white-space.
|
|
RefPtr<dom::Text> mLastCollapsibleWhiteSpaceAppendedTextNode;
|
|
|
|
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 AddPointerClickListener(Element* aElement);
|
|
void RemovePointerClickListener(Element* aElement);
|
|
|
|
bool mDisabledLinkHandling = false;
|
|
bool mOldLinkHandlingEnabled = false;
|
|
|
|
bool mHasBeforeInputBeenCanceled = false;
|
|
|
|
bool mHasFocus = false;
|
|
bool mIsInDesignMode = false;
|
|
|
|
ParagraphSeparator mDefaultParagraphSeparator;
|
|
|
|
friend class AlignStateAtSelection; // CollectEditableTargetNodes,
|
|
// CollectNonEditableNodes
|
|
friend class AutoClonedRangeArray; // RangeUpdaterRef,
|
|
// SplitNodeWithTransaction,
|
|
// SplitInlineAncestorsAtRangeBoundaries
|
|
friend class AutoClonedSelectionRangeArray; // RangeUpdaterRef,
|
|
friend class AutoSelectionRestore;
|
|
friend class AutoSelectionSetterAfterTableEdit; // SetSelectionAfterEdit
|
|
friend class CSSEditUtils; // DoTransactionInternal, HasAttributes,
|
|
// RemoveContainerWithTransaction
|
|
friend class EditorBase; // ComputeTargetRanges,
|
|
// GetChangedRangeForTopLevelEditSubAction,
|
|
// GetSelectedRangeItemForTopLevelEditSubAction,
|
|
// MaybeCreatePaddingBRElementForEmptyEditor,
|
|
// PrepareToInsertBRElement,
|
|
// ReflectPaddingBRElementForEmptyEditor,
|
|
// RefreshEditingUI,
|
|
// mComposerUpdater, mHasBeforeInputBeenCanceled
|
|
friend class JoinNodesTransaction; // DidJoinNodesTransaction, DoJoinNodes,
|
|
// DoSplitNode, // RangeUpdaterRef
|
|
friend class ListElementSelectionState; // CollectEditTargetNodes,
|
|
// CollectNonEditableNodes
|
|
friend class ListItemElementSelectionState; // CollectEditTargetNodes,
|
|
// CollectNonEditableNodes
|
|
friend class MoveNodeTransaction; // AllowsTransactionsToChangeSelection,
|
|
// CollapseSelectionTo, 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,
|
|
// InsertLineBreak,
|
|
// JoinNearestEditableNodesWithTransaction,
|
|
// LineBreakType,
|
|
// MoveChildrenWithTransaction,
|
|
// SplitAncestorStyledInlineElementsAt,
|
|
// TreatEmptyTextNodes
|
|
};
|
|
|
|
/**
|
|
* ListElementSelectionState class gets which list element is selected right
|
|
* now.
|
|
*/
|
|
class MOZ_STACK_CLASS ListElementSelectionState final {
|
|
public:
|
|
ListElementSelectionState() = delete;
|
|
ListElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv);
|
|
|
|
bool IsOLElementSelected() const { return mIsOLElementSelected; }
|
|
bool IsULElementSelected() const { return mIsULElementSelected; }
|
|
bool IsDLElementSelected() const { return mIsDLElementSelected; }
|
|
bool IsNotOneTypeListElementSelected() const {
|
|
return (mIsOLElementSelected + mIsULElementSelected + mIsDLElementSelected +
|
|
mIsOtherContentSelected) > 1;
|
|
}
|
|
|
|
private:
|
|
bool mIsOLElementSelected = false;
|
|
bool mIsULElementSelected = false;
|
|
bool mIsDLElementSelected = false;
|
|
bool mIsOtherContentSelected = false;
|
|
};
|
|
|
|
/**
|
|
* ListItemElementSelectionState class gets which list item element is selected
|
|
* right now.
|
|
*/
|
|
class MOZ_STACK_CLASS ListItemElementSelectionState final {
|
|
public:
|
|
ListItemElementSelectionState() = delete;
|
|
ListItemElementSelectionState(HTMLEditor& aHTMLEditor, ErrorResult& aRv);
|
|
|
|
bool IsLIElementSelected() const { return mIsLIElementSelected; }
|
|
bool IsDTElementSelected() const { return mIsDTElementSelected; }
|
|
bool IsDDElementSelected() const { return mIsDDElementSelected; }
|
|
bool IsNotOneTypeDefinitionListItemElementSelected() const {
|
|
return (mIsDTElementSelected + mIsDDElementSelected +
|
|
mIsOtherElementSelected) > 1;
|
|
}
|
|
|
|
private:
|
|
bool mIsLIElementSelected = false;
|
|
bool mIsDTElementSelected = false;
|
|
bool mIsDDElementSelected = false;
|
|
bool mIsOtherElementSelected = false;
|
|
};
|
|
|
|
/**
|
|
* AlignStateAtSelection class gets alignment at selection.
|
|
* XXX This currently returns only first alignment.
|
|
*/
|
|
class MOZ_STACK_CLASS AlignStateAtSelection final {
|
|
public:
|
|
AlignStateAtSelection() = delete;
|
|
MOZ_CAN_RUN_SCRIPT AlignStateAtSelection(HTMLEditor& aHTMLEditor,
|
|
ErrorResult& aRv);
|
|
|
|
nsIHTMLEditor::EAlignment AlignmentAtSelectionStart() const {
|
|
return mFirstAlign;
|
|
}
|
|
bool IsSelectionRangesFound() const { return mFoundSelectionRanges; }
|
|
|
|
private:
|
|
nsIHTMLEditor::EAlignment mFirstAlign = nsIHTMLEditor::eLeft;
|
|
bool mFoundSelectionRanges = false;
|
|
};
|
|
|
|
/**
|
|
* ParagraphStateAtSelection class gets format block types around selection.
|
|
*/
|
|
class MOZ_STACK_CLASS ParagraphStateAtSelection final {
|
|
public:
|
|
using FormatBlockMode = HTMLEditor::FormatBlockMode;
|
|
|
|
ParagraphStateAtSelection() = delete;
|
|
/**
|
|
* @param aFormatBlockMode Whether HTML formatBlock command or XUL
|
|
* paragraphState command.
|
|
*/
|
|
ParagraphStateAtSelection(HTMLEditor& aHTMLEditor,
|
|
FormatBlockMode aFormatBlockMode, ErrorResult& aRv);
|
|
|
|
/**
|
|
* GetFirstParagraphStateAtSelection() returns:
|
|
* - nullptr if there is no format blocks nor inline nodes.
|
|
* - nsGkAtoms::_empty if first node is not in any format block.
|
|
* - a tag name of format block at first node.
|
|
* XXX See the private method explanations. If selection ranges contains
|
|
* non-format block first, it'll be check after its siblings. Therefore,
|
|
* this may return non-first paragraph state.
|
|
*/
|
|
nsAtom* GetFirstParagraphStateAtSelection() const {
|
|
return mIsMixed && mIsInDLElement ? nsGkAtoms::dl
|
|
: mFirstParagraphState.get();
|
|
}
|
|
|
|
/**
|
|
* If selected nodes are not in same format node nor only in no-format blocks,
|
|
* this returns true.
|
|
*/
|
|
bool IsMixed() const { return mIsMixed && !mIsInDLElement; }
|
|
|
|
private:
|
|
using EditorType = EditorBase::EditorType;
|
|
|
|
[[nodiscard]] static bool IsFormatElement(FormatBlockMode aFormatBlockMode,
|
|
const nsIContent& aContent);
|
|
|
|
/**
|
|
* AppendDescendantFormatNodesAndFirstInlineNode() appends descendant
|
|
* format blocks and first inline child node in aNonFormatBlockElement to
|
|
* the last of the array (not inserting where aNonFormatBlockElement is,
|
|
* so that the node order becomes randomly).
|
|
*
|
|
* @param aArrayOfContents [in/out] Found descendant format blocks
|
|
* and first inline node in each non-format
|
|
* block will be appended to this.
|
|
* @param aFormatBlockMode Whether HTML formatBlock command or XUL
|
|
* paragraphState command.
|
|
* @param aNonFormatBlockElement Must be a non-format block element.
|
|
*/
|
|
static void AppendDescendantFormatNodesAndFirstInlineNode(
|
|
nsTArray<OwningNonNull<nsIContent>>& aArrayOfContents,
|
|
FormatBlockMode aFormatBlockMode, dom::Element& aNonFormatBlockElement);
|
|
|
|
/**
|
|
* CollectEditableFormatNodesInSelection() collects only editable nodes
|
|
* around selection ranges (with
|
|
* AutoClonedRangeArray::ExtendRangesToWrapLines() and
|
|
* HTMLEditor::CollectEditTargetNodes(), see its document for the detail).
|
|
* If it includes list, list item or table related elements, they will be
|
|
* replaced their children.
|
|
*
|
|
* @param aFormatBlockMode Whether HTML formatBlock command or XUL
|
|
* paragraphState command.
|
|
*/
|
|
static nsresult CollectEditableFormatNodesInSelection(
|
|
HTMLEditor& aHTMLEditor, FormatBlockMode aFormatBlockMode,
|
|
const dom::Element& aEditingHost,
|
|
nsTArray<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
|