зеркало из https://github.com/mozilla/gecko-dev.git
2692 строки
100 KiB
C++
2692 строки
100 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_EditorBase_h
|
|
#define mozilla_EditorBase_h
|
|
|
|
#include "mozilla/Assertions.h" // for MOZ_ASSERT, etc.
|
|
#include "mozilla/EditAction.h" // for EditAction and EditSubAction
|
|
#include "mozilla/EditorDOMPoint.h" // for EditorDOMPoint
|
|
#include "mozilla/EventForwards.h" // for InputEventTargetRanges
|
|
#include "mozilla/Maybe.h" // for Maybe
|
|
#include "mozilla/OwningNonNull.h" // for OwningNonNull
|
|
#include "mozilla/TypeInState.h" // for PropItem, StyleCache
|
|
#include "mozilla/RangeBoundary.h" // for RawRangeBoundary, RangeBoundary
|
|
#include "mozilla/SelectionState.h" // for RangeUpdater, etc.
|
|
#include "mozilla/StyleSheet.h" // for StyleSheet
|
|
#include "mozilla/TransactionManager.h" // for TransactionManager
|
|
#include "mozilla/WeakPtr.h" // for WeakPtr
|
|
#include "mozilla/dom/DataTransfer.h" // for dom::DataTransfer
|
|
#include "mozilla/dom/HTMLBRElement.h" // for dom::HTMLBRElement
|
|
#include "mozilla/dom/Selection.h"
|
|
#include "mozilla/dom/Text.h"
|
|
#include "nsAtom.h" // for nsAtom, nsStaticAtom
|
|
#include "nsCOMPtr.h" // for already_AddRefed, nsCOMPtr
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIContentInlines.h" // for nsINode::IsEditable()
|
|
#include "nsIEditor.h" // for nsIEditor, etc.
|
|
#include "nsIFrame.h" // for nsBidiLevel
|
|
#include "nsISelectionController.h" // for nsISelectionController constants
|
|
#include "nsISelectionListener.h" // for nsISelectionListener
|
|
#include "nsISupportsImpl.h" // for EditorBase::Release, etc.
|
|
#include "nsIWeakReferenceUtils.h" // for nsWeakPtr
|
|
#include "nsLiteralString.h" // for NS_LITERAL_STRING
|
|
#include "nsPIDOMWindow.h" // for nsPIDOMWindowInner, etc.
|
|
#include "nsString.h" // for nsCString
|
|
#include "nsTArray.h" // for nsTArray and nsAutoTArray
|
|
#include "nsWeakReference.h" // for nsSupportsWeakReference
|
|
#include "nscore.h" // for nsresult, nsAString, etc.
|
|
|
|
class mozInlineSpellChecker;
|
|
class nsAtom;
|
|
class nsCaret;
|
|
class nsIContent;
|
|
class nsIDocumentStateListener;
|
|
class nsIEditActionListener;
|
|
class nsIEditorObserver;
|
|
class nsINode;
|
|
class nsIPrincipal;
|
|
class nsISupports;
|
|
class nsITransferable;
|
|
class nsITransaction;
|
|
class nsITransactionListener;
|
|
class nsIWidget;
|
|
class nsRange;
|
|
|
|
namespace mozilla {
|
|
class AlignStateAtSelection;
|
|
class AutoRangeArray;
|
|
class AutoSelectionRestorer;
|
|
class AutoTopLevelEditSubActionNotifier;
|
|
class AutoTransactionBatch;
|
|
class AutoTransactionsConserveSelection;
|
|
class AutoUpdateViewBatch;
|
|
class ChangeAttributeTransaction;
|
|
class CompositionTransaction;
|
|
class CreateElementTransaction;
|
|
class CSSEditUtils;
|
|
class DeleteNodeTransaction;
|
|
class DeleteRangeTransaction;
|
|
class DeleteTextTransaction;
|
|
class EditActionResult;
|
|
class EditAggregateTransaction;
|
|
class EditorEventListener;
|
|
class EditTransactionBase;
|
|
class ErrorResult;
|
|
class HTMLEditor;
|
|
class HTMLEditUtils;
|
|
class IMEContentObserver;
|
|
class InsertNodeTransaction;
|
|
class InsertTextTransaction;
|
|
class JoinNodeTransaction;
|
|
class ListElementSelectionState;
|
|
class ListItemElementSelectionState;
|
|
class ParagraphStateAtSelection;
|
|
class PlaceholderTransaction;
|
|
class PresShell;
|
|
class ReplaceTextTransaction;
|
|
class SplitNodeResult;
|
|
class SplitNodeTransaction;
|
|
class TextComposition;
|
|
class TextEditor;
|
|
class TextInputListener;
|
|
class TextServicesDocument;
|
|
class TypeInState;
|
|
class WhiteSpaceVisibilityKeeper;
|
|
|
|
template <typename NodeType>
|
|
class CreateNodeResultBase;
|
|
typedef CreateNodeResultBase<dom::Element> CreateElementResult;
|
|
|
|
namespace dom {
|
|
class AbstractRange;
|
|
class DataTransfer;
|
|
class Document;
|
|
class DragEvent;
|
|
class Element;
|
|
class EventTarget;
|
|
class HTMLBRElement;
|
|
} // namespace dom
|
|
|
|
namespace widget {
|
|
struct IMEState;
|
|
} // namespace widget
|
|
|
|
/**
|
|
* Implementation of an editor object. it will be the controller/focal point
|
|
* for the main editor services. i.e. the GUIManager, publishing, transaction
|
|
* manager, event interfaces. the idea for the event interfaces is to have them
|
|
* delegate the actual commands to the editor independent of the XPFE
|
|
* implementation.
|
|
*/
|
|
class EditorBase : public nsIEditor,
|
|
public nsISelectionListener,
|
|
public nsSupportsWeakReference {
|
|
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.
|
|
****************************************************************************/
|
|
|
|
typedef dom::Document Document;
|
|
typedef dom::Element Element;
|
|
typedef dom::Selection Selection;
|
|
typedef dom::Text Text;
|
|
|
|
enum class EditorType { Text, HTML };
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EditorBase, nsIEditor)
|
|
|
|
// nsIEditor methods
|
|
NS_DECL_NSIEDITOR
|
|
|
|
// nsISelectionListener method
|
|
NS_DECL_NSISELECTIONLISTENER
|
|
|
|
/**
|
|
* The default constructor. This should suffice. the setting of the
|
|
* interfaces is done after the construction of the editor class.
|
|
*/
|
|
EditorBase();
|
|
|
|
bool IsTextEditor() const { return !mIsHTMLEditorClass; }
|
|
bool IsHTMLEditor() const { return mIsHTMLEditorClass; }
|
|
|
|
/**
|
|
* Init is to tell the implementation of nsIEditor to begin its services
|
|
* @param aDoc The dom document interface being observed
|
|
* @param aRoot This is the root of the editable section of this
|
|
* document. If it is null then we get root
|
|
* from document body.
|
|
* @param aSelCon this should be used to get the selection location
|
|
* (will be null for HTML editors)
|
|
* @param aFlags A bitmask of flags for specifying the behavior
|
|
* of the editor.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult Init(Document& doc, Element* aRoot,
|
|
nsISelectionController* aSelCon,
|
|
uint32_t aFlags,
|
|
const nsAString& aInitialValue);
|
|
|
|
/**
|
|
* 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.
|
|
* @param aDestroyingFrames set to true when the frames being edited
|
|
* are being destroyed (so there is no need to modify any nsISelections,
|
|
* nor is it safe to do so)
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual void PreDestroy(bool aDestroyingFrames);
|
|
|
|
bool IsInitialized() const { return !!mDocument; }
|
|
bool Destroyed() const { return mDidPreDestroy; }
|
|
|
|
Document* GetDocument() const { return mDocument; }
|
|
nsPIDOMWindowOuter* GetWindow() const;
|
|
nsPIDOMWindowInner* GetInnerWindow() const;
|
|
|
|
/**
|
|
* MayHaveMutationEventListeners() returns true when the window may have
|
|
* mutation event listeners.
|
|
*
|
|
* @param aMutationEventType One or multiple of NS_EVENT_BITS_MUTATION_*.
|
|
* @return true if the editor is an HTMLEditor instance,
|
|
* and at least one of NS_EVENT_BITS_MUTATION_* is
|
|
* set to the window or in debug build.
|
|
*/
|
|
bool MayHaveMutationEventListeners(
|
|
uint32_t aMutationEventType = 0xFFFFFFFF) const {
|
|
if (IsTextEditor()) {
|
|
// DOM mutation event listeners cannot catch the changes of
|
|
// <input type="text"> nor <textarea>.
|
|
return false;
|
|
}
|
|
#ifdef DEBUG
|
|
// On debug build, this should always return true for testing complicated
|
|
// path without mutation event listeners because when mutation event
|
|
// listeners do not touch the DOM, editor needs to run as there is no
|
|
// mutation event listeners.
|
|
return true;
|
|
#else // #ifdef DEBUG
|
|
nsPIDOMWindowInner* window = GetInnerWindow();
|
|
return window ? window->HasMutationListeners(aMutationEventType) : false;
|
|
#endif // #ifdef DEBUG #else
|
|
}
|
|
|
|
/**
|
|
* MayHaveBeforeInputEventListenersForTelemetry() returns true when the
|
|
* window may have or have had one or more `beforeinput` event listeners.
|
|
* Note that this may return false even if there is a `beforeinput`.
|
|
* See nsPIDOMWindowInner::HasBeforeInputEventListenersForTelemetry()'s
|
|
* comment for the detail.
|
|
*/
|
|
bool MayHaveBeforeInputEventListenersForTelemetry() const {
|
|
if (const nsPIDOMWindowInner* window = GetInnerWindow()) {
|
|
return window->HasBeforeInputEventListenersForTelemetry();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* MutationObserverHasObservedNodeForTelemetry() returns true when a node in
|
|
* the window may have been observed by the web apps with a mutation observer
|
|
* (i.e., `MutationObserver.observe()` called by chrome script and addon's
|
|
* script does not make this returns true).
|
|
* Note that this may return false even if there is a node observed by
|
|
* a MutationObserver. See
|
|
* nsPIDOMWindowInner::MutationObserverHasObservedNodeForTelemetry()'s comment
|
|
* for the detail.
|
|
*/
|
|
bool MutationObserverHasObservedNodeForTelemetry() const {
|
|
if (const nsPIDOMWindowInner* window = GetInnerWindow()) {
|
|
return window->MutationObserverHasObservedNodeForTelemetry();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
PresShell* GetPresShell() const;
|
|
nsPresContext* GetPresContext() const;
|
|
already_AddRefed<nsCaret> GetCaret() const;
|
|
|
|
already_AddRefed<nsIWidget> GetWidget();
|
|
|
|
nsISelectionController* GetSelectionController() const;
|
|
|
|
nsresult GetSelection(SelectionType aSelectionType,
|
|
Selection** aSelection) const;
|
|
|
|
Selection* GetSelection(
|
|
SelectionType aSelectionType = SelectionType::eNormal) const {
|
|
if (aSelectionType == SelectionType::eNormal &&
|
|
IsEditActionDataAvailable()) {
|
|
return SelectionRefPtr().get();
|
|
}
|
|
nsISelectionController* sc = GetSelectionController();
|
|
if (!sc) {
|
|
return nullptr;
|
|
}
|
|
Selection* selection = sc->GetSelection(ToRawSelectionType(aSelectionType));
|
|
return selection;
|
|
}
|
|
|
|
/**
|
|
* Fast non-refcounting editor root element accessor
|
|
*/
|
|
Element* GetRoot() const { return mRootElement; }
|
|
|
|
/**
|
|
* Set or unset TextInputListener. If setting non-nullptr when the editor
|
|
* already has a TextInputListener, this will crash in debug build.
|
|
*/
|
|
void SetTextInputListener(TextInputListener* aTextInputListener);
|
|
|
|
/**
|
|
* Set or unset IMEContentObserver. If setting non-nullptr when the editor
|
|
* already has an IMEContentObserver, this will crash in debug build.
|
|
*/
|
|
void SetIMEContentObserver(IMEContentObserver* aIMEContentObserver);
|
|
|
|
/**
|
|
* Returns current composition.
|
|
*/
|
|
TextComposition* GetComposition() const;
|
|
|
|
/**
|
|
* Get preferred IME status of current widget.
|
|
*/
|
|
virtual nsresult GetPreferredIMEState(widget::IMEState* aState);
|
|
|
|
/**
|
|
* Returns true if there is composition string and not fixed.
|
|
*/
|
|
bool IsIMEComposing() const;
|
|
|
|
/**
|
|
* Commit composition if there is.
|
|
* Note that when there is a composition, this requests to commit composition
|
|
* to native IME. Therefore, when there is composition, this can do anything.
|
|
* For example, the editor instance, the widget or the process itself may
|
|
* be destroyed.
|
|
*/
|
|
nsresult CommitComposition();
|
|
|
|
/**
|
|
* ToggleTextDirection() toggles text-direction of the root element.
|
|
*
|
|
* @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
|
|
ToggleTextDirectionAsAction(nsIPrincipal* aPrincipal = nullptr);
|
|
|
|
/**
|
|
* SwitchTextDirectionTo() sets the text-direction of the root element to
|
|
* LTR or RTL.
|
|
*/
|
|
enum class TextDirection {
|
|
eLTR,
|
|
eRTL,
|
|
};
|
|
MOZ_CAN_RUN_SCRIPT void SwitchTextDirectionTo(TextDirection aTextDirection);
|
|
|
|
/**
|
|
* Finalizes selection and caret for the editor.
|
|
*/
|
|
nsresult FinalizeSelection();
|
|
|
|
/**
|
|
* Returns true if selection is in an editable element and both the range
|
|
* start and the range end are editable. E.g., even if the selection range
|
|
* includes non-editable elements, returns true when one of common ancestors
|
|
* of the range start and the range end is editable. Otherwise, false.
|
|
*/
|
|
bool IsSelectionEditable();
|
|
|
|
/**
|
|
* Returns number of undo or redo items.
|
|
*/
|
|
size_t NumberOfUndoItems() const {
|
|
return mTransactionManager ? mTransactionManager->NumberOfUndoItems() : 0;
|
|
}
|
|
size_t NumberOfRedoItems() const {
|
|
return mTransactionManager ? mTransactionManager->NumberOfRedoItems() : 0;
|
|
}
|
|
|
|
/**
|
|
* Returns number of maximum undo/redo transactions.
|
|
*/
|
|
int32_t NumberOfMaximumTransactions() const {
|
|
return mTransactionManager
|
|
? mTransactionManager->NumberOfMaximumTransactions()
|
|
: 0;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this editor can store transactions for undo/redo.
|
|
*/
|
|
bool IsUndoRedoEnabled() const {
|
|
return mTransactionManager &&
|
|
mTransactionManager->NumberOfMaximumTransactions();
|
|
}
|
|
|
|
/**
|
|
* Return true if it's possible to undo/redo right now.
|
|
*/
|
|
bool CanUndo() const {
|
|
return IsUndoRedoEnabled() && NumberOfUndoItems() > 0;
|
|
}
|
|
bool CanRedo() const {
|
|
return IsUndoRedoEnabled() && NumberOfRedoItems() > 0;
|
|
}
|
|
|
|
/**
|
|
* Enables or disables undo/redo feature. Returns true if it succeeded,
|
|
* otherwise, e.g., we're undoing or redoing, returns false.
|
|
*/
|
|
bool EnableUndoRedo(int32_t aMaxTransactionCount = -1) {
|
|
if (!mTransactionManager) {
|
|
mTransactionManager = new TransactionManager();
|
|
}
|
|
return mTransactionManager->EnableUndoRedo(aMaxTransactionCount);
|
|
}
|
|
bool DisableUndoRedo() {
|
|
if (!mTransactionManager) {
|
|
return true;
|
|
}
|
|
return mTransactionManager->DisableUndoRedo();
|
|
}
|
|
bool ClearUndoRedo() {
|
|
if (!mTransactionManager) {
|
|
return true;
|
|
}
|
|
return mTransactionManager->ClearUndoRedo();
|
|
}
|
|
|
|
/**
|
|
* Adds or removes transaction listener to or from the transaction manager.
|
|
* Note that TransactionManager does not check if the listener is in the
|
|
* array. So, caller of AddTransactionListener() needs to manage if it's
|
|
* already been registered to the transaction manager.
|
|
*/
|
|
bool AddTransactionListener(nsITransactionListener& aListener) {
|
|
if (!mTransactionManager) {
|
|
return false;
|
|
}
|
|
return mTransactionManager->AddTransactionListener(aListener);
|
|
}
|
|
bool RemoveTransactionListener(nsITransactionListener& aListener) {
|
|
if (!mTransactionManager) {
|
|
return false;
|
|
}
|
|
return mTransactionManager->RemoveTransactionListener(aListener);
|
|
}
|
|
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult HandleKeyPressEvent(
|
|
WidgetKeyboardEvent* aKeyboardEvent);
|
|
|
|
virtual dom::EventTarget* GetDOMEventTarget() const = 0;
|
|
|
|
/**
|
|
* Similar to the setter for wrapWidth, but just sets the editor
|
|
* internal state without actually changing the content being edited
|
|
* to wrap at that column. This should only be used by callers who
|
|
* are sure that their content is already set up correctly.
|
|
*/
|
|
void SetWrapColumn(int32_t aWrapColumn) { mWrapColumn = aWrapColumn; }
|
|
|
|
/**
|
|
* Accessor methods to flags.
|
|
*/
|
|
uint32_t Flags() const { return mFlags; }
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult AddFlags(uint32_t aFlags) {
|
|
const uint32_t kOldFlags = Flags();
|
|
const uint32_t kNewFlags = (kOldFlags | aFlags);
|
|
if (kNewFlags == kOldFlags) {
|
|
return NS_OK;
|
|
}
|
|
return SetFlags(kNewFlags); // virtual call and may be expensive.
|
|
}
|
|
MOZ_CAN_RUN_SCRIPT nsresult RemoveFlags(uint32_t aFlags) {
|
|
const uint32_t kOldFlags = Flags();
|
|
const uint32_t kNewFlags = (kOldFlags & ~aFlags);
|
|
if (kNewFlags == kOldFlags) {
|
|
return NS_OK;
|
|
}
|
|
return SetFlags(kNewFlags); // virtual call and may be expensive.
|
|
}
|
|
MOZ_CAN_RUN_SCRIPT nsresult AddAndRemoveFlags(uint32_t aAddingFlags,
|
|
uint32_t aRemovingFlags) {
|
|
MOZ_ASSERT(!(aAddingFlags & aRemovingFlags),
|
|
"Same flags are specified both adding and removing");
|
|
const uint32_t kOldFlags = Flags();
|
|
const uint32_t kNewFlags = ((kOldFlags | aAddingFlags) & ~aRemovingFlags);
|
|
if (kNewFlags == kOldFlags) {
|
|
return NS_OK;
|
|
}
|
|
return SetFlags(kNewFlags); // virtual call and may be expensive.
|
|
}
|
|
|
|
bool IsPlaintextEditor() const {
|
|
return (mFlags & nsIEditor::eEditorPlaintextMask) != 0;
|
|
}
|
|
|
|
bool IsSingleLineEditor() const {
|
|
return (mFlags & nsIEditor::eEditorSingleLineMask) != 0;
|
|
}
|
|
|
|
bool IsPasswordEditor() const {
|
|
return (mFlags & nsIEditor::eEditorPasswordMask) != 0;
|
|
}
|
|
|
|
// FYI: Both IsRightToLeft() and IsLeftToRight() may return false if
|
|
// the editor inherits the content node's direction.
|
|
bool IsRightToLeft() const {
|
|
return (mFlags & nsIEditor::eEditorRightToLeft) != 0;
|
|
}
|
|
bool IsLeftToRight() const {
|
|
return (mFlags & nsIEditor::eEditorLeftToRight) != 0;
|
|
}
|
|
|
|
bool IsReadonly() const {
|
|
return (mFlags & nsIEditor::eEditorReadonlyMask) != 0;
|
|
}
|
|
|
|
bool IsInputFiltered() const {
|
|
return (mFlags & nsIEditor::eEditorFilterInputMask) != 0;
|
|
}
|
|
|
|
bool IsMailEditor() const {
|
|
return (mFlags & nsIEditor::eEditorMailMask) != 0;
|
|
}
|
|
|
|
bool IsWrapHackEnabled() const {
|
|
return (mFlags & nsIEditor::eEditorEnableWrapHackMask) != 0;
|
|
}
|
|
|
|
bool IsFormWidget() const {
|
|
return (mFlags & nsIEditor::eEditorWidgetMask) != 0;
|
|
}
|
|
|
|
bool NoCSS() const { return (mFlags & nsIEditor::eEditorNoCSSMask) != 0; }
|
|
|
|
bool IsInteractionAllowed() const {
|
|
return (mFlags & nsIEditor::eEditorAllowInteraction) != 0;
|
|
}
|
|
|
|
bool ShouldSkipSpellCheck() const {
|
|
return (mFlags & nsIEditor::eEditorSkipSpellCheck) != 0;
|
|
}
|
|
|
|
bool IsTabbable() const {
|
|
return IsSingleLineEditor() || IsPasswordEditor() || IsFormWidget() ||
|
|
IsInteractionAllowed();
|
|
}
|
|
|
|
bool HasIndependentSelection() const { return !!mSelectionController; }
|
|
|
|
bool IsModifiable() const { return !IsReadonly(); }
|
|
|
|
/**
|
|
* IsInEditSubAction() return true while the instance is handling an edit
|
|
* sub-action. Otherwise, false.
|
|
*/
|
|
bool IsInEditSubAction() const { return mIsInEditSubAction; }
|
|
|
|
/**
|
|
* SuppressDispatchingInputEvent() suppresses or unsuppresses dispatching
|
|
* "input" event.
|
|
*/
|
|
void SuppressDispatchingInputEvent(bool aSuppress) {
|
|
mDispatchInputEvent = !aSuppress;
|
|
}
|
|
|
|
/**
|
|
* IsSuppressingDispatchingInputEvent() returns true if the editor stops
|
|
* dispatching input event. Otherwise, false.
|
|
*/
|
|
bool IsSuppressingDispatchingInputEvent() const {
|
|
return !mDispatchInputEvent;
|
|
}
|
|
|
|
/**
|
|
* Returns true if markNodeDirty() has any effect. Returns false if
|
|
* markNodeDirty() is a no-op.
|
|
*/
|
|
bool OutputsMozDirty() const {
|
|
// Return true for Composer (!IsInteractionAllowed()) or mail
|
|
// (IsMailEditor()), but false for webpages.
|
|
return !IsInteractionAllowed() || IsMailEditor();
|
|
}
|
|
|
|
/**
|
|
* Get the focused content, if we're focused. Returns null otherwise.
|
|
*/
|
|
virtual nsIContent* GetFocusedContent() const;
|
|
|
|
/**
|
|
* Get the focused content for the argument of some IMEStateManager's
|
|
* methods.
|
|
*/
|
|
virtual nsIContent* GetFocusedContentForIME() const;
|
|
|
|
/**
|
|
* Whether the aGUIEvent should be handled by this editor or not. When this
|
|
* returns false, The aGUIEvent shouldn't be handled on this editor,
|
|
* i.e., The aGUIEvent should be handled by another inner editor or ancestor
|
|
* elements.
|
|
*/
|
|
virtual bool IsAcceptableInputEvent(WidgetGUIEvent* aGUIEvent) const;
|
|
|
|
/**
|
|
* FindSelectionRoot() returns a selection root of this editor when aNode
|
|
* gets focus. aNode must be a content node or a document node. When the
|
|
* target isn't a part of this editor, returns nullptr. If this is for
|
|
* designMode, you should set the document node to aNode except that an
|
|
* element in the document has focus.
|
|
*/
|
|
virtual Element* FindSelectionRoot(nsINode* aNode) const;
|
|
|
|
/**
|
|
* This method has to be called by EditorEventListener::Focus.
|
|
* All actions that have to be done when the editor is focused needs to be
|
|
* added here.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void OnFocus(nsINode& aFocusEventTargetNode);
|
|
|
|
/** Resyncs spellchecking state (enabled/disabled). This should be called
|
|
* when anything that affects spellchecking state changes, such as the
|
|
* spellcheck attribute value.
|
|
*/
|
|
void SyncRealTimeSpell();
|
|
|
|
/**
|
|
* This method re-initializes the selection and caret state that are for
|
|
* current editor state. When editor session is destroyed, it always reset
|
|
* selection state even if this has no focus. So if destroying editor,
|
|
* we have to call this method for focused editor to set selection state.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void ReinitializeSelection(Element& aElement);
|
|
|
|
/**
|
|
* InsertTextAsAction() inserts aStringToInsert at selection.
|
|
* Although this method is implementation of nsIEditor.insertText(),
|
|
* this treats the input is an edit action. If you'd like to insert text
|
|
* as part of edit action, you probably should use InsertTextAsSubAction().
|
|
*
|
|
* @param aStringToInsert The string to insert.
|
|
* @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 InsertTextAsAction(
|
|
const nsAString& aStringToInsert, nsIPrincipal* aPrincipal = nullptr);
|
|
|
|
/**
|
|
* DeleteSelectionAsAction() removes selection content or content around
|
|
* caret with transactions. This should be used for handling it as an
|
|
* edit action. If you'd like to remove selection for preparing to insert
|
|
* something, you probably should use DeleteSelectionAsSubAction().
|
|
*
|
|
* @param aDirectionAndAmount How much range should be removed.
|
|
* @param aStripWrappers Whether the parent blocks should be removed
|
|
* when they become empty.
|
|
* @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
|
|
DeleteSelectionAsAction(nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers,
|
|
nsIPrincipal* aPrincipal = nullptr);
|
|
|
|
protected: // May be used by friends.
|
|
class AutoEditActionDataSetter;
|
|
|
|
/**
|
|
* TopLevelEditSubActionData stores temporary data while we're handling
|
|
* top-level edit sub-action.
|
|
*/
|
|
struct MOZ_STACK_CLASS TopLevelEditSubActionData final {
|
|
friend class AutoEditActionDataSetter;
|
|
|
|
// If we have created a new block element, set to it.
|
|
RefPtr<Element> mNewBlockElement;
|
|
|
|
// Set selected range before edit. Then, RangeUpdater keep modifying
|
|
// the range while we're changing the DOM tree.
|
|
RefPtr<RangeItem> mSelectedRange;
|
|
|
|
// Computing changed range while we're handling sub actions.
|
|
RefPtr<nsRange> mChangedRange;
|
|
|
|
// XXX In strict speaking, mCachedInlineStyles isn't enough to cache inline
|
|
// styles because inline style can be specified with "style" attribute
|
|
// and/or CSS in <style> elements or CSS files. So, we need to look
|
|
// for better implementation about this.
|
|
// FYI: Initialization cost of AutoStyleCacheArray is expensive and it is
|
|
// not used by TextEditor so that we should construct it only when
|
|
// we're an HTMLEditor.
|
|
Maybe<AutoStyleCacheArray> mCachedInlineStyles;
|
|
|
|
// If we tried to delete selection, set to true.
|
|
bool mDidDeleteSelection;
|
|
|
|
// If we have explicitly set selection inter line, set to true.
|
|
// `AfterEdit()` or something shouldn't overwrite it in such case.
|
|
bool mDidExplicitlySetInterLine;
|
|
|
|
// If we have deleted non-collapsed range set to true, there are only 2
|
|
// cases for now:
|
|
// - non-collapsed range was selected.
|
|
// - selection was collapsed in a text node and a Unicode character
|
|
// was removed.
|
|
bool mDidDeleteNonCollapsedRange;
|
|
|
|
// If we have deleted parent empty blocks, set to true.
|
|
bool mDidDeleteEmptyParentBlocks;
|
|
|
|
// If we're a contenteditable editor, we temporarily increase edit count
|
|
// of the document between `BeforeEdit()` and `AfterEdit()`. I.e., if
|
|
// we increased the count in `BeforeEdit()`, we need to decrease it in
|
|
// `AfterEdit()`, however, the document may be changed to designMode or
|
|
// non-editable. Therefore, we need to store with this whether we need
|
|
// to restore it.
|
|
bool mRestoreContentEditableCount;
|
|
|
|
// If we explicitly normalized whitespaces around the changed range,
|
|
// set to true.
|
|
bool mDidNormalizeWhitespaces;
|
|
|
|
/**
|
|
* The following methods modifies some data of this struct and
|
|
* `EditSubActionData` struct. Currently, these are required only
|
|
* by `HTMLEditor`. Therefore, for cutting the runtime cost of
|
|
* `TextEditor`, these methods should be called only by `HTMLEditor`.
|
|
* But it's fine to use these methods in `TextEditor` if necessary.
|
|
* If so, you need to call `DidDeleteText()` and `DidInsertText()`
|
|
* from `SetTextNodeWithoutTransaction()`.
|
|
*/
|
|
void DidCreateElement(EditorBase& aEditorBase, Element& aNewElement);
|
|
void DidInsertContent(EditorBase& aEditorBase, nsIContent& aNewContent);
|
|
void WillDeleteContent(EditorBase& aEditorBase,
|
|
nsIContent& aRemovingContent);
|
|
void DidSplitContent(EditorBase& aEditorBase,
|
|
nsIContent& aExistingRightContent,
|
|
nsIContent& aNewLeftContent);
|
|
void WillJoinContents(EditorBase& aEditorBase, nsIContent& aLeftContent,
|
|
nsIContent& aRightContent);
|
|
void DidJoinContents(EditorBase& aEditorBase, nsIContent& aLeftContent,
|
|
nsIContent& aRightContent);
|
|
void DidInsertText(EditorBase& aEditorBase,
|
|
const EditorRawDOMPoint& aInsertionBegin,
|
|
const EditorRawDOMPoint& aInsertionEnd);
|
|
void DidDeleteText(EditorBase& aEditorBase,
|
|
const EditorRawDOMPoint& aStartInTextNode);
|
|
void WillDeleteRange(EditorBase& aEditorBase,
|
|
const EditorRawDOMPoint& aStart,
|
|
const EditorRawDOMPoint& aEnd);
|
|
|
|
private:
|
|
void Clear() {
|
|
mDidExplicitlySetInterLine = false;
|
|
// We don't need to clear other members which are referred only when the
|
|
// editor is an HTML editor anymore. Note that if `mSelectedRange` is
|
|
// non-nullptr, that means that we're in `HTMLEditor`.
|
|
if (!mSelectedRange) {
|
|
return;
|
|
}
|
|
mNewBlockElement = nullptr;
|
|
mSelectedRange->Clear();
|
|
mChangedRange->Reset();
|
|
if (mCachedInlineStyles.isSome()) {
|
|
mCachedInlineStyles->Clear();
|
|
}
|
|
mDidDeleteSelection = false;
|
|
mDidDeleteNonCollapsedRange = false;
|
|
mDidDeleteEmptyParentBlocks = false;
|
|
mRestoreContentEditableCount = false;
|
|
mDidNormalizeWhitespaces = false;
|
|
}
|
|
|
|
/**
|
|
* Extend mChangedRange to include `aNode`.
|
|
*/
|
|
nsresult AddNodeToChangedRange(const HTMLEditor& aHTMLEditor,
|
|
nsINode& aNode);
|
|
|
|
/**
|
|
* Extend mChangedRange to include `aPoint`.
|
|
*/
|
|
nsresult AddPointToChangedRange(const HTMLEditor& aHTMLEditor,
|
|
const EditorRawDOMPoint& aPoint);
|
|
|
|
/**
|
|
* Extend mChangedRange to include `aStart` and `aEnd`.
|
|
*/
|
|
nsresult AddRangeToChangedRange(const HTMLEditor& aHTMLEditor,
|
|
const EditorRawDOMPoint& aStart,
|
|
const EditorRawDOMPoint& aEnd);
|
|
|
|
TopLevelEditSubActionData() = default;
|
|
TopLevelEditSubActionData(const TopLevelEditSubActionData& aOther) = delete;
|
|
};
|
|
|
|
struct MOZ_STACK_CLASS EditSubActionData final {
|
|
uint32_t mJoinedLeftNodeLength;
|
|
|
|
// While this is set to false, TopLevelEditSubActionData::mChangedRange
|
|
// shouldn't be modified since in some cases, modifying it in the setter
|
|
// itself may be faster. Note that we should affect this only for current
|
|
// edit sub action since mutation event listener may edit different range.
|
|
bool mAdjustChangedRangeFromListener;
|
|
|
|
private:
|
|
void Clear() {
|
|
mJoinedLeftNodeLength = 0;
|
|
mAdjustChangedRangeFromListener = true;
|
|
}
|
|
|
|
friend EditorBase;
|
|
};
|
|
|
|
protected: // AutoEditActionDataSetter, this shouldn't be accessed by friends.
|
|
/**
|
|
* SettingDataTransfer enum class is used to specify whether DataTransfer
|
|
* should be initialized with or without format. For example, when user
|
|
* uses Accel + Shift + V to paste text without format, DataTransfer should
|
|
* have only plain/text data to make web apps treat it without format.
|
|
*/
|
|
enum class SettingDataTransfer {
|
|
eWithFormat,
|
|
eWithoutFormat,
|
|
};
|
|
|
|
/**
|
|
* AutoEditActionDataSetter grabs some necessary objects for handling any
|
|
* edit actions and store the edit action what we're handling. When this is
|
|
* created, its pointer is set to the mEditActionData, and this guarantees
|
|
* the lifetime of grabbing objects until it's destroyed.
|
|
*/
|
|
class MOZ_STACK_CLASS AutoEditActionDataSetter final {
|
|
public:
|
|
// NOTE: aPrincipal will be used when we implement "beforeinput" event.
|
|
// It's set only when maybe we shouldn't dispatch it because of
|
|
// called by JS. I.e., if this is nullptr, we can always dispatch
|
|
// it.
|
|
AutoEditActionDataSetter(const EditorBase& aEditorBase,
|
|
EditAction aEditAction,
|
|
nsIPrincipal* aPrincipal = nullptr);
|
|
~AutoEditActionDataSetter();
|
|
|
|
void UpdateEditAction(EditAction aEditAction) {
|
|
MOZ_ASSERT(!mHasTriedToDispatchBeforeInputEvent,
|
|
"It's too late to update EditAction since this may have "
|
|
"already dispatched a beforeinput event");
|
|
mEditAction = aEditAction;
|
|
}
|
|
|
|
/**
|
|
* CanHandle() or CanHandleAndHandleBeforeInput() must be called
|
|
* immediately after creating the instance. If caller does not need to
|
|
* handle "beforeinput" event or caller needs to set additional information
|
|
* the events later, use the former. Otherwise, use the latter. If caller
|
|
* uses the former, it's required to call MaybeDispatchBeforeInputEvent() by
|
|
* itself.
|
|
*
|
|
*/
|
|
[[nodiscard]] bool CanHandle() const {
|
|
#ifdef DEBUG
|
|
mHasCanHandleChecked = true;
|
|
#endif // #ifdefn DEBUG
|
|
return mSelection && mEditorBase.IsInitialized();
|
|
}
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
CanHandleAndMaybeDispatchBeforeInputEvent() {
|
|
if (NS_WARN_IF(!CanHandle())) {
|
|
return NS_ERROR_NOT_INITIALIZED;
|
|
}
|
|
return MaybeDispatchBeforeInputEvent();
|
|
}
|
|
|
|
/**
|
|
* MaybeDispatchBeforeInputEvent() considers whether this instance needs to
|
|
* dispatch "beforeinput" event or not. Then,
|
|
* mHasTriedToDispatchBeforeInputEvent is set to true.
|
|
*
|
|
* @param aDeleteDirectionAndAmount
|
|
* If `MayEditActionDeleteAroundCollapsedSelection(
|
|
* mEditAction)` returns true, this must be set.
|
|
* Otherwise, don't set explicitly.
|
|
* @return If this method actually dispatches "beforeinput" event
|
|
* and it's canceled, returns
|
|
* NS_ERROR_EDITOR_ACTION_CANCELED.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MaybeDispatchBeforeInputEvent(
|
|
nsIEditor::EDirection aDeleteDirectionAndAmount = nsIEditor::eNone);
|
|
|
|
/**
|
|
* MarkAsBeforeInputHasBeenDispatched() should be called only when updating
|
|
* the DOM occurs asynchronously from user input (e.g., inserting blob
|
|
* object which is loaded asynchronously) and `beforeinput` has already
|
|
* been dispatched (always should be so).
|
|
*/
|
|
void MarkAsBeforeInputHasBeenDispatched() {
|
|
MOZ_ASSERT(!HasTriedToDispatchBeforeInputEvent());
|
|
MOZ_ASSERT(mEditAction == EditAction::ePaste ||
|
|
mEditAction == EditAction::ePasteAsQuotation ||
|
|
mEditAction == EditAction::eDrop);
|
|
mHasTriedToDispatchBeforeInputEvent = true;
|
|
}
|
|
|
|
/**
|
|
* ShouldAlreadyHaveHandledBeforeInputEventDispatching() returns true if the
|
|
* edit action requires to handle "beforeinput" event but not yet dispatched
|
|
* it nor considered as not dispatched it and can dispatch it when this is
|
|
* called.
|
|
*/
|
|
bool ShouldAlreadyHaveHandledBeforeInputEventDispatching() const {
|
|
return !HasTriedToDispatchBeforeInputEvent() &&
|
|
NeedsBeforeInputEventHandling(mEditAction) &&
|
|
IsBeforeInputEventEnabled() /* &&
|
|
// If we still need to dispatch a clipboard event, we should
|
|
// dispatch it first, then, we need to dispatch beforeinput
|
|
// event later.
|
|
!NeedsToDispatchClipboardEvent()*/
|
|
;
|
|
}
|
|
|
|
/**
|
|
* HasTriedToDispatchBeforeInputEvent() returns true if the instance's
|
|
* MaybeDispatchBeforeInputEvent() has already been called.
|
|
*/
|
|
bool HasTriedToDispatchBeforeInputEvent() const {
|
|
return mHasTriedToDispatchBeforeInputEvent;
|
|
}
|
|
|
|
bool IsCanceled() const { return mBeforeInputEventCanceled; }
|
|
|
|
const RefPtr<Selection>& SelectionRefPtr() const {
|
|
MOZ_ASSERT(!mSelection ||
|
|
(mSelection->GetType() == SelectionType::eNormal));
|
|
|
|
return mSelection;
|
|
}
|
|
|
|
nsIPrincipal* GetPrincipal() const { return mPrincipal; }
|
|
EditAction GetEditAction() const { return mEditAction; }
|
|
|
|
template <typename PT, typename CT>
|
|
void SetSpellCheckRestartPoint(const EditorDOMPointBase<PT, CT>& aPoint) {
|
|
MOZ_ASSERT(aPoint.IsSet());
|
|
// We should store only container and offset because new content may
|
|
// be inserted before referring child.
|
|
// XXX Shouldn't we compare whether aPoint is before
|
|
// mSpellCheckRestartPoint if it's set.
|
|
mSpellCheckRestartPoint =
|
|
EditorDOMPoint(aPoint.GetContainer(), aPoint.Offset());
|
|
}
|
|
void ClearSpellCheckRestartPoint() { mSpellCheckRestartPoint.Clear(); }
|
|
const EditorDOMPoint& GetSpellCheckRestartPoint() const {
|
|
return mSpellCheckRestartPoint;
|
|
}
|
|
|
|
void SetData(const nsAString& aData) {
|
|
MOZ_ASSERT(!mHasTriedToDispatchBeforeInputEvent,
|
|
"It's too late to set data since this may have already "
|
|
"dispatched a beforeinput event");
|
|
mData = aData;
|
|
}
|
|
const nsString& GetData() const { return mData; }
|
|
|
|
void SetColorData(const nsAString& aData);
|
|
|
|
/**
|
|
* InitializeDataTransfer(DataTransfer*) sets mDataTransfer to
|
|
* aDataTransfer. In this case, aDataTransfer should not be read/write
|
|
* because it'll be set to InputEvent.dataTransfer and which should be
|
|
* read-only.
|
|
*/
|
|
void InitializeDataTransfer(dom::DataTransfer* aDataTransfer);
|
|
/**
|
|
* InitializeDataTransfer(nsITransferable*) creates new DataTransfer
|
|
* instance, initializes it with aTransferable and sets mDataTransfer to
|
|
* it.
|
|
*/
|
|
void InitializeDataTransfer(nsITransferable* aTransferable);
|
|
/**
|
|
* InitializeDataTransfer(const nsAString&) creates new DataTransfer
|
|
* instance, initializes it with aString and sets mDataTransfer to it.
|
|
*/
|
|
void InitializeDataTransfer(const nsAString& aString);
|
|
/**
|
|
* InitializeDataTransferWithClipboard() creates new DataTransfer instance,
|
|
* initializes it with clipboard and sets mDataTransfer to it.
|
|
*/
|
|
void InitializeDataTransferWithClipboard(
|
|
SettingDataTransfer aSettingDataTransfer, int32_t aClipboardType);
|
|
dom::DataTransfer* GetDataTransfer() const { return mDataTransfer; }
|
|
|
|
/**
|
|
* AppendTargetRange() appends aTargetRange to target ranges. This should
|
|
* be used only by edit action handlers which do not want to set target
|
|
* ranges to selection ranges.
|
|
*/
|
|
void AppendTargetRange(dom::StaticRange& aTargetRange);
|
|
|
|
/**
|
|
* Make dispatching `beforeinput` forcibly non-cancelable.
|
|
*/
|
|
void MakeBeforeInputEventNonCancelable() {
|
|
mMakeBeforeInputEventNonCancelable = true;
|
|
}
|
|
|
|
/**
|
|
* NotifyOfDispatchingClipboardEvent() is called after dispatching
|
|
* a clipboard event.
|
|
*/
|
|
void NotifyOfDispatchingClipboardEvent() {
|
|
MOZ_ASSERT(NeedsToDispatchClipboardEvent());
|
|
MOZ_ASSERT(!mHasTriedToDispatchClipboardEvent);
|
|
mHasTriedToDispatchClipboardEvent = true;
|
|
}
|
|
|
|
void Abort() { mAborted = true; }
|
|
bool IsAborted() const { return mAborted; }
|
|
|
|
void SetTopLevelEditSubAction(EditSubAction aEditSubAction,
|
|
EDirection aDirection = eNone) {
|
|
mTopLevelEditSubAction = aEditSubAction;
|
|
TopLevelEditSubActionDataRef().Clear();
|
|
switch (mTopLevelEditSubAction) {
|
|
case EditSubAction::eInsertNode:
|
|
case EditSubAction::eCreateNode:
|
|
case EditSubAction::eSplitNode:
|
|
case EditSubAction::eInsertText:
|
|
case EditSubAction::eInsertTextComingFromIME:
|
|
case EditSubAction::eSetTextProperty:
|
|
case EditSubAction::eRemoveTextProperty:
|
|
case EditSubAction::eRemoveAllTextProperties:
|
|
case EditSubAction::eSetText:
|
|
case EditSubAction::eInsertLineBreak:
|
|
case EditSubAction::eInsertParagraphSeparator:
|
|
case EditSubAction::eCreateOrChangeList:
|
|
case EditSubAction::eIndent:
|
|
case EditSubAction::eOutdent:
|
|
case EditSubAction::eSetOrClearAlignment:
|
|
case EditSubAction::eCreateOrRemoveBlock:
|
|
case EditSubAction::eMergeBlockContents:
|
|
case EditSubAction::eRemoveList:
|
|
case EditSubAction::eCreateOrChangeDefinitionListItem:
|
|
case EditSubAction::eInsertElement:
|
|
case EditSubAction::eInsertQuotation:
|
|
case EditSubAction::eInsertQuotedText:
|
|
case EditSubAction::ePasteHTMLContent:
|
|
case EditSubAction::eInsertHTMLSource:
|
|
case EditSubAction::eSetPositionToAbsolute:
|
|
case EditSubAction::eSetPositionToStatic:
|
|
case EditSubAction::eDecreaseZIndex:
|
|
case EditSubAction::eIncreaseZIndex:
|
|
MOZ_ASSERT(aDirection == eNext);
|
|
mDirectionOfTopLevelEditSubAction = eNext;
|
|
break;
|
|
case EditSubAction::eJoinNodes:
|
|
case EditSubAction::eDeleteText:
|
|
MOZ_ASSERT(aDirection == ePrevious);
|
|
mDirectionOfTopLevelEditSubAction = ePrevious;
|
|
break;
|
|
case EditSubAction::eUndo:
|
|
case EditSubAction::eRedo:
|
|
case EditSubAction::eComputeTextToOutput:
|
|
case EditSubAction::eCreatePaddingBRElementForEmptyEditor:
|
|
case EditSubAction::eNone:
|
|
MOZ_ASSERT(aDirection == eNone);
|
|
mDirectionOfTopLevelEditSubAction = eNone;
|
|
break;
|
|
case EditSubAction::eReplaceHeadWithHTMLSource:
|
|
// NOTE: Not used with AutoTopLevelEditSubActionNotifier.
|
|
mDirectionOfTopLevelEditSubAction = eNone;
|
|
break;
|
|
case EditSubAction::eDeleteNode:
|
|
case EditSubAction::eDeleteSelectedContent:
|
|
// Unfortunately, eDeleteNode and eDeleteSelectedContent is used with
|
|
// any direction. We might have specific sub-action for each
|
|
// direction, but there are some points referencing
|
|
// eDeleteSelectedContent so that we should keep storing direction
|
|
// as-is for now.
|
|
mDirectionOfTopLevelEditSubAction = aDirection;
|
|
break;
|
|
}
|
|
}
|
|
EditSubAction GetTopLevelEditSubAction() const {
|
|
MOZ_ASSERT(CanHandle());
|
|
return mTopLevelEditSubAction;
|
|
}
|
|
EDirection GetDirectionOfTopLevelEditSubAction() const {
|
|
return mDirectionOfTopLevelEditSubAction;
|
|
}
|
|
|
|
const TopLevelEditSubActionData& TopLevelEditSubActionDataRef() const {
|
|
return mParentData ? mParentData->TopLevelEditSubActionDataRef()
|
|
: mTopLevelEditSubActionData;
|
|
}
|
|
TopLevelEditSubActionData& TopLevelEditSubActionDataRef() {
|
|
return mParentData ? mParentData->TopLevelEditSubActionDataRef()
|
|
: mTopLevelEditSubActionData;
|
|
}
|
|
|
|
const EditSubActionData& EditSubActionDataRef() const {
|
|
return mEditSubActionData;
|
|
}
|
|
EditSubActionData& EditSubActionDataRef() { return mEditSubActionData; }
|
|
|
|
SelectionState& SavedSelectionRef() {
|
|
return mParentData ? mParentData->SavedSelectionRef() : mSavedSelection;
|
|
}
|
|
const SelectionState& SavedSelectionRef() const {
|
|
return mParentData ? mParentData->SavedSelectionRef() : mSavedSelection;
|
|
}
|
|
|
|
RangeUpdater& RangeUpdaterRef() {
|
|
return mParentData ? mParentData->RangeUpdaterRef() : mRangeUpdater;
|
|
}
|
|
const RangeUpdater& RangeUpdaterRef() const {
|
|
return mParentData ? mParentData->RangeUpdaterRef() : mRangeUpdater;
|
|
}
|
|
|
|
void UpdateSelectionCache(Selection& aSelection) {
|
|
MOZ_ASSERT(aSelection.GetType() == SelectionType::eNormal);
|
|
|
|
AutoEditActionDataSetter* actionData = this;
|
|
while (actionData) {
|
|
if (actionData->mSelection) {
|
|
actionData->mSelection = &aSelection;
|
|
}
|
|
actionData = actionData->mParentData;
|
|
}
|
|
}
|
|
|
|
private:
|
|
bool IsBeforeInputEventEnabled() const;
|
|
|
|
static bool NeedsBeforeInputEventHandling(EditAction aEditAction) {
|
|
MOZ_ASSERT(aEditAction != EditAction::eNone);
|
|
switch (aEditAction) {
|
|
case EditAction::eNone:
|
|
// If we're not handling edit action, we don't need to handle
|
|
// "beforeinput" event.
|
|
case EditAction::eNotEditing:
|
|
// If raw level transaction API is used, the API user needs to handle
|
|
// both "beforeinput" event and "input" event if it's necessary.
|
|
case EditAction::eUnknown:
|
|
// Hiding/showing password affects only layout so that we don't need
|
|
// to handle beforeinput event for it.
|
|
case EditAction::eHidePassword:
|
|
// We don't need to dispatch "beforeinput" event before
|
|
// "compositionstart".
|
|
case EditAction::eStartComposition:
|
|
// We don't need to let web apps know the mode change.
|
|
case EditAction::eEnableOrDisableCSS:
|
|
case EditAction::eEnableOrDisableAbsolutePositionEditor:
|
|
case EditAction::eEnableOrDisableResizer:
|
|
case EditAction::eEnableOrDisableInlineTableEditingUI:
|
|
// We don't need to let contents in chrome's editor to know the size
|
|
// change.
|
|
case EditAction::eSetWrapWidth:
|
|
// While resizing or moving element, we update only shadow, i.e.,
|
|
// don't touch to the DOM in content. Therefore, we don't need to
|
|
// dispatch "beforeinput" event.
|
|
case EditAction::eResizingElement:
|
|
case EditAction::eMovingElement:
|
|
// Perhaps, we don't need to dispatch "beforeinput" event for
|
|
// padding `<br>` element for empty editor because it's internal
|
|
// handling and it should be occurred by another change.
|
|
case EditAction::eCreatePaddingBRElementForEmptyEditor:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool NeedsToDispatchClipboardEvent() const {
|
|
if (mHasTriedToDispatchClipboardEvent) {
|
|
return false;
|
|
}
|
|
switch (mEditAction) {
|
|
case EditAction::ePaste:
|
|
case EditAction::ePasteAsQuotation:
|
|
case EditAction::eCut:
|
|
case EditAction::eCopy:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
EditorBase& mEditorBase;
|
|
RefPtr<Selection> mSelection;
|
|
nsCOMPtr<nsIPrincipal> mPrincipal;
|
|
// EditAction may be nested, for example, a command may be executed
|
|
// from mutation event listener which is run while editor changes
|
|
// the DOM tree. In such case, we need to handle edit action separately.
|
|
AutoEditActionDataSetter* mParentData;
|
|
|
|
// Cached selection for AutoSelectionRestorer.
|
|
SelectionState mSavedSelection;
|
|
|
|
// Utility class object for maintaining preserved ranges.
|
|
RangeUpdater mRangeUpdater;
|
|
|
|
// The data should be set to InputEvent.data.
|
|
nsString mData;
|
|
|
|
// The dataTransfer should be set to InputEvent.dataTransfer.
|
|
RefPtr<dom::DataTransfer> mDataTransfer;
|
|
|
|
// They are used for result of InputEvent.getTargetRanges() of beforeinput.
|
|
OwningNonNullStaticRangeArray mTargetRanges;
|
|
|
|
// Start point where spell checker should check from. This is used only
|
|
// by TextEditor.
|
|
EditorDOMPoint mSpellCheckRestartPoint;
|
|
|
|
// Different from mTopLevelEditSubAction, its data should be stored only
|
|
// in the most ancestor AutoEditActionDataSetter instance since we don't
|
|
// want to pay the copying cost and sync cost.
|
|
TopLevelEditSubActionData mTopLevelEditSubActionData;
|
|
|
|
// Different from mTopLevelEditSubActionData, this stores temporaly data
|
|
// for current edit sub action.
|
|
EditSubActionData mEditSubActionData;
|
|
|
|
EditAction mEditAction;
|
|
|
|
// Different from its data, you can refer "current" AutoEditActionDataSetter
|
|
// instance's mTopLevelEditSubAction member since it's copied from the
|
|
// parent instance at construction and it's always cleared before this
|
|
// won't be overwritten and cleared before destruction.
|
|
EditSubAction mTopLevelEditSubAction;
|
|
|
|
EDirection mDirectionOfTopLevelEditSubAction;
|
|
|
|
bool mAborted;
|
|
|
|
// Set to true when this handles "beforeinput" event dispatching. Note
|
|
// that even if "beforeinput" event shouldn't be dispatched for this,
|
|
// instance, this is set to true when it's considered.
|
|
bool mHasTriedToDispatchBeforeInputEvent;
|
|
// Set to true if "beforeinput" event was dispatched and it's canceled.
|
|
bool mBeforeInputEventCanceled;
|
|
// Set to true if `beforeinput` event must not be cancelable even if
|
|
// its inputType is defined as cancelable by the standards.
|
|
bool mMakeBeforeInputEventNonCancelable;
|
|
// Set to true when the edit action handler tries to dispatch a clipboard
|
|
// event.
|
|
bool mHasTriedToDispatchClipboardEvent;
|
|
|
|
#ifdef DEBUG
|
|
mutable bool mHasCanHandleChecked = false;
|
|
#endif // #ifdef DEBUG
|
|
|
|
AutoEditActionDataSetter() = delete;
|
|
AutoEditActionDataSetter(const AutoEditActionDataSetter& aOther) = delete;
|
|
};
|
|
|
|
void UpdateEditActionData(const nsAString& aData) {
|
|
mEditActionData->SetData(aData);
|
|
}
|
|
|
|
void NotifyOfDispatchingClipboardEvent() {
|
|
MOZ_ASSERT(mEditActionData);
|
|
mEditActionData->NotifyOfDispatchingClipboardEvent();
|
|
}
|
|
|
|
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.
|
|
****************************************************************************/
|
|
|
|
bool IsEditActionCanceled() const {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData->IsCanceled();
|
|
}
|
|
|
|
bool ShouldAlreadyHaveHandledBeforeInputEventDispatching() const {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData
|
|
->ShouldAlreadyHaveHandledBeforeInputEventDispatching();
|
|
}
|
|
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MaybeDispatchBeforeInputEvent() {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData->MaybeDispatchBeforeInputEvent();
|
|
}
|
|
|
|
void MarkAsBeforeInputHasBeenDispatched() {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData->MarkAsBeforeInputHasBeenDispatched();
|
|
}
|
|
|
|
bool HasTriedToDispatchBeforeInputEvent() const {
|
|
return mEditActionData &&
|
|
mEditActionData->HasTriedToDispatchBeforeInputEvent();
|
|
}
|
|
|
|
bool IsEditActionDataAvailable() const {
|
|
return mEditActionData && mEditActionData->CanHandle();
|
|
}
|
|
|
|
bool IsTopLevelEditSubActionDataAvailable() const {
|
|
return mEditActionData && !!GetTopLevelEditSubAction();
|
|
}
|
|
|
|
bool IsEditActionAborted() const {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData->IsAborted();
|
|
}
|
|
|
|
/**
|
|
* SelectionRefPtr() returns cached Selection. This is pretty faster than
|
|
* EditorBase::GetSelection() if available.
|
|
* Note that this never returns nullptr unless public methods ignore
|
|
* result of AutoEditActionDataSetter::CanHandle() and keep handling edit
|
|
* action but any methods should stop handling edit action if it returns
|
|
* false.
|
|
*/
|
|
const RefPtr<Selection>& SelectionRefPtr() const {
|
|
MOZ_ASSERT(mEditActionData);
|
|
MOZ_ASSERT(mEditActionData->SelectionRefPtr()->GetType() ==
|
|
SelectionType::eNormal);
|
|
|
|
return mEditActionData->SelectionRefPtr();
|
|
}
|
|
|
|
nsIPrincipal* GetEditActionPrincipal() const {
|
|
MOZ_ASSERT(mEditActionData);
|
|
return mEditActionData->GetPrincipal();
|
|
}
|
|
|
|
/**
|
|
* GetEditAction() returns EditAction which is being handled. If some
|
|
* edit actions are nested, this returns the innermost edit action.
|
|
*/
|
|
EditAction GetEditAction() const {
|
|
return mEditActionData ? mEditActionData->GetEditAction()
|
|
: EditAction::eNone;
|
|
}
|
|
|
|
/**
|
|
* GetInputEventData() returns inserting or inserted text value with
|
|
* current edit action. The result is proper for InputEvent.data value.
|
|
*/
|
|
const nsString& GetInputEventData() const {
|
|
return mEditActionData ? mEditActionData->GetData() : VoidString();
|
|
}
|
|
|
|
/**
|
|
* GetInputEventDataTransfer() returns inserting or inserted transferable
|
|
* content with current edit action. The result is proper for
|
|
* InputEvent.dataTransfer value.
|
|
*/
|
|
dom::DataTransfer* GetInputEventDataTransfer() const {
|
|
return mEditActionData ? mEditActionData->GetDataTransfer() : nullptr;
|
|
}
|
|
|
|
/**
|
|
* GetTopLevelEditSubAction() returns the top level edit sub-action.
|
|
* For example, if selected content is being replaced with inserted text,
|
|
* while removing selected content, the top level edit sub-action may be
|
|
* EditSubAction::eDeleteSelectedContent. However, while inserting new
|
|
* text, the top level edit sub-action may be EditSubAction::eInsertText.
|
|
* So, this result means what we are doing right now unless you're looking
|
|
* for a case which the method is called via mutation event listener or
|
|
* selectionchange event listener which are fired while handling the edit
|
|
* sub-action.
|
|
*/
|
|
EditSubAction GetTopLevelEditSubAction() const {
|
|
return mEditActionData ? mEditActionData->GetTopLevelEditSubAction()
|
|
: EditSubAction::eNone;
|
|
}
|
|
|
|
/**
|
|
* GetDirectionOfTopLevelEditSubAction() returns direction which user
|
|
* intended for doing the edit sub-action.
|
|
*/
|
|
EDirection GetDirectionOfTopLevelEditSubAction() const {
|
|
return mEditActionData
|
|
? mEditActionData->GetDirectionOfTopLevelEditSubAction()
|
|
: eNone;
|
|
}
|
|
|
|
/**
|
|
* SavedSelection() returns reference to saved selection which are
|
|
* stored by AutoSelectionRestorer.
|
|
*/
|
|
SelectionState& SavedSelectionRef() {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->SavedSelectionRef();
|
|
}
|
|
const SelectionState& SavedSelectionRef() const {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->SavedSelectionRef();
|
|
}
|
|
|
|
RangeUpdater& RangeUpdaterRef() {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->RangeUpdaterRef();
|
|
}
|
|
const RangeUpdater& RangeUpdaterRef() const {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->RangeUpdaterRef();
|
|
}
|
|
|
|
template <typename PT, typename CT>
|
|
void SetSpellCheckRestartPoint(const EditorDOMPointBase<PT, CT>& aPoint) {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->SetSpellCheckRestartPoint(aPoint);
|
|
}
|
|
|
|
void ClearSpellCheckRestartPoint() {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->ClearSpellCheckRestartPoint();
|
|
}
|
|
|
|
const EditorDOMPoint& GetSpellCheckRestartPoint() const {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->GetSpellCheckRestartPoint();
|
|
}
|
|
|
|
const TopLevelEditSubActionData& TopLevelEditSubActionDataRef() const {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->TopLevelEditSubActionDataRef();
|
|
}
|
|
TopLevelEditSubActionData& TopLevelEditSubActionDataRef() {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->TopLevelEditSubActionDataRef();
|
|
}
|
|
|
|
const EditSubActionData& EditSubActionDataRef() const {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->EditSubActionDataRef();
|
|
}
|
|
EditSubActionData& EditSubActionDataRef() {
|
|
MOZ_ASSERT(IsEditActionDataAvailable());
|
|
return mEditActionData->EditSubActionDataRef();
|
|
}
|
|
|
|
/**
|
|
* GetCompositionStartPoint() and GetCompositionEndPoint() returns start and
|
|
* end point of composition string if there is. Otherwise, returns non-set
|
|
* DOM point.
|
|
*/
|
|
EditorRawDOMPoint GetCompositionStartPoint() const;
|
|
EditorRawDOMPoint GetCompositionEndPoint() const;
|
|
|
|
/**
|
|
* IsSelectionRangeContainerNotContent() returns true if one of container
|
|
* of selection ranges is not a content node, i.e., a Document node.
|
|
*/
|
|
bool IsSelectionRangeContainerNotContent() const;
|
|
|
|
/**
|
|
* InsertTextAsSubAction() inserts aStringToInsert at selection. This
|
|
* should be used for handling it as an edit sub-action.
|
|
*
|
|
* @param aStringToInsert The string to insert.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
InsertTextAsSubAction(const nsAString& aStringToInsert);
|
|
|
|
/**
|
|
* InsertTextWithTransaction() inserts aStringToInsert to aPointToInsert or
|
|
* better insertion point around it. If aPointToInsert isn't in a text node,
|
|
* this method looks for the nearest point in a text node with
|
|
* FindBetterInsertionPoint(). If there is no text node, this creates
|
|
* new text node and put aStringToInsert to it.
|
|
*
|
|
* @param aDocument The document of this editor.
|
|
* @param aStringToInsert The string to insert.
|
|
* @param aPointToInser The point to insert aStringToInsert.
|
|
* Must be valid DOM point.
|
|
* @param aPointAfterInsertedString
|
|
* The point after inserted aStringToInsert.
|
|
* So, when this method actually inserts string,
|
|
* this is set to a point in the text node.
|
|
* Otherwise, this may be set to aPointToInsert.
|
|
* @return When this succeeds to insert the string or
|
|
* does nothing during composition, returns NS_OK.
|
|
* Otherwise, an error code.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult InsertTextWithTransaction(
|
|
Document& aDocument, const nsAString& aStringToInsert,
|
|
const EditorRawDOMPoint& aPointToInsert,
|
|
EditorRawDOMPoint* aPointAfterInsertedString = nullptr);
|
|
|
|
/**
|
|
* InsertTextIntoTextNodeWithTransaction() inserts aStringToInsert into
|
|
* aOffset of aTextNode with transaction.
|
|
*
|
|
* @param aStringToInsert String to be inserted.
|
|
* @param aPointToInsert The insertion point.
|
|
* @param aSuppressIME true if it's not a part of IME composition.
|
|
* E.g., adjusting white-spaces during composition.
|
|
* false, otherwise.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertTextIntoTextNodeWithTransaction(
|
|
const nsAString& aStringToInsert,
|
|
const EditorDOMPointInText& aPointToInsert, bool aSuppressIME = false);
|
|
|
|
/**
|
|
* SetTextNodeWithoutTransaction() is optimized path to set new value to
|
|
* the text node directly and without transaction. This is used when
|
|
* setting `<input>.value` and `<textarea>.value`.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
SetTextNodeWithoutTransaction(const nsAString& aString, Text& aTextNode);
|
|
|
|
/**
|
|
* DeleteNodeWithTransaction() removes aContent from the DOM tree.
|
|
*
|
|
* @param aContent The node which will be removed form the DOM tree.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult DeleteNodeWithTransaction(nsIContent& aContent);
|
|
|
|
/**
|
|
* InsertNodeWithTransaction() inserts aContentToInsert before the child
|
|
* specified by aPointToInsert.
|
|
*
|
|
* @param aContentToInsert The node to be inserted.
|
|
* @param aPointToInsert The insertion point of aContentToInsert.
|
|
* If this refers end of the container, the
|
|
* transaction will append the node to the
|
|
* container. Otherwise, will insert the node
|
|
* before child node referred by this.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult InsertNodeWithTransaction(
|
|
nsIContent& aContentToInsert, const EditorDOMPoint& aPointToInsert);
|
|
|
|
/**
|
|
* InsertPaddingBRElementForEmptyLastLineWithTransaction() creates a padding
|
|
* <br> element with setting flags to NS_PADDING_FOR_EMPTY_LAST_LINE and
|
|
* inserts it around aPointToInsert.
|
|
*
|
|
* @param aPointToInsert The DOM point where should be <br> node inserted
|
|
* before.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT CreateElementResult
|
|
InsertPaddingBRElementForEmptyLastLineWithTransaction(
|
|
const EditorDOMPoint& aPointToInsert);
|
|
|
|
/**
|
|
* CloneAttributesWithTransaction() clones all attributes from
|
|
* aSourceElement to aDestElement after removing all attributes in
|
|
* aDestElement.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void CloneAttributesWithTransaction(
|
|
Element& aDestElement, Element& aSourceElement);
|
|
|
|
/**
|
|
* CloneAttributeWithTransaction() copies aAttribute of aSourceElement to
|
|
* aDestElement. If aSourceElement doesn't have aAttribute, this removes
|
|
* aAttribute from aDestElement.
|
|
*
|
|
* @param aAttribute Attribute name to be cloned.
|
|
* @param aDestElement Element node which will be set aAttribute or
|
|
* whose aAttribute will be removed.
|
|
* @param aSourceElement Element node which provides the value of
|
|
* aAttribute in aDestElement.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult CloneAttributeWithTransaction(
|
|
nsAtom& aAttribute, Element& aDestElement, Element& aSourceElement);
|
|
|
|
/**
|
|
* RemoveAttributeWithTransaction() removes aAttribute from aElement.
|
|
*
|
|
* @param aElement Element node which will lose aAttribute.
|
|
* @param aAttribute Attribute name to be removed from aElement.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
RemoveAttributeWithTransaction(Element& aElement, nsAtom& aAttribute);
|
|
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult RemoveAttributeOrEquivalent(
|
|
Element* aElement, nsAtom* aAttribute, bool aSuppressTransaction) = 0;
|
|
|
|
/**
|
|
* SetAttributeWithTransaction() sets aAttribute of aElement to aValue.
|
|
*
|
|
* @param aElement Element node which will have aAttribute.
|
|
* @param aAttribute Attribute name to be set.
|
|
* @param aValue Attribute value be set to aAttribute.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult SetAttributeWithTransaction(
|
|
Element& aElement, nsAtom& aAttribute, const nsAString& aValue);
|
|
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult SetAttributeOrEquivalent(
|
|
Element* aElement, nsAtom* aAttribute, const nsAString& aValue,
|
|
bool aSuppressTransaction) = 0;
|
|
|
|
/**
|
|
* Method to replace certain CreateElementNS() calls.
|
|
*
|
|
* @param aTag Tag you want.
|
|
*/
|
|
already_AddRefed<Element> CreateHTMLContent(const nsAtom* aTag);
|
|
|
|
/**
|
|
* Creates text node which is marked as "maybe modified frequently" and
|
|
* "maybe masked" if this is a password editor.
|
|
*/
|
|
already_AddRefed<nsTextNode> CreateTextNode(const nsAString& aData);
|
|
|
|
/**
|
|
* DoInsertText(), DoDeleteText(), DoReplaceText() and DoSetText() are
|
|
* wrapper of `CharacterData::InsertData()`, `CharacterData::DeleteData()`,
|
|
* `CharacterData::ReplaceData()` and `CharacterData::SetData()`.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void DoInsertText(dom::Text& aText, uint32_t aOffset,
|
|
const nsAString& aStringToInsert,
|
|
ErrorResult& aRv);
|
|
MOZ_CAN_RUN_SCRIPT void DoDeleteText(dom::Text& aText, uint32_t aOffset,
|
|
uint32_t aCount, ErrorResult& aRv);
|
|
MOZ_CAN_RUN_SCRIPT void DoReplaceText(dom::Text& aText, uint32_t aOffset,
|
|
uint32_t aCount,
|
|
const nsAString& aStringToInsert,
|
|
ErrorResult& aRv);
|
|
MOZ_CAN_RUN_SCRIPT void DoSetText(dom::Text& aText,
|
|
const nsAString& aStringToSet,
|
|
ErrorResult& aRv);
|
|
|
|
/**
|
|
* Create an element node whose name is aTag at before aPointToInsert. When
|
|
* this succeed to create an element node, this sets aPointToInsert to the
|
|
* new element because the relation of child and offset may be broken.
|
|
* If the caller needs to collapse the selection to next to the new element
|
|
* node, it should call |aPointToInsert.AdvanceOffset()| after calling this.
|
|
*
|
|
* @param aTag 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.
|
|
* @return The created new element node.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT already_AddRefed<Element> CreateNodeWithTransaction(
|
|
nsAtom& aTag, const EditorDOMPoint& aPointToInsert);
|
|
|
|
/**
|
|
* DeleteTextWithTransaction() removes text in the range from aTextNode.
|
|
*
|
|
* @param aTextNode The text node which should be modified.
|
|
* @param aOffset Start offset of removing text in aTextNode.
|
|
* @param aLength Length of removing text.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult DeleteTextWithTransaction(dom::Text& aTextNode,
|
|
uint32_t aOffset,
|
|
uint32_t aLength);
|
|
|
|
/**
|
|
* EnsureNoPaddingBRElementForEmptyEditor() removes padding <br> element
|
|
* for empty editor if there is.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
EnsureNoPaddingBRElementForEmptyEditor();
|
|
|
|
/**
|
|
* MaybeCreatePaddingBRElementForEmptyEditor() creates padding <br> element
|
|
* for empty editor if there is no children.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
MaybeCreatePaddingBRElementForEmptyEditor();
|
|
|
|
/**
|
|
* MarkElementDirty() sets a special dirty attribute on the element.
|
|
* Usually this will be called immediately after creating a new node.
|
|
*
|
|
* @param aElement The element for which to insert formatting.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult MarkElementDirty(Element& aElement);
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
DoTransactionInternal(nsITransaction* aTransaction);
|
|
|
|
/**
|
|
* Get the previous node.
|
|
*/
|
|
nsIContent* GetPreviousNode(const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, false, true, false);
|
|
}
|
|
nsIContent* GetPreviousElementOrText(const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, false, false, false);
|
|
}
|
|
nsIContent* GetPreviousEditableNode(const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, true, true, false);
|
|
}
|
|
nsIContent* GetPreviousNodeInBlock(const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, false, true, true);
|
|
}
|
|
nsIContent* GetPreviousElementOrTextInBlock(
|
|
const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, false, false, true);
|
|
}
|
|
nsIContent* GetPreviousEditableNodeInBlock(
|
|
const EditorRawDOMPoint& aPoint) const {
|
|
return GetPreviousNodeInternal(aPoint, true, true, true);
|
|
}
|
|
nsIContent* GetPreviousNode(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, false, true, false);
|
|
}
|
|
nsIContent* GetPreviousElementOrText(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, false, false, false);
|
|
}
|
|
nsIContent* GetPreviousEditableNode(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, true, true, false);
|
|
}
|
|
nsIContent* GetPreviousNodeInBlock(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, false, true, true);
|
|
}
|
|
nsIContent* GetPreviousElementOrTextInBlock(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, false, false, true);
|
|
}
|
|
nsIContent* GetPreviousEditableNodeInBlock(const nsINode& aNode) const {
|
|
return GetPreviousNodeInternal(aNode, true, true, true);
|
|
}
|
|
|
|
/**
|
|
* Get the next node.
|
|
*
|
|
* Note that methods taking EditorRawDOMPoint behavior includes the
|
|
* child at offset as search target. E.g., following code causes infinite
|
|
* loop.
|
|
*
|
|
* EditorRawDOMPoint point(aEditableNode);
|
|
* while (nsIContent* content = GetNextEditableNode(point)) {
|
|
* // Do something...
|
|
* point.Set(content);
|
|
* }
|
|
*
|
|
* Following code must be you expected:
|
|
*
|
|
* while (nsIContent* content = GetNextEditableNode(point)) {
|
|
* // Do something...
|
|
* DebugOnly<bool> advanced = point.Advanced();
|
|
* MOZ_ASSERT(advanced);
|
|
* point.Set(point.GetChild());
|
|
* }
|
|
*
|
|
* On the other hand, the methods taking nsINode behavior must be what
|
|
* you want. They start to search the result from next node of the given
|
|
* node.
|
|
*/
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextNode(const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, false, true, false);
|
|
}
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextElementOrText(
|
|
const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, false, false, false);
|
|
}
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextEditableNode(
|
|
const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, true, true, false);
|
|
}
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextNodeInBlock(
|
|
const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, false, true, true);
|
|
}
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextElementOrTextInBlock(
|
|
const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, false, false, true);
|
|
}
|
|
template <typename PT, typename CT>
|
|
nsIContent* GetNextEditableNodeInBlock(
|
|
const EditorDOMPointBase<PT, CT>& aPoint) const {
|
|
return GetNextNodeInternal(aPoint, true, true, true);
|
|
}
|
|
nsIContent* GetNextNode(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, false, true, false);
|
|
}
|
|
nsIContent* GetNextElementOrText(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, false, false, false);
|
|
}
|
|
nsIContent* GetNextEditableNode(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, true, true, false);
|
|
}
|
|
nsIContent* GetNextNodeInBlock(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, false, true, true);
|
|
}
|
|
nsIContent* GetNextElementOrTextInBlock(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, false, false, true);
|
|
}
|
|
nsIContent* GetNextEditableNodeInBlock(const nsINode& aNode) const {
|
|
return GetNextNodeInternal(aNode, true, true, true);
|
|
}
|
|
|
|
/**
|
|
* Returns true if aNode is our root node.
|
|
*/
|
|
bool IsRoot(const nsINode* inNode) const;
|
|
bool IsEditorRoot(const nsINode* aNode) const;
|
|
|
|
/**
|
|
* Returns true if aNode is a descendant of our root node.
|
|
*/
|
|
bool IsDescendantOfRoot(const nsINode* inNode) const;
|
|
bool IsDescendantOfEditorRoot(const nsINode* aNode) const;
|
|
|
|
/**
|
|
* Counts number of editable child nodes.
|
|
*/
|
|
uint32_t CountEditableChildren(nsINode* aNode);
|
|
|
|
/**
|
|
* Find the deep first and last children.
|
|
*/
|
|
nsINode* GetFirstEditableNode(nsINode* aRoot);
|
|
|
|
/**
|
|
* Returns true when inserting text should be a part of current composition.
|
|
*/
|
|
bool ShouldHandleIMEComposition() const;
|
|
|
|
/**
|
|
* GetNodeAtRangeOffsetPoint() returns the node at this position in a range,
|
|
* assuming that the container is the node itself if it's a text node, or
|
|
* the node's parent otherwise.
|
|
*/
|
|
static nsIContent* GetNodeAtRangeOffsetPoint(nsINode* aContainer,
|
|
int32_t aOffset) {
|
|
return GetNodeAtRangeOffsetPoint(RawRangeBoundary(aContainer, aOffset));
|
|
}
|
|
static nsIContent* GetNodeAtRangeOffsetPoint(const RawRangeBoundary& aPoint);
|
|
|
|
static EditorRawDOMPoint GetStartPoint(const Selection& aSelection);
|
|
static EditorRawDOMPoint GetEndPoint(const Selection& aSelection);
|
|
|
|
static nsresult GetEndChildNode(const Selection& aSelection,
|
|
nsIContent** aEndNode);
|
|
|
|
/**
|
|
* CollapseSelectionToEnd() collapses the selection to the end of the editor.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult CollapseSelectionToEnd() const;
|
|
|
|
/**
|
|
* AllowsTransactionsToChangeSelection() returns true if editor allows any
|
|
* transactions to change Selection. Otherwise, transactions shouldn't
|
|
* change Selection.
|
|
*/
|
|
inline bool AllowsTransactionsToChangeSelection() const {
|
|
return mAllowsTransactionsToChangeSelection;
|
|
}
|
|
|
|
/**
|
|
* MakeThisAllowTransactionsToChangeSelection() with true makes this editor
|
|
* allow transactions to change Selection. Otherwise, i.e., with false,
|
|
* makes this editor not allow transactions to change Selection.
|
|
*/
|
|
inline void MakeThisAllowTransactionsToChangeSelection(bool aAllow) {
|
|
mAllowsTransactionsToChangeSelection = aAllow;
|
|
}
|
|
|
|
nsresult HandleInlineSpellCheck(
|
|
const EditorDOMPoint& aPreviouslySelectedStart,
|
|
const dom::AbstractRange* aRange = nullptr);
|
|
|
|
/**
|
|
* Likewise, but gets the editor's root instead, which is different for HTML
|
|
* editors.
|
|
*/
|
|
virtual Element* GetEditorRoot() const;
|
|
|
|
/**
|
|
* Likewise, but gets the text control element instead of the root for
|
|
* plaintext editors.
|
|
*/
|
|
Element* GetExposedRoot() const;
|
|
|
|
/**
|
|
* Whether the editor is active on the DOM window. Note that when this
|
|
* returns true but GetFocusedContent() returns null, it means that this
|
|
* editor was focused when the DOM window was active.
|
|
*/
|
|
virtual bool IsActiveInDOMWindow() const;
|
|
|
|
/**
|
|
* FindBetterInsertionPoint() tries to look for better insertion point which
|
|
* is typically the nearest text node and offset in it.
|
|
*
|
|
* @param aPoint Insertion point which the callers found.
|
|
* @return Better insertion point if there is. If not returns
|
|
* same point as aPoint.
|
|
*/
|
|
EditorRawDOMPoint FindBetterInsertionPoint(
|
|
const EditorRawDOMPoint& aPoint) const;
|
|
|
|
/**
|
|
* HideCaret() hides caret with nsCaret::AddForceHide() or may show carent
|
|
* with nsCaret::RemoveForceHide(). This does NOT set visibility of
|
|
* nsCaret. Therefore, this is stateless.
|
|
*/
|
|
void HideCaret(bool aHide);
|
|
|
|
protected: // Edit sub-action handler
|
|
/**
|
|
* AutoCaretBidiLevelManager() computes bidi level of caret, deleting
|
|
* character(s) from aPointAtCaret at construction. Then, if you'll
|
|
* need to extend the selection, you should calls `UpdateCaretBidiLevel()`,
|
|
* then, this class may update caret bidi level for you if it's required.
|
|
*/
|
|
class MOZ_RAII AutoCaretBidiLevelManager final {
|
|
public:
|
|
/**
|
|
* @param aEditorBase The editor.
|
|
* @param aPointAtCaret Collapsed `Selection` point.
|
|
* @param aDirectionAndAmount The direction and amount to delete.
|
|
*/
|
|
template <typename PT, typename CT>
|
|
AutoCaretBidiLevelManager(const EditorBase& aEditorBase,
|
|
nsIEditor::EDirection aDirectionAndAmount,
|
|
const EditorDOMPointBase<PT, CT>& aPointAtCaret);
|
|
|
|
/**
|
|
* Failed() returns true if the constructor failed to handle the bidi
|
|
* information.
|
|
*/
|
|
bool Failed() const { return mFailed; }
|
|
|
|
/**
|
|
* Canceled() returns true if when the caller should stop deleting
|
|
* characters since caret position is not visually adjacent the deleting
|
|
* characters and user does not wand to delete them in that case.
|
|
*/
|
|
bool Canceled() const { return mCanceled; }
|
|
|
|
/**
|
|
* MaybeUpdateCaretBidiLevel() may update caret bidi level and schedule to
|
|
* paint it if they are necessary.
|
|
*/
|
|
void MaybeUpdateCaretBidiLevel(const EditorBase& aEditorBase) const;
|
|
|
|
private:
|
|
Maybe<nsBidiLevel> mNewCaretBidiLevel;
|
|
bool mFailed = false;
|
|
bool mCanceled = false;
|
|
};
|
|
|
|
/**
|
|
* UndefineCaretBidiLevel() resets bidi level of the caret.
|
|
*/
|
|
void UndefineCaretBidiLevel() const;
|
|
|
|
/**
|
|
* Flushing pending notifications if nsFrameSelection requires the latest
|
|
* layout information to compute deletion range. This may destroy the
|
|
* editor instance itself. When this returns false, don't keep doing
|
|
* anything.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT bool
|
|
FlushPendingNotificationsIfToHandleDeletionWithFrameSelection(
|
|
nsIEditor::EDirection aDirectionAndAmount) const;
|
|
|
|
/**
|
|
* DeleteSelectionAsSubAction() removes selection content or content around
|
|
* caret with transactions. This should be used for handling it as an
|
|
* edit sub-action.
|
|
*
|
|
* @param aDirectionAndAmount How much range should be removed.
|
|
* @param aStripWrappers Whether the parent blocks should be removed
|
|
* when they become empty. If this instance is
|
|
* a TextEditor, Must be nsIEditor::eNoStrip.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
DeleteSelectionAsSubAction(nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers);
|
|
|
|
/**
|
|
* This method handles "delete selection" commands.
|
|
* NOTE: Don't call this method recursively from the helper methods since
|
|
* when nobody handled it without canceling and returing an error,
|
|
* this falls it back to `DeleteSelectionWithTransaction()`.
|
|
*
|
|
* @param aDirectionAndAmount Direction of the deletion.
|
|
* @param aStripWrappers Must be nsIEditor::eNoStrip if this is a
|
|
* TextEditor instance. Otherwise,
|
|
* nsIEditor::eStrip is also valid.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT virtual EditActionResult
|
|
HandleDeleteSelection(nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers) = 0;
|
|
|
|
protected: // Called by helper classes.
|
|
/**
|
|
* OnStartToHandleTopLevelEditSubAction() is called when
|
|
* GetTopLevelEditSubAction() is EditSubAction::eNone and somebody starts to
|
|
* handle aEditSubAction.
|
|
*
|
|
* @param aTopLevelEditSubAction Top level edit sub action which
|
|
* will be handled soon.
|
|
* @param aDirectionOfTopLevelEditSubAction Direction of aEditSubAction.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual void OnStartToHandleTopLevelEditSubAction(
|
|
EditSubAction aTopLevelEditSubAction,
|
|
nsIEditor::EDirection aDirectionOfTopLevelEditSubAction,
|
|
ErrorResult& aRv);
|
|
|
|
/**
|
|
* OnEndHandlingTopLevelEditSubAction() is called after
|
|
* SetTopLevelEditSubAction() is handled.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult OnEndHandlingTopLevelEditSubAction();
|
|
|
|
/**
|
|
* OnStartToHandleEditSubAction() and OnEndHandlingEditSubAction() are called
|
|
* when starting to handle an edit sub action and ending handling an edit
|
|
* sub action.
|
|
*/
|
|
void OnStartToHandleEditSubAction() { EditSubActionDataRef().Clear(); }
|
|
void OnEndHandlingEditSubAction() { EditSubActionDataRef().Clear(); }
|
|
|
|
/**
|
|
* Routines for managing the preservation of selection across
|
|
* various editor actions.
|
|
*/
|
|
bool ArePreservingSelection();
|
|
void PreserveSelectionAcrossActions();
|
|
nsresult RestorePreservedSelection();
|
|
void StopPreservingSelection();
|
|
|
|
/**
|
|
* (Begin|End)PlaceholderTransaction() are called by AutoPlaceholderBatch.
|
|
* This set of methods are similar to the (Begin|End)Transaction(), but do
|
|
* not use the transaction managers batching feature. Instead we use a
|
|
* placeholder transaction to wrap up any further transaction while the
|
|
* batch is open. The advantage of this is that placeholder transactions
|
|
* can later merge, if needed. Merging is unavailable between transaction
|
|
* manager batches.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY void BeginPlaceholderTransaction(
|
|
nsStaticAtom& aTransactionName);
|
|
enum class ScrollSelectionIntoView { No, Yes };
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY void EndPlaceholderTransaction(
|
|
ScrollSelectionIntoView aScrollSelectionIntoView);
|
|
|
|
void BeginUpdateViewBatch();
|
|
MOZ_CAN_RUN_SCRIPT void EndUpdateViewBatch();
|
|
|
|
/**
|
|
* Used by AutoTransactionBatch. After calling BeginTransactionInternal(),
|
|
* all transactions will be treated as an atomic transaction. I.e.,
|
|
* two or more transactions are undid once.
|
|
* XXX What's the difference with PlaceholderTransaction? Should we always
|
|
* use it instead?
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void BeginTransactionInternal();
|
|
MOZ_CAN_RUN_SCRIPT void EndTransactionInternal();
|
|
|
|
protected: // Shouldn't be used by friend classes
|
|
/**
|
|
* The default destructor. This should suffice. Should this be pure virtual
|
|
* for someone to derive from the EditorBase later? I don't believe so.
|
|
*/
|
|
virtual ~EditorBase();
|
|
|
|
MOZ_ALWAYS_INLINE EditorType GetEditorType() const {
|
|
return mIsHTMLEditorClass ? EditorType::HTML : EditorType::Text;
|
|
}
|
|
|
|
int32_t WrapWidth() const { return mWrapColumn; }
|
|
|
|
/**
|
|
* ToGenericNSResult() computes proper nsresult value for the editor users.
|
|
* This should be used only when public methods return result of internal
|
|
* methods.
|
|
*/
|
|
static inline nsresult ToGenericNSResult(nsresult aRv) {
|
|
switch (aRv) {
|
|
// If the editor is destroyed while handling an edit action, editor needs
|
|
// to stop handling it. However, editor throw exception in this case
|
|
// because Chrome does not throw exception even in this case.
|
|
case NS_ERROR_EDITOR_DESTROYED:
|
|
return NS_OK;
|
|
// If editor meets unexpected DOM tree due to modified by mutation event
|
|
// listener, editor needs to stop handling it. However, editor shouldn't
|
|
// return error for the users because Chrome does not throw exception in
|
|
// this case.
|
|
case NS_ERROR_EDITOR_UNEXPECTED_DOM_TREE:
|
|
return NS_OK;
|
|
// If the editing action is canceled by event listeners, editor needs
|
|
// to stop handling it. However, editor shouldn't return error for
|
|
// the callers but they should be able to distinguish whether it's
|
|
// canceled or not. Although it's DOM specific code, let's return
|
|
// DOM_SUCCESS_DOM_NO_OPERATION here.
|
|
case NS_ERROR_EDITOR_ACTION_CANCELED:
|
|
return NS_SUCCESS_DOM_NO_OPERATION;
|
|
default:
|
|
return aRv;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GetDocumentCharsetInternal() returns charset of the document.
|
|
*/
|
|
nsresult GetDocumentCharsetInternal(nsACString& aCharset) const;
|
|
|
|
/**
|
|
* SelectAllInternal() should be used instead of SelectAll() in editor
|
|
* because SelectAll() creates AutoEditActionSetter but we should avoid
|
|
* to create it as far as possible.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult SelectAllInternal();
|
|
|
|
nsresult DetermineCurrentDirection();
|
|
|
|
/**
|
|
* DispatchInputEvent() dispatches an "input" event synchronously or
|
|
* asynchronously if it's not safe to dispatch.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void DispatchInputEvent();
|
|
|
|
/**
|
|
* Called after a transaction is done successfully.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void DoAfterDoTransaction(nsITransaction* aTransaction);
|
|
|
|
/**
|
|
* Called after a transaction is undone successfully.
|
|
*/
|
|
|
|
MOZ_CAN_RUN_SCRIPT void DoAfterUndoTransaction();
|
|
|
|
/**
|
|
* Called after a transaction is redone successfully.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT void DoAfterRedoTransaction();
|
|
|
|
/**
|
|
* Tell the doc state listeners that the doc state has changed.
|
|
*/
|
|
enum TDocumentListenerNotification {
|
|
eDocumentCreated,
|
|
eDocumentToBeDestroyed,
|
|
eDocumentStateChanged
|
|
};
|
|
MOZ_CAN_RUN_SCRIPT nsresult
|
|
NotifyDocumentListeners(TDocumentListenerNotification aNotificationType);
|
|
|
|
/**
|
|
* Make the given selection span the entire document.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT virtual nsresult SelectEntireDocument() = 0;
|
|
|
|
/**
|
|
* Helper method for scrolling the selection into view after
|
|
* an edit operation.
|
|
*
|
|
* Editor methods *should* call this method instead of the versions
|
|
* in the various selection interfaces, since this makes sure that
|
|
* the editor's sync/async settings for reflowing, painting, and scrolling
|
|
* match.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult ScrollSelectionFocusIntoView();
|
|
|
|
/**
|
|
* Helper for GetPreviousNodeInternal() and GetNextNodeInternal().
|
|
*/
|
|
nsIContent* FindNextLeafNode(const nsINode* aCurrentNode, bool aGoForward,
|
|
bool bNoBlockCrossing) const;
|
|
nsIContent* FindNode(const nsINode* aCurrentNode, bool aGoForward,
|
|
bool aEditableNode, bool aFindAnyDataNode,
|
|
bool bNoBlockCrossing) const;
|
|
|
|
/**
|
|
* Get the node immediately previous node of aNode.
|
|
* @param atNode The node from which we start the search.
|
|
* @param aFindEditableNode If true, only return an editable node.
|
|
* @param aFindAnyDataNode If true, may return invisible data node
|
|
* like Comment.
|
|
* @param aNoBlockCrossing If true, don't move across "block" nodes,
|
|
* whatever that means.
|
|
* @return The node that occurs before aNode in
|
|
* the tree, skipping non-editable nodes if
|
|
* aFindEditableNode is true. If there is no
|
|
* previous node, returns nullptr.
|
|
*/
|
|
nsIContent* GetPreviousNodeInternal(const nsINode& aNode,
|
|
bool aFindEditableNode,
|
|
bool aFindAnyDataNode,
|
|
bool aNoBlockCrossing) const;
|
|
|
|
/**
|
|
* And another version that takes a point in DOM tree rather than a node.
|
|
*/
|
|
nsIContent* GetPreviousNodeInternal(const EditorRawDOMPoint& aPoint,
|
|
bool aFindEditableNode,
|
|
bool aFindAnyDataNode,
|
|
bool aNoBlockCrossing) const;
|
|
|
|
/**
|
|
* Get the node immediately next node of aNode.
|
|
* @param aNode The node from which we start the search.
|
|
* @param aFindEditableNode If true, only return an editable node.
|
|
* @param aFindAnyDataNode If true, may return invisible data node
|
|
* like Comment.
|
|
* @param aNoBlockCrossing If true, don't move across "block" nodes,
|
|
* whatever that means.
|
|
* @return The node that occurs after aNode in the
|
|
* tree, skipping non-editable nodes if
|
|
* aFindEditableNode is true. If there is no
|
|
* next node, returns nullptr.
|
|
*/
|
|
nsIContent* GetNextNodeInternal(const nsINode& aNode, bool aFindEditableNode,
|
|
bool aFindAnyDataNode,
|
|
bool aNoBlockCrossing) const;
|
|
|
|
/**
|
|
* And another version that takes a point in DOM tree rather than a node.
|
|
*/
|
|
nsIContent* GetNextNodeInternal(const EditorRawDOMPoint& aPoint,
|
|
bool aFindEditableNode, bool aFindAnyDataNode,
|
|
bool aNoBlockCrossing) const;
|
|
|
|
virtual nsresult InstallEventListeners();
|
|
virtual void CreateEventListeners();
|
|
virtual void RemoveEventListeners();
|
|
|
|
/**
|
|
* Get the input event target. This might return null.
|
|
*/
|
|
virtual already_AddRefed<Element> GetInputEventTargetElement() const = 0;
|
|
|
|
/**
|
|
* Return true if spellchecking should be enabled for this editor.
|
|
*/
|
|
bool GetDesiredSpellCheckState();
|
|
|
|
bool CanEnableSpellCheck() {
|
|
// Check for password/readonly/disabled, which are not spellchecked
|
|
// regardless of DOM. Also, check to see if spell check should be skipped
|
|
// or not.
|
|
return !IsPasswordEditor() && !IsReadonly() && !ShouldSkipSpellCheck();
|
|
}
|
|
|
|
/**
|
|
* InitializeSelectionAncestorLimit() is called by InitializeSelection().
|
|
* When this is called, each implementation has to call
|
|
* Selection::SetAncestorLimiter() with aAnotherLimit.
|
|
*
|
|
* @param aAncestorLimit New ancestor limit of Selection. This always
|
|
* has parent node. So, it's always safe to
|
|
* call SetAncestorLimit() with this node.
|
|
*/
|
|
virtual void InitializeSelectionAncestorLimit(
|
|
nsIContent& aAncestorLimit) const;
|
|
|
|
/**
|
|
* Creates a range with just the supplied node and appends that to the
|
|
* selection.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
|
|
AppendNodeToSelectionAsRange(nsINode* aNode);
|
|
|
|
/**
|
|
* When you are using AppendNodeToSelectionAsRange(), call this first to
|
|
* start a new selection.
|
|
*/
|
|
nsresult ClearSelection();
|
|
|
|
/**
|
|
* Initializes selection and caret for the editor. If aEventTarget isn't
|
|
* a host of the editor, i.e., the editor doesn't get focus, this does
|
|
* nothing.
|
|
*/
|
|
MOZ_CAN_RUN_SCRIPT nsresult InitializeSelection(nsINode& aFocusEventTarget);
|
|
|
|
enum NotificationForEditorObservers {
|
|
eNotifyEditorObserversOfEnd,
|
|
eNotifyEditorObserversOfBefore,
|
|
eNotifyEditorObserversOfCancel
|
|
};
|
|
MOZ_CAN_RUN_SCRIPT void NotifyEditorObservers(
|
|
NotificationForEditorObservers aNotification);
|
|
|
|
/**
|
|
* InsertLineBreakAsSubAction() inserts a line break, i.e., \n if it's
|
|
* TextEditor or <br> if it's HTMLEditor.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertLineBreakAsSubAction();
|
|
|
|
/**
|
|
* HowToHandleCollapsedRange indicates how collapsed range should be treated.
|
|
*/
|
|
enum class HowToHandleCollapsedRange {
|
|
// Ignore collapsed range.
|
|
Ignore,
|
|
// Extend collapsed range for removing previous content.
|
|
ExtendBackward,
|
|
// Extend collapsed range for removing next content.
|
|
ExtendForward,
|
|
};
|
|
|
|
static HowToHandleCollapsedRange HowToHandleCollapsedRangeFor(
|
|
nsIEditor::EDirection aDirectionAndAmount) {
|
|
switch (aDirectionAndAmount) {
|
|
case nsIEditor::eNone:
|
|
return HowToHandleCollapsedRange::Ignore;
|
|
case nsIEditor::ePrevious:
|
|
return HowToHandleCollapsedRange::ExtendBackward;
|
|
case nsIEditor::eNext:
|
|
return HowToHandleCollapsedRange::ExtendForward;
|
|
case nsIEditor::ePreviousWord:
|
|
case nsIEditor::eNextWord:
|
|
case nsIEditor::eToBeginningOfLine:
|
|
case nsIEditor::eToEndOfLine:
|
|
// If the amount is word or
|
|
// line,`AutoRangeArray::ExtendAnchorFocusRangeFor()` must have already
|
|
// been extended collapsed ranges before.
|
|
return HowToHandleCollapsedRange::Ignore;
|
|
}
|
|
MOZ_ASSERT_UNREACHABLE("Invalid nsIEditor::EDirection value");
|
|
return HowToHandleCollapsedRange::Ignore;
|
|
}
|
|
|
|
/**
|
|
* DeleteSelectionWithTransaction() removes selected content or content
|
|
* around caret with transactions and remove empty inclusive ancestor
|
|
* inline elements of collapsed selection after removing the contents.
|
|
*
|
|
* @param aDirectionAndAmount How much range should be removed.
|
|
* @param aStripWrappers Whether the parent blocks should be removed
|
|
* when they become empty.
|
|
* Note that this must be `nsIEditor::eNoStrip`
|
|
* if this is a TextEditor because anyway it'll
|
|
* be ignored.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
DeleteSelectionWithTransaction(nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers);
|
|
|
|
/**
|
|
* DeleteRangesWithTransaction() removes content in aRangesToDelete or content
|
|
* around collapsed ranges in aRangesToDelete with transactions and remove
|
|
* empty inclusive ancestor inline elements of collapsed ranges after
|
|
* removing the contents.
|
|
*
|
|
* @param aDirectionAndAmount How much range should be removed.
|
|
* @param aStripWrappers Whether the parent blocks should be removed
|
|
* when they become empty.
|
|
* Note that this must be `nsIEditor::eNoStrip`
|
|
* if this is a TextEditor because anyway it'll
|
|
* be ignored.
|
|
* @param aRangesToDelete The ranges to delete content.
|
|
*/
|
|
[[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
|
|
DeleteRangesWithTransaction(nsIEditor::EDirection aDirectionAndAmount,
|
|
nsIEditor::EStripWrappers aStripWrappers,
|
|
const AutoRangeArray& aRangesToDelete);
|
|
|
|
/**
|
|
* Create an aggregate transaction for delete the content in aRangesToDelete.
|
|
* The result may include DeleteNodeTransactions and/or DeleteTextTransactions
|
|
* as its children.
|
|
*
|
|
* @param aHowToHandleCollapsedRange
|
|
* How to handle collapsed ranges.
|
|
* @param aRangesToDelete The ranges to delete content.
|
|
* @return If it can remove the content in ranges, returns
|
|
* an aggregate transaction which has some
|
|
* DeleteNodeTransactions and/or
|
|
* DeleteTextTransactions as its children.
|
|
*/
|
|
already_AddRefed<EditAggregateTransaction>
|
|
CreateTransactionForDeleteSelection(
|
|
HowToHandleCollapsedRange aHowToHandleCollapsedRange,
|
|
const AutoRangeArray& aRangesToDelete);
|
|
|
|
/**
|
|
* Create a transaction for removing the nodes and/or text around
|
|
* aRangeToDelete.
|
|
*
|
|
* @param aCollapsedRange The range to be removed. This must be
|
|
* collapsed.
|
|
* @param aHowToHandleCollapsedRange
|
|
* How to handle aCollapsedRange. Must
|
|
* be HowToHandleCollapsedRange::ExtendBackward or
|
|
* HowToHandleCollapsedRange::ExtendForward.
|
|
* @return The transaction to remove content around the
|
|
* range. Its type is DeleteNodeTransaction or
|
|
* DeleteTextTransaction.
|
|
*/
|
|
already_AddRefed<EditTransactionBase> CreateTransactionForCollapsedRange(
|
|
const nsRange& aCollapsedRange,
|
|
HowToHandleCollapsedRange aHowToHandleCollapsedRange);
|
|
|
|
/**
|
|
* ComputeInsertedRange() returns actual range modified by inserting string
|
|
* in a text node. If mutation event listener changed the text data, this
|
|
* returns a range which covers all over the text data.
|
|
*/
|
|
Tuple<EditorDOMPointInText, EditorDOMPointInText> ComputeInsertedRange(
|
|
const EditorDOMPointInText& aInsertedPoint,
|
|
const nsAString& aInsertedString) const;
|
|
|
|
private:
|
|
nsCOMPtr<nsISelectionController> mSelectionController;
|
|
RefPtr<Document> mDocument;
|
|
|
|
AutoEditActionDataSetter* mEditActionData;
|
|
|
|
/**
|
|
* SetTextDirectionTo() sets text-direction of the root element.
|
|
* Should use SwitchTextDirectionTo() or ToggleTextDirection() instead.
|
|
* This is a helper class of them.
|
|
*/
|
|
nsresult SetTextDirectionTo(TextDirection aTextDirection);
|
|
|
|
protected: // helper classes which may be used by friends
|
|
/**
|
|
* 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
|
|
* AutoPlaceholderBatch instead.
|
|
*/
|
|
class MOZ_RAII AutoTransactionBatch final {
|
|
public:
|
|
MOZ_CAN_RUN_SCRIPT explicit AutoTransactionBatch(EditorBase& aEditorBase)
|
|
: mEditorBase(aEditorBase) {
|
|
MOZ_KnownLive(mEditorBase).BeginTransactionInternal();
|
|
}
|
|
|
|
MOZ_CAN_RUN_SCRIPT ~AutoTransactionBatch() {
|
|
MOZ_KnownLive(mEditorBase).EndTransactionInternal();
|
|
}
|
|
|
|
protected:
|
|
EditorBase& mEditorBase;
|
|
};
|
|
|
|
/**
|
|
* Stack based helper class for batching a collection of transactions inside
|
|
* a placeholder transaction. Different from AutoTransactionBatch, this
|
|
* notifies editor observers of before/end edit action handling, and
|
|
* dispatches "input" event if it's necessary.
|
|
*/
|
|
class MOZ_RAII AutoPlaceholderBatch final {
|
|
public:
|
|
AutoPlaceholderBatch(EditorBase& aEditorBase,
|
|
ScrollSelectionIntoView aScrollSelectionIntoView)
|
|
: mEditorBase(aEditorBase),
|
|
mScrollSelectionIntoView(aScrollSelectionIntoView) {
|
|
mEditorBase->BeginPlaceholderTransaction(*nsGkAtoms::_empty);
|
|
}
|
|
|
|
AutoPlaceholderBatch(EditorBase& aEditorBase,
|
|
nsStaticAtom& aTransactionName,
|
|
ScrollSelectionIntoView aScrollSelectionIntoView)
|
|
: mEditorBase(aEditorBase),
|
|
mScrollSelectionIntoView(aScrollSelectionIntoView) {
|
|
mEditorBase->BeginPlaceholderTransaction(aTransactionName);
|
|
}
|
|
|
|
~AutoPlaceholderBatch() {
|
|
mEditorBase->EndPlaceholderTransaction(mScrollSelectionIntoView);
|
|
}
|
|
|
|
protected:
|
|
OwningNonNull<EditorBase> mEditorBase;
|
|
ScrollSelectionIntoView mScrollSelectionIntoView;
|
|
};
|
|
|
|
/**
|
|
* Stack based helper class for saving/restoring selection. Note that this
|
|
* assumes that the nodes involved are still around afterwords!
|
|
*/
|
|
class MOZ_RAII AutoSelectionRestorer final {
|
|
public:
|
|
/**
|
|
* Constructor responsible for remembering all state needed to restore
|
|
* aSelection.
|
|
*/
|
|
explicit AutoSelectionRestorer(EditorBase& aEditorBase);
|
|
|
|
/**
|
|
* Destructor restores mSelection to its former state
|
|
*/
|
|
~AutoSelectionRestorer();
|
|
|
|
/**
|
|
* Abort() cancels to restore the selection.
|
|
*/
|
|
void Abort();
|
|
|
|
protected:
|
|
EditorBase* mEditorBase;
|
|
};
|
|
|
|
/**
|
|
* AutoEditSubActionNotifier notifies editor of start to handle
|
|
* top level edit sub-action and end handling top level edit sub-action.
|
|
*/
|
|
class MOZ_RAII AutoEditSubActionNotifier final {
|
|
public:
|
|
MOZ_CAN_RUN_SCRIPT AutoEditSubActionNotifier(
|
|
EditorBase& aEditorBase, EditSubAction aEditSubAction,
|
|
nsIEditor::EDirection aDirection, ErrorResult& aRv)
|
|
: mEditorBase(aEditorBase), mIsTopLevel(true) {
|
|
// The top level edit sub action has already be set if this is nested call
|
|
// XXX Looks like that this is not aware of unexpected nested edit action
|
|
// handling via selectionchange event listener or mutation event
|
|
// listener.
|
|
if (!mEditorBase.GetTopLevelEditSubAction()) {
|
|
MOZ_KnownLive(mEditorBase)
|
|
.OnStartToHandleTopLevelEditSubAction(aEditSubAction, aDirection,
|
|
aRv);
|
|
} else {
|
|
mIsTopLevel = false;
|
|
}
|
|
mEditorBase.OnStartToHandleEditSubAction();
|
|
}
|
|
|
|
MOZ_CAN_RUN_SCRIPT ~AutoEditSubActionNotifier() {
|
|
mEditorBase.OnEndHandlingEditSubAction();
|
|
if (mIsTopLevel) {
|
|
MOZ_KnownLive(mEditorBase).OnEndHandlingTopLevelEditSubAction();
|
|
}
|
|
}
|
|
|
|
protected:
|
|
EditorBase& mEditorBase;
|
|
bool mIsTopLevel;
|
|
};
|
|
|
|
/**
|
|
* Stack based helper class for turning off active selection adjustment
|
|
* by low level transactions
|
|
*/
|
|
class MOZ_RAII AutoTransactionsConserveSelection final {
|
|
public:
|
|
explicit AutoTransactionsConserveSelection(EditorBase& aEditorBase)
|
|
: mEditorBase(aEditorBase),
|
|
mAllowedTransactionsToChangeSelection(
|
|
aEditorBase.AllowsTransactionsToChangeSelection()) {
|
|
mEditorBase.MakeThisAllowTransactionsToChangeSelection(false);
|
|
}
|
|
|
|
~AutoTransactionsConserveSelection() {
|
|
mEditorBase.MakeThisAllowTransactionsToChangeSelection(
|
|
mAllowedTransactionsToChangeSelection);
|
|
}
|
|
|
|
protected:
|
|
EditorBase& mEditorBase;
|
|
bool mAllowedTransactionsToChangeSelection;
|
|
};
|
|
|
|
/***************************************************************************
|
|
* stack based helper class for batching reflow and paint requests.
|
|
*/
|
|
class MOZ_RAII AutoUpdateViewBatch final {
|
|
public:
|
|
MOZ_CAN_RUN_SCRIPT explicit AutoUpdateViewBatch(EditorBase& aEditorBase)
|
|
: mEditorBase(aEditorBase) {
|
|
mEditorBase.BeginUpdateViewBatch();
|
|
}
|
|
|
|
MOZ_CAN_RUN_SCRIPT ~AutoUpdateViewBatch() {
|
|
MOZ_KnownLive(mEditorBase).EndUpdateViewBatch();
|
|
}
|
|
|
|
protected:
|
|
EditorBase& mEditorBase;
|
|
};
|
|
|
|
protected:
|
|
enum Tristate { eTriUnset, eTriFalse, eTriTrue };
|
|
|
|
// MIME type of the doc we are editing.
|
|
nsString mContentMIMEType;
|
|
|
|
RefPtr<mozInlineSpellChecker> mInlineSpellChecker;
|
|
// Reference to text services document for mInlineSpellChecker.
|
|
RefPtr<TextServicesDocument> mTextServicesDocument;
|
|
|
|
RefPtr<TransactionManager> mTransactionManager;
|
|
// Cached root node.
|
|
RefPtr<Element> mRootElement;
|
|
|
|
// mPaddingBRElementForEmptyEditor should be used for placing caret
|
|
// at proper position when editor is empty.
|
|
RefPtr<dom::HTMLBRElement> mPaddingBRElementForEmptyEditor;
|
|
|
|
// The form field as an event receiver.
|
|
nsCOMPtr<dom::EventTarget> mEventTarget;
|
|
RefPtr<EditorEventListener> mEventListener;
|
|
// Strong reference to placeholder for begin/end batch purposes.
|
|
RefPtr<PlaceholderTransaction> mPlaceholderTransaction;
|
|
// Name of placeholder transaction.
|
|
nsStaticAtom* mPlaceholderName;
|
|
// Saved selection state for placeholder transaction batching.
|
|
mozilla::Maybe<SelectionState> mSelState;
|
|
// IME composition this is not null between compositionstart and
|
|
// compositionend.
|
|
RefPtr<TextComposition> mComposition;
|
|
|
|
RefPtr<TextInputListener> mTextInputListener;
|
|
|
|
RefPtr<IMEContentObserver> mIMEContentObserver;
|
|
|
|
// Listens to all low level actions on the doc.
|
|
// Edit action listener is currently used by highlighter of the findbar and
|
|
// the spellchecker. So, we should reserve only 2 items.
|
|
typedef AutoTArray<OwningNonNull<nsIEditActionListener>, 2>
|
|
AutoActionListenerArray;
|
|
AutoActionListenerArray mActionListeners;
|
|
// Just notify once per high level change.
|
|
// Editor observer is used only by legacy addons for Thunderbird and
|
|
// BlueGriffon. So, we don't need to reserve the space for them.
|
|
typedef AutoTArray<OwningNonNull<nsIEditorObserver>, 0>
|
|
AutoEditorObserverArray;
|
|
AutoEditorObserverArray mEditorObservers;
|
|
// Listen to overall doc state (dirty or not, just created, etc.).
|
|
// Document state listener is currently used by FinderHighlighter and
|
|
// BlueGriffon so that reserving only one is enough.
|
|
typedef AutoTArray<OwningNonNull<nsIDocumentStateListener>, 1>
|
|
AutoDocumentStateListenerArray;
|
|
AutoDocumentStateListenerArray mDocStateListeners;
|
|
|
|
// Number of modifications (for undo/redo stack).
|
|
uint32_t mModCount;
|
|
// Behavior flags. See nsIEditor.idl for the flags we use.
|
|
uint32_t mFlags;
|
|
|
|
int32_t mUpdateCount;
|
|
|
|
// Nesting count for batching.
|
|
int32_t mPlaceholderBatch;
|
|
|
|
int32_t mWrapColumn;
|
|
int32_t mNewlineHandling;
|
|
int32_t mCaretStyle;
|
|
|
|
// -1 = not initialized
|
|
int8_t mDocDirtyState;
|
|
// A Tristate value.
|
|
uint8_t mSpellcheckCheckboxState;
|
|
|
|
// If true, initialization was succeeded.
|
|
bool mInitSucceeded;
|
|
// If false, transactions should not change Selection even after modifying
|
|
// the DOM tree.
|
|
bool mAllowsTransactionsToChangeSelection;
|
|
// Whether PreDestroy has been called.
|
|
bool mDidPreDestroy;
|
|
// Whether PostCreate has been called.
|
|
bool mDidPostCreate;
|
|
bool mDispatchInputEvent;
|
|
// True while the instance is handling an edit sub-action.
|
|
bool mIsInEditSubAction;
|
|
// Whether caret is hidden forcibly.
|
|
bool mHidingCaret;
|
|
// Whether spellchecker dictionary is initialized after focused.
|
|
bool mSpellCheckerDictionaryUpdated;
|
|
// Whether we are an HTML editor class.
|
|
bool mIsHTMLEditorClass;
|
|
|
|
friend class AlignStateAtSelection;
|
|
friend class AutoRangeArray;
|
|
friend class CompositionTransaction;
|
|
friend class CreateElementTransaction;
|
|
friend class CSSEditUtils;
|
|
friend class DeleteNodeTransaction;
|
|
friend class DeleteRangeTransaction;
|
|
friend class DeleteTextTransaction;
|
|
friend class HTMLEditUtils;
|
|
friend class InsertNodeTransaction;
|
|
friend class InsertTextTransaction;
|
|
friend class JoinNodeTransaction;
|
|
friend class ListElementSelectionState;
|
|
friend class ListItemElementSelectionState;
|
|
friend class ParagraphStateAtSelection;
|
|
friend class ReplaceTextTransaction;
|
|
friend class SplitNodeTransaction;
|
|
friend class TypeInState;
|
|
friend class WhiteSpaceVisibilityKeeper;
|
|
friend class WSRunScanner;
|
|
friend class nsIEditor;
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
mozilla::EditorBase* nsIEditor::AsEditorBase() {
|
|
return static_cast<mozilla::EditorBase*>(this);
|
|
}
|
|
|
|
const mozilla::EditorBase* nsIEditor::AsEditorBase() const {
|
|
return static_cast<const mozilla::EditorBase*>(this);
|
|
}
|
|
|
|
#endif // #ifndef mozilla_EditorBase_h
|