summaryrefslogtreecommitdiffstats
path: root/editor/libeditor/TextEditor.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /editor/libeditor/TextEditor.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'editor/libeditor/TextEditor.h')
-rw-r--r--editor/libeditor/TextEditor.h614
1 files changed, 614 insertions, 0 deletions
diff --git a/editor/libeditor/TextEditor.h b/editor/libeditor/TextEditor.h
new file mode 100644
index 0000000000..77df2dabba
--- /dev/null
+++ b/editor/libeditor/TextEditor.h
@@ -0,0 +1,614 @@
+/* -*- 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_TextEditor_h
+#define mozilla_TextEditor_h
+
+#include "mozilla/EditorBase.h"
+#include "mozilla/EditorForwards.h"
+#include "mozilla/TextControlState.h"
+#include "mozilla/UniquePtr.h"
+
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsINamed.h"
+#include "nsISupportsImpl.h"
+#include "nsITimer.h"
+#include "nscore.h"
+
+class nsIContent;
+class nsIDocumentEncoder;
+class nsIOutputStream;
+class nsIPrincipal;
+class nsISelectionController;
+class nsITransferable;
+
+namespace mozilla {
+namespace dom {
+class Selection;
+} // namespace dom
+
+/**
+ * The text editor implementation.
+ * Use to edit text document represented as a DOM tree.
+ */
+class TextEditor final : public EditorBase,
+ public nsITimerCallback,
+ public nsINamed {
+ public:
+ /****************************************************************************
+ * NOTE: DO NOT MAKE YOUR NEW METHODS PUBLIC IF they are called by other
+ * classes under libeditor except EditorEventListener and
+ * HTMLEditorEventListener because each public method which may fire
+ * eEditorInput event will need to instantiate new stack class for
+ * managing input type value of eEditorInput and cache some objects
+ * for smarter handling. In other words, when you add new root
+ * method to edit the DOM tree, you can make your new method public.
+ ****************************************************************************/
+
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TextEditor, EditorBase)
+
+ TextEditor();
+
+ /**
+ * Note that TextEditor::Init() shouldn't cause running script synchronously.
+ * So, `MOZ_CAN_RUN_SCRIPT_BOUNDARY` is safe here.
+ *
+ * @param aDocument The document which aAnonymousDivElement belongs to.
+ * @param aAnonymousDivElement
+ * The root editable element for this editor.
+ * @param aSelectionController
+ * The selection controller for independent selections
+ * in the `<input>` or `<textarea>` element.
+ * @param aFlags Some of nsIEditor::eEditor*Mask flags.
+ * @param aPasswordMaskData
+ * Set to an instance only when aFlags includes
+ * `nsIEditor::eEditorPasswordMask`. Otherwise, must be
+ * `nullptr`.
+ */
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult
+ Init(Document& aDocument, Element& aAnonymousDivElement,
+ nsISelectionController& aSelectionController, uint32_t aFlags,
+ UniquePtr<PasswordMaskData>&& aPasswordMaskData);
+
+ /**
+ * PostCreate() should be called after Init, and is the time that the editor
+ * tells its documentStateObservers that the document has been created.
+ * Note that TextEditor::PostCreate() shouldn't cause running script
+ * synchronously. So, `MOZ_CAN_RUN_SCRIPT_BOUNDARY` is safe here.
+ */
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult PostCreate();
+
+ /**
+ * 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);
+
+ /**
+ * PreDestroy() is called before the editor goes away, and gives the editor a
+ * chance to tell its documentStateObservers that the document is going away.
+ * Note that TextEditor::PreDestroy() shouldn't cause running script
+ * synchronously. So, `MOZ_CAN_RUN_SCRIPT_BOUNDARY` is safe here.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT_BOUNDARY UniquePtr<PasswordMaskData>
+ PreDestroy();
+
+ static TextEditor* GetFrom(nsIEditor* aEditor) {
+ return aEditor ? aEditor->GetAsTextEditor() : nullptr;
+ }
+ static const TextEditor* GetFrom(const nsIEditor* aEditor) {
+ return aEditor ? aEditor->GetAsTextEditor() : nullptr;
+ }
+
+ /**
+ * Helper method for `AppendString()` and `AppendSubString()`. This should
+ * be called only when `aText` is in a password field. This method masks
+ * A part of or all of `aText` (`aStartOffsetInText` and later) should've
+ * been copied (appended) to `aString`. `aStartOffsetInString` is where
+ * the password was appended into `aString`.
+ */
+ static void MaskString(nsString& aString, const dom::Text& aTextNode,
+ uint32_t aStartOffsetInString,
+ uint32_t aStartOffsetInText);
+
+ NS_DECL_NSITIMERCALLBACK
+ NS_DECL_NSINAMED
+
+ // Overrides of nsIEditor
+ MOZ_CAN_RUN_SCRIPT NS_IMETHOD EndOfDocument() final;
+ MOZ_CAN_RUN_SCRIPT NS_IMETHOD InsertLineBreak() final;
+ NS_IMETHOD GetTextLength(uint32_t* aCount) final;
+
+ // Shouldn't be used internally, but we need these using declarations for
+ // avoiding warnings of clang.
+ using EditorBase::CanCopy;
+ using EditorBase::CanCut;
+ using EditorBase::CanPaste;
+
+ // Overrides of EditorBase
+ bool IsEmpty() const final;
+
+ bool CanPaste(int32_t aClipboardType) const final;
+
+ bool CanPasteTransferable(nsITransferable* aTransferable) final;
+
+ MOZ_CAN_RUN_SCRIPT nsresult
+ HandleKeyPressEvent(WidgetKeyboardEvent* aKeyboardEvent) final;
+
+ dom::EventTarget* GetDOMEventTarget() const final;
+
+ MOZ_CAN_RUN_SCRIPT nsresult
+ OnFocus(const nsINode& aOriginalEventTargetNode) final;
+
+ nsresult OnBlur(const dom::EventTarget* aEventTarget) final;
+
+ /**
+ * The maximum number of characters allowed.
+ * default: -1 (unlimited).
+ */
+ int32_t MaxTextLength() const { return mMaxTextLength; }
+ void SetMaxTextLength(int32_t aLength) { mMaxTextLength = aLength; }
+
+ /**
+ * Replace existed string with a string.
+ * This is fast path to replace all string when using single line control.
+ *
+ * @param aString The string to be set
+ * @param aAllowBeforeInputEventCancelable
+ * Whether `beforeinput` event which will be
+ * dispatched for this can be cancelable or not.
+ * @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 SetTextAsAction(
+ const nsAString& aString,
+ AllowBeforeInputEventCancelable aAllowBeforeInputEventCancelable,
+ nsIPrincipal* aPrincipal = nullptr);
+
+ MOZ_CAN_RUN_SCRIPT nsresult
+ InsertLineBreakAsAction(nsIPrincipal* aPrincipal = nullptr) final;
+
+ /**
+ * ComputeTextValue() computes plaintext value of this editor. This may be
+ * too expensive if it's in hot path.
+ *
+ * @param aDocumentEncoderFlags Flags of nsIDocumentEncoder.
+ * @param aCharset Encoding of the document.
+ */
+ nsresult ComputeTextValue(uint32_t aDocumentEncoderFlags,
+ nsAString& aOutputString) const {
+ AutoEditActionDataSetter editActionData(*this, EditAction::eNotEditing);
+ if (NS_WARN_IF(!editActionData.CanHandle())) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+ nsresult rv = ComputeValueInternal(u"text/plain"_ns, aDocumentEncoderFlags,
+ aOutputString);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return EditorBase::ToGenericNSResult(rv);
+ }
+ return NS_OK;
+ }
+
+ /**
+ * The following methods are available only when the instance is a password
+ * editor. They return whether there is unmasked range or not and range
+ * start and length.
+ */
+ MOZ_ALWAYS_INLINE bool IsAllMasked() const {
+ MOZ_ASSERT(IsPasswordEditor());
+ return !mPasswordMaskData || mPasswordMaskData->IsAllMasked();
+ }
+ MOZ_ALWAYS_INLINE uint32_t UnmaskedStart() const {
+ MOZ_ASSERT(IsPasswordEditor());
+ return mPasswordMaskData ? mPasswordMaskData->mUnmaskedStart : UINT32_MAX;
+ }
+ MOZ_ALWAYS_INLINE uint32_t UnmaskedLength() const {
+ MOZ_ASSERT(IsPasswordEditor());
+ return mPasswordMaskData ? mPasswordMaskData->mUnmaskedLength : 0;
+ }
+ MOZ_ALWAYS_INLINE uint32_t UnmaskedEnd() const {
+ MOZ_ASSERT(IsPasswordEditor());
+ return mPasswordMaskData ? mPasswordMaskData->UnmaskedEnd() : UINT32_MAX;
+ }
+
+ /**
+ * IsMaskingPassword() returns false when the last caller of `Unmask()`
+ * didn't want to mask again automatically. When this returns true, user
+ * input causes masking the password even before timed-out.
+ */
+ bool IsMaskingPassword() const {
+ MOZ_ASSERT(IsPasswordEditor());
+ return mPasswordMaskData && mPasswordMaskData->mIsMaskingPassword;
+ }
+
+ /**
+ * PasswordMask() returns a character which masks each character in password
+ * fields.
+ */
+ static char16_t PasswordMask();
+
+ /**
+ * If you want to prevent to echo password temporarily, use the following
+ * methods.
+ */
+ bool EchoingPasswordPrevented() const {
+ return mPasswordMaskData && mPasswordMaskData->mEchoingPasswordPrevented;
+ }
+ void PreventToEchoPassword() {
+ if (mPasswordMaskData) {
+ mPasswordMaskData->mEchoingPasswordPrevented = true;
+ }
+ }
+ void AllowToEchoPassword() {
+ if (mPasswordMaskData) {
+ mPasswordMaskData->mEchoingPasswordPrevented = false;
+ }
+ }
+
+ dom::Text* GetTextNode() {
+ MOZ_DIAGNOSTIC_ASSERT(GetRoot());
+ MOZ_DIAGNOSTIC_ASSERT(GetRoot()->GetFirstChild());
+ MOZ_DIAGNOSTIC_ASSERT(GetRoot()->GetFirstChild()->IsText());
+ if (MOZ_UNLIKELY(!GetRoot() || !GetRoot()->GetFirstChild())) {
+ return nullptr;
+ }
+ return GetRoot()->GetFirstChild()->GetAsText();
+ }
+ const dom::Text* GetTextNode() const {
+ return const_cast<TextEditor*>(this)->GetTextNode();
+ }
+
+ 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.
+ ****************************************************************************/
+
+ // Overrides of EditorBase
+ MOZ_CAN_RUN_SCRIPT nsresult RemoveAttributeOrEquivalent(
+ Element* aElement, nsAtom* aAttribute, bool aSuppressTransaction) final;
+ MOZ_CAN_RUN_SCRIPT nsresult SetAttributeOrEquivalent(
+ Element* aElement, nsAtom* aAttribute, const nsAString& aValue,
+ bool aSuppressTransaction) final;
+ using EditorBase::RemoveAttributeOrEquivalent;
+ using EditorBase::SetAttributeOrEquivalent;
+
+ /**
+ * InsertLineBreakAsSubAction() inserts a line break.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertLineBreakAsSubAction();
+
+ /**
+ * Replace existed string with aString. Caller must guarantee that there
+ * is a placeholder transaction which will have the transaction.
+ *
+ * @ param aString The string to be set.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
+ SetTextAsSubAction(const nsAString& aString);
+
+ /**
+ * MaybeDoAutoPasswordMasking() may mask password if we're doing auto-masking.
+ */
+ void MaybeDoAutoPasswordMasking() {
+ if (IsPasswordEditor() && IsMaskingPassword()) {
+ MaskAllCharacters();
+ }
+ }
+
+ /**
+ * SetUnmaskRange() is available only when the instance is a password
+ * editor. This just updates unmask range. I.e., caller needs to
+ * guarantee to update the layout.
+ *
+ * @param aStart First index to show the character.
+ * If aLength is 0, this value is ignored.
+ * @param aLength Optional, Length to show characters.
+ * If UINT32_MAX, it means unmasking all characters after
+ * aStart.
+ * If 0, it means that masking all characters.
+ * @param aTimeout Optional, specify milliseconds to hide the unmasked
+ * characters after this call.
+ * If 0, it means this won't mask the characters
+ * automatically.
+ * If aLength is 0, this value is ignored.
+ */
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult SetUnmaskRange(
+ uint32_t aStart, uint32_t aLength = UINT32_MAX, uint32_t aTimeout = 0) {
+ return SetUnmaskRangeInternal(aStart, aLength, aTimeout, false, false);
+ }
+
+ /**
+ * SetUnmaskRangeAndNotify() is available only when the instance is a
+ * password editor. This updates unmask range and notifying the text frame
+ * to update the visible characters.
+ *
+ * @param aStart First index to show the character.
+ * If UINT32_MAX, it means masking all.
+ * @param aLength Optional, Length to show characters.
+ * If UINT32_MAX, it means unmasking all characters after
+ * aStart.
+ * @param aTimeout Optional, specify milliseconds to hide the unmasked
+ * characters after this call.
+ * If 0, it means this won't mask the characters
+ * automatically.
+ * If aLength is 0, this value is ignored.
+ */
+ MOZ_CAN_RUN_SCRIPT nsresult SetUnmaskRangeAndNotify(
+ uint32_t aStart, uint32_t aLength = UINT32_MAX, uint32_t aTimeout = 0) {
+ return SetUnmaskRangeInternal(aStart, aLength, aTimeout, true, false);
+ }
+
+ /**
+ * MaskAllCharacters() is an alias of SetUnmaskRange() to mask all characters.
+ * In other words, this removes existing unmask range.
+ * After this is called, TextEditor starts masking password automatically.
+ */
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult MaskAllCharacters() {
+ if (!mPasswordMaskData) {
+ return NS_OK; // Already we don't have masked range data.
+ }
+ return SetUnmaskRangeInternal(UINT32_MAX, 0, 0, false, true);
+ }
+
+ /**
+ * MaskAllCharactersAndNotify() is an alias of SetUnmaskRangeAndNotify() to
+ * mask all characters and notifies the text frame. In other words, this
+ * removes existing unmask range.
+ * After this is called, TextEditor starts masking password automatically.
+ */
+ MOZ_CAN_RUN_SCRIPT nsresult MaskAllCharactersAndNotify() {
+ return SetUnmaskRangeInternal(UINT32_MAX, 0, 0, true, true);
+ }
+
+ /**
+ * WillDeleteText() is called before `DeleteTextTransaction` or something
+ * removes text in a text node. Note that this won't be called if the
+ * instance is `HTMLEditor` since supporting it makes the code complicated
+ * due to mutation events.
+ *
+ * @param aCurrentLength Current text length of the node.
+ * @param aRemoveStartOffset Start offset of the range to be removed.
+ * @param aRemoveLength Length of the range to be removed.
+ */
+ void WillDeleteText(uint32_t aCurrentLength, uint32_t aRemoveStartOffset,
+ uint32_t aRemoveLength);
+
+ /**
+ * DidInsertText() is called after `InsertTextTransaction` or something
+ * inserts text into a text node. Note that this won't be called if the
+ * instance is `HTMLEditor` since supporting it makes the code complicated
+ * due to mutatione events.
+ *
+ * @param aNewLength New text length after the insertion.
+ * @param aInsertedOffset Start offset of the inserted text.
+ * @param aInsertedLength Length of the inserted text.
+ * @return NS_OK or NS_ERROR_EDITOR_DESTROYED.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult DidInsertText(
+ uint32_t aNewLength, uint32_t aInsertedOffset, uint32_t aInsertedLength);
+
+ protected: // edit sub-action handler
+ /**
+ * MaybeTruncateInsertionStringForMaxLength() truncates aInsertionString to
+ * `maxlength` if it was not pasted in by the user.
+ *
+ * @param aInsertionString [in/out] New insertion string. This is
+ * truncated to `maxlength` if it was not pasted in
+ * by the user.
+ * @return If aInsertionString is truncated, it returns "as
+ * handled", else "as ignored."
+ */
+ Result<EditActionResult, nsresult> MaybeTruncateInsertionStringForMaxLength(
+ nsAString& aInsertionString);
+
+ /**
+ * InsertLineFeedCharacterAtSelection() inserts a linefeed character at
+ * selection.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
+ InsertLineFeedCharacterAtSelection();
+
+ /**
+ * Handles the newline characters according to the default system prefs
+ * (editor.singleLine.pasteNewlines).
+ * Each value means:
+ * nsIEditor::eNewlinesReplaceWithSpaces (2, Firefox default):
+ * replace newlines with spaces.
+ * nsIEditor::eNewlinesStrip (3):
+ * remove newlines from the string.
+ * nsIEditor::eNewlinesReplaceWithCommas (4, Thunderbird default):
+ * replace newlines with commas.
+ * nsIEditor::eNewlinesStripSurroundingWhitespace (5):
+ * collapse newlines and surrounding white-space characters and
+ * remove them from the string.
+ * nsIEditor::eNewlinesPasteIntact (0):
+ * only remove the leading and trailing newlines.
+ * nsIEditor::eNewlinesPasteToFirst (1) or any other value:
+ * remove the first newline and all characters following it.
+ *
+ * @param aString the string to be modified in place.
+ */
+ void HandleNewLinesInStringForSingleLineEditor(nsString& aString) const;
+
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
+ HandleInsertText(EditSubAction aEditSubAction,
+ const nsAString& aInsertionString,
+ SelectionHandling aSelectionHandling) final;
+
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InsertDroppedDataTransferAsAction(
+ AutoEditActionDataSetter& aEditActionData,
+ dom::DataTransfer& aDataTransfer, const EditorDOMPoint& aDroppedAt,
+ nsIPrincipal* aSourcePrincipal) final;
+
+ /**
+ * HandleDeleteSelectionInternal() is a helper method of
+ * HandleDeleteSelection(). Must be called only when the instance is
+ * TextEditor.
+ * NOTE: This method creates SelectionBatcher. Therefore, each caller
+ * needs to check if the editor is still available even if this returns
+ * NS_OK.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
+ HandleDeleteSelectionInternal(nsIEditor::EDirection aDirectionAndAmount,
+ nsIEditor::EStripWrappers aStripWrappers);
+
+ /**
+ * This method handles "delete selection" commands.
+ *
+ * @param aDirectionAndAmount Direction of the deletion.
+ * @param aStripWrappers Must be nsIEditor::eNoStrip.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
+ HandleDeleteSelection(nsIEditor::EDirection aDirectionAndAmount,
+ nsIEditor::EStripWrappers aStripWrappers) final;
+
+ /**
+ * ComputeValueFromTextNodeAndBRElement() tries to compute "value" of
+ * this editor content only with text nodes and `<br>` elements.
+ * If this succeeds to compute the value, it's returned with aValue and
+ * the result is marked as "handled". Otherwise, the caller needs to
+ * compute it with another way.
+ */
+ Result<EditActionResult, nsresult> ComputeValueFromTextNodeAndBRElement(
+ nsAString& aValue) const;
+
+ /**
+ * SetTextWithoutTransaction() is optimized method to set `<input>.value`
+ * and `<textarea>.value` to aValue without transaction. This must be
+ * called only when it's not `HTMLEditor` and undo/redo is disabled.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT Result<EditActionResult, nsresult>
+ SetTextWithoutTransaction(const nsAString& aValue);
+
+ /**
+ * EnsureCaretNotAtEndOfTextNode() collapses selection at the padding `<br>`
+ * element (i.e., container becomes the anonymous `<div>` element) if
+ * `Selection` is at end of the text node.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult EnsureCaretNotAtEndOfTextNode();
+
+ protected: // Called by helper classes.
+ MOZ_CAN_RUN_SCRIPT void OnStartToHandleTopLevelEditSubAction(
+ EditSubAction aTopLevelEditSubAction,
+ nsIEditor::EDirection aDirectionOfTopLevelEditSubAction,
+ ErrorResult& aRv) final;
+ MOZ_CAN_RUN_SCRIPT nsresult OnEndHandlingTopLevelEditSubAction() final;
+
+ /**
+ * HandleInlineSpellCheckAfterEdit() does spell-check after handling top level
+ * edit subaction.
+ */
+ nsresult HandleInlineSpellCheckAfterEdit() {
+ MOZ_ASSERT(IsEditActionDataAvailable());
+ if (!GetSpellCheckRestartPoint().IsSet()) {
+ return NS_OK; // Maybe being initialized.
+ }
+ nsresult rv = HandleInlineSpellCheck(GetSpellCheckRestartPoint());
+ NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "Failed to spellcheck");
+ ClearSpellCheckRestartPoint();
+ return rv;
+ }
+
+ protected: // Shouldn't be used by friend classes
+ virtual ~TextEditor();
+
+ /**
+ * CanEchoPasswordNow() returns true if currently we can echo password.
+ * If it's direct user input such as pasting or dropping text, this
+ * returns false even if we may echo password.
+ */
+ bool CanEchoPasswordNow() const;
+
+ /**
+ * InitEditorContentAndSelection() may insert a padding `<br>` element for
+ * if it's required in the anonymous `<div>` element or `<body>` element and
+ * collapse selection at the end if there is no selection ranges.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult InitEditorContentAndSelection();
+
+ /**
+ * Collapse `Selection` to end of the text node in the anonymous <div>
+ * element.
+ */
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult CollapseSelectionToEndOfTextNode();
+
+ /**
+ * Make the given selection span the entire document.
+ */
+ MOZ_CAN_RUN_SCRIPT nsresult SelectEntireDocument() final;
+
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePaste(
+ AutoEditActionDataSetter& aEditActionData, int32_t aClipboardType) final;
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandlePasteAsQuotation(
+ AutoEditActionDataSetter& aEditActionData, int32_t aClipboardType) final;
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
+ HandlePasteTransferable(AutoEditActionDataSetter& aEditActionData,
+ nsITransferable& aTransferable) final;
+
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
+ InsertWithQuotationsAsSubAction(const nsAString& aQuotedText) final;
+
+ [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
+ InsertTextFromTransferable(nsITransferable* transferable);
+
+ bool IsCopyToClipboardAllowedInternal() const final;
+
+ already_AddRefed<Element> GetInputEventTargetElement() const final;
+
+ /**
+ * See SetUnmaskRange() and SetUnmaskRangeAndNotify() for the detail.
+ *
+ * @param aForceStartMasking If true, forcibly starts masking. This should
+ * be used only when `nsIEditor::Mask()` is called.
+ */
+ MOZ_CAN_RUN_SCRIPT nsresult SetUnmaskRangeInternal(uint32_t aStart,
+ uint32_t aLength,
+ uint32_t aTimeout,
+ bool aNotify,
+ bool aForceStartMasking);
+
+ MOZ_ALWAYS_INLINE bool HasAutoMaskingTimer() const {
+ return mPasswordMaskData && mPasswordMaskData->mTimer;
+ }
+
+ protected:
+ UniquePtr<PasswordMaskData> mPasswordMaskData;
+
+ int32_t mMaxTextLength = -1;
+
+ friend class DeleteNodeTransaction;
+ friend class EditorBase;
+ friend class InsertNodeTransaction;
+};
+
+} // namespace mozilla
+
+mozilla::TextEditor* nsIEditor::AsTextEditor() {
+ MOZ_DIAGNOSTIC_ASSERT(IsTextEditor());
+ return static_cast<mozilla::TextEditor*>(this);
+}
+
+const mozilla::TextEditor* nsIEditor::AsTextEditor() const {
+ MOZ_DIAGNOSTIC_ASSERT(IsTextEditor());
+ return static_cast<const mozilla::TextEditor*>(this);
+}
+
+mozilla::TextEditor* nsIEditor::GetAsTextEditor() {
+ return AsEditorBase()->IsTextEditor() ? AsTextEditor() : nullptr;
+}
+
+const mozilla::TextEditor* nsIEditor::GetAsTextEditor() const {
+ return AsEditorBase()->IsTextEditor() ? AsTextEditor() : nullptr;
+}
+
+#endif // #ifndef mozilla_TextEditor_h