gecko-dev/dom/html/nsTextEditorState.h

453 строки
19 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 nsTextEditorState_h__
#define nsTextEditorState_h__
#include "nsString.h"
#include "nsITextControlElement.h"
#include "nsITextControlFrame.h"
#include "nsCycleCollectionParticipant.h"
#include "mozilla/dom/Element.h"
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "mozilla/TextEditor.h"
#include "mozilla/WeakPtr.h"
#include "mozilla/dom/HTMLInputElementBinding.h"
#include "mozilla/dom/Nullable.h"
class nsTextControlFrame;
class nsTextInputSelectionImpl;
class nsAnonDivObserver;
class nsISelectionController;
class nsFrameSelection;
class nsITextControlElement;
class nsFrame;
namespace mozilla {
class ErrorResult;
class TextInputListener;
namespace dom {
class HTMLInputElement;
} // namespace dom
} // namespace mozilla
/**
* nsTextEditorState is a class which is responsible for managing the state of
* plaintext controls. This currently includes the following HTML elements:
* <input type=text>
* <input type=search>
* <input type=url>
* <input type=telephone>
* <input type=email>
* <input type=password>
* <textarea>
* and also XUL controls such as <textbox> which use one of these elements
* behind the scenes.
*
* This class is held as a member of HTMLInputElement and nsHTMLTextAreaElement.
* The public functions in this class include the public APIs which content/
* uses. Layout code uses the nsITextControlElement interface to invoke
* functions on this class.
*
* The design motivation behind this class is maintaining all of the things
* which collectively are considered the "state" of the text control in a single
* location. This state includes several things:
*
* * The control's value. This value is stored in the mValue member, and is
* only used when there is no frame for the control, or when the editor object
* has not been initialized yet.
*
* * The control's associated frame. This value is stored in the mBoundFrame
* member. A text control might never have an associated frame during its life
* cycle, or might have several different ones, but at any given moment in time
* there is a maximum of 1 bound frame to each text control.
*
* * The control's associated editor. This value is stored in the mEditor
* member. An editor is initilized for the control only when necessary (that is,
* when either the user is about to interact with the text control, or when some
* other code needs to access the editor object. Without a frame bound to the
* control, an editor is never initialzied. Once initialized, the editor might
* outlive the frame, in which case the same editor will be used if a new frame
* gets bound to the text control.
*
* * The anonymous content associated with the text control's frame, including
* the value div (the DIV element responsible for holding the value of the text
* control) and the placeholder div (the DIV element responsible for holding the
* placeholder value of the text control.) These values are stored in the
* mRootNode and mPlaceholderDiv members, respectively. They will be created
* when a frame is bound to the text control. They will be destroyed when the
* frame is unbound from the object. We could try and hold on to the anonymous
* content between different frames, but unfortunately that is not currently
* possible because they are not unbound from the document in time.
*
* * The frame selection controller. This value is stored in the mSelCon
* member. The frame selection controller is responsible for maintaining the
* selection state on a frame. It is created when a frame is bound to the text
* control element, and will be destroy when the frame is being unbound from the
* text control element. It is created alongside with the frame selection object
* which is stored in the mFrameSel member.
*
* * The editor text listener. This value is stored in the mTextListener
* member. Its job is to listen to selection and keyboard events, and act
* accordingly. It is created when an a frame is first bound to the control, and
* will be destroyed when the frame is unbound from the text control element.
*
* * The editor's cached value. This value is stored in the mCachedValue
* member. It is used to improve the performance of append operations to the
* text control. A mutation observer stored in the mMutationObserver has the
* job of invalidating this cache when the anonymous contect containing the
* value is changed.
*
* * The editor's cached selection properties. These vales are stored in the
* mSelectionProperties member, and include the selection's start, end and
* direction. They are only used when there is no frame available for the
* text field.
*
*
* As a general rule, nsTextEditorState objects own the value of the text
* control, and any attempt to retrieve or set the value must be made through
* those objects. Internally, the value can be represented in several different
* ways, based on the state the control is in.
*
* * When the control is first initialized, its value is equal to the default
* value of the DOM node. For <input> text controls, this default value is the
* value of the value attribute. For <textarea> elements, this default value is
* the value of the text node children of the element.
*
* * If the value has been changed through the DOM node (before the editor for
* the object is initialized), the value is stored as a simple string inside the
* mValue member of the nsTextEditorState object.
*
* * If an editor has been initialized for the control, the value is set and
* retrievd via the nsIPlaintextEditor interface, and is internally managed by
* the editor as the native anonymous content tree attached to the control's
* frame.
*
* * If the text editor state object is unbound from the control's frame, the
* value is transferred to the mValue member variable, and will be managed there
* until a new frame is bound to the text editor state object.
*/
class RestoreSelectionState;
class nsTextEditorState : public mozilla::SupportsWeakPtr<nsTextEditorState> {
public:
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsTextEditorState)
explicit nsTextEditorState(nsITextControlElement* aOwningElement);
static nsTextEditorState* Construct(nsITextControlElement* aOwningElement,
nsTextEditorState** aReusedState);
MOZ_CAN_RUN_SCRIPT_BOUNDARY ~nsTextEditorState();
void Traverse(nsCycleCollectionTraversalCallback& cb);
MOZ_CAN_RUN_SCRIPT_BOUNDARY void Unlink();
void PrepareForReuse() {
Unlink();
mValue.reset();
mValueBeingSet.Truncate();
mTextCtrlElement = nullptr;
}
mozilla::TextEditor* GetTextEditor();
mozilla::TextEditor* GetTextEditorWithoutCreation();
nsISelectionController* GetSelectionController() const;
nsFrameSelection* GetConstFrameSelection();
nsresult BindToFrame(nsTextControlFrame* aFrame);
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void UnbindFromFrame(nsTextControlFrame* aFrame);
MOZ_CAN_RUN_SCRIPT_BOUNDARY
nsresult PrepareEditor(const nsAString* aValue = nullptr);
void InitializeKeyboardEventListeners();
enum SetValueFlags {
// The call is for internal processing.
eSetValue_Internal = 1 << 0,
// The value is changed by a call of setUserInput() from chrome.
eSetValue_BySetUserInput = 1 << 1,
// The value is changed by changing value attribute of the element or
// something like setRangeText().
eSetValue_ByContent = 1 << 2,
// Whether the value change should be notified to the frame/contet nor not.
eSetValue_Notify = 1 << 3,
// Whether to move the cursor to end of the value (in the case when we have
// cached selection offsets), in the case when the value has changed. If
// this is not set and
// eSetValue_MoveCursorToBeginSetSelectionDirectionForward
// is not set, the cached selection offsets will simply be clamped to
// be within the length of the new value. In either case, if the value has
// not changed the cursor won't move.
// TODO(mbrodesser): update comment and enumerator identifier to reflect
// that also the direction is set to forward.
eSetValue_MoveCursorToEndIfValueChanged = 1 << 4,
// The value is changed for a XUL text control as opposed to for an HTML
// text control. Such value changes are different in that they preserve the
// undo history.
eSetValue_ForXUL = 1 << 5,
// Whether it should be tried to move the cursor to the beginning of the
// text control and set the selection direction to "forward".
// TODO(mbrodesser): As soon as "none" is supported
// (https://bugzilla.mozilla.org/show_bug.cgi?id=1541454), it should be set
// to "none" and only fall back to "forward" if the platform doesn't support
// it.
eSetValue_MoveCursorToBeginSetSelectionDirectionForward = 1 << 6,
};
MOZ_CAN_RUN_SCRIPT
MOZ_MUST_USE bool SetValue(const nsAString& aValue,
const nsAString* aOldValue, uint32_t aFlags);
MOZ_CAN_RUN_SCRIPT
MOZ_MUST_USE bool SetValue(const nsAString& aValue, uint32_t aFlags) {
return SetValue(aValue, nullptr, aFlags);
}
void GetValue(nsAString& aValue, bool aIgnoreWrap) const;
bool HasNonEmptyValue();
// The following methods are for textarea element to use whether default
// value or not.
// XXX We might have to add assertion when it is into editable,
// or reconsider fixing bug 597525 to remove these.
void EmptyValue() {
if (mValue) mValue->Truncate();
}
bool IsEmpty() const { return mValue ? mValue->IsEmpty() : true; }
mozilla::dom::Element* GetRootNode();
mozilla::dom::Element* GetPreviewNode();
bool IsSingleLineTextControl() const {
return mTextCtrlElement->IsSingleLineTextControl();
}
bool IsTextArea() const { return mTextCtrlElement->IsTextArea(); }
bool IsPasswordTextControl() const {
return mTextCtrlElement->IsPasswordTextControl();
}
int32_t GetCols() { return mTextCtrlElement->GetCols(); }
int32_t GetWrapCols() { return mTextCtrlElement->GetWrapCols(); }
int32_t GetRows() { return mTextCtrlElement->GetRows(); }
void UpdateOverlayTextVisibility(bool aNotify);
// placeholder methods
bool GetPlaceholderVisibility() { return mPlaceholderVisibility; }
// preview methods
void SetPreviewText(const nsAString& aValue, bool aNotify);
void GetPreviewText(nsAString& aValue);
bool GetPreviewVisibility() { return mPreviewVisibility; }
/**
* Get the maxlength attribute
* @param aMaxLength the value of the max length attr
* @returns false if attr not defined
*/
int32_t GetMaxLength();
void HideSelectionIfBlurred();
struct SelectionProperties {
public:
SelectionProperties()
: mStart(0), mEnd(0), mDirection(nsITextControlFrame::eForward) {}
bool IsDefault() const {
return mStart == 0 && mEnd == 0 &&
mDirection == nsITextControlFrame::eForward;
}
uint32_t GetStart() const { return mStart; }
void SetStart(uint32_t value) {
mIsDirty = true;
mStart = value;
}
uint32_t GetEnd() const { return mEnd; }
void SetEnd(uint32_t value) {
mIsDirty = true;
mEnd = value;
}
nsITextControlFrame::SelectionDirection GetDirection() const {
return mDirection;
}
void SetDirection(nsITextControlFrame::SelectionDirection value) {
mIsDirty = true;
mDirection = value;
}
// return true only if mStart, mEnd, or mDirection have been modified,
// or if SetIsDirty() was explicitly called.
bool IsDirty() const { return mIsDirty; }
void SetIsDirty() { mIsDirty = true; }
private:
uint32_t mStart, mEnd;
bool mIsDirty = false;
nsITextControlFrame::SelectionDirection mDirection;
};
bool IsSelectionCached() const;
SelectionProperties& GetSelectionProperties();
void SetSelectionProperties(SelectionProperties& aProps);
void WillInitEagerly() { mSelectionRestoreEagerInit = true; }
bool HasNeverInitializedBefore() const { return !mEverInited; }
// Sync up our selection properties with our editor prior to being destroyed.
// This will invoke UnbindFromFrame() to ensure that we grab whatever
// selection state may be at the moment.
MOZ_CAN_RUN_SCRIPT
void SyncUpSelectionPropertiesBeforeDestruction();
// Get the selection range start and end points in our text.
void GetSelectionRange(uint32_t* aSelectionStart, uint32_t* aSelectionEnd,
mozilla::ErrorResult& aRv);
// Get the selection direction
nsITextControlFrame::SelectionDirection GetSelectionDirection(
mozilla::ErrorResult& aRv);
// Set the selection range (start, end, direction). aEnd is allowed to be
// smaller than aStart; in that case aStart will be reset to the same value as
// aEnd. This basically implements
// https://html.spec.whatwg.org/multipage/forms.html#set-the-selection-range
// but with the start/end already coerced to zero if null (and without the
// special infinity value), and the direction already converted to a
// SelectionDirection.
//
// If we have a frame, this method will scroll the selection into view.
//
// XXXbz This should really take uint32_t, but none of our guts (either the
// frame or our cached selection state) work with uint32_t at the moment...
void SetSelectionRange(uint32_t aStart, uint32_t aEnd,
nsITextControlFrame::SelectionDirection aDirection,
mozilla::ErrorResult& aRv);
// Set the selection range, but with an optional string for the direction.
// This will convert aDirection to an nsITextControlFrame::SelectionDirection
// and then call our other SetSelectionRange overload.
void SetSelectionRange(uint32_t aSelectionStart, uint32_t aSelectionEnd,
const mozilla::dom::Optional<nsAString>& aDirection,
mozilla::ErrorResult& aRv);
// Set the selection start. This basically implements the
// https://html.spec.whatwg.org/multipage/forms.html#dom-textarea/input-selectionstart
// setter.
void SetSelectionStart(const mozilla::dom::Nullable<uint32_t>& aStart,
mozilla::ErrorResult& aRv);
// Set the selection end. This basically implements the
// https://html.spec.whatwg.org/multipage/forms.html#dom-textarea/input-selectionend
// setter.
void SetSelectionEnd(const mozilla::dom::Nullable<uint32_t>& aEnd,
mozilla::ErrorResult& aRv);
// Get the selection direction as a string. This implements the
// https://html.spec.whatwg.org/multipage/forms.html#dom-textarea/input-selectiondirection
// getter.
void GetSelectionDirectionString(nsAString& aDirection,
mozilla::ErrorResult& aRv);
// Set the selection direction. This basically implements the
// https://html.spec.whatwg.org/multipage/forms.html#dom-textarea/input-selectiondirection
// setter.
void SetSelectionDirection(const nsAString& aDirection,
mozilla::ErrorResult& aRv);
// Set the range text. This basically implements
// https://html.spec.whatwg.org/multipage/forms.html#dom-textarea/input-setrangetext
void SetRangeText(const nsAString& aReplacement, mozilla::ErrorResult& aRv);
// The last two arguments are -1 if we don't know our selection range;
// otherwise they're the start and end of our selection range.
void SetRangeText(
const nsAString& aReplacement, uint32_t aStart, uint32_t aEnd,
mozilla::dom::SelectionMode aSelectMode, mozilla::ErrorResult& aRv,
const mozilla::Maybe<uint32_t>& aSelectionStart = mozilla::Nothing(),
const mozilla::Maybe<uint32_t>& aSelectionEnd = mozilla::Nothing());
void UpdateEditableState(bool aNotify) {
if (auto* root = GetRootNode()) {
root->UpdateEditableState(aNotify);
}
}
private:
friend class RestoreSelectionState;
// not copy constructible
nsTextEditorState(const nsTextEditorState&);
// not assignable
void operator=(const nsTextEditorState&);
void ValueWasChanged(bool aNotify);
MOZ_CAN_RUN_SCRIPT void DestroyEditor();
MOZ_CAN_RUN_SCRIPT void Clear();
nsresult InitializeRootNode();
void FinishedRestoringSelection();
mozilla::dom::HTMLInputElement* GetParentNumberControl(nsFrame* aFrame) const;
bool EditorHasComposition();
class InitializationGuard {
public:
explicit InitializationGuard(nsTextEditorState& aState)
: mState(aState), mGuardSet(false) {
if (!mState.mInitializing) {
mGuardSet = true;
mState.mInitializing = true;
}
}
~InitializationGuard() {
if (mGuardSet) {
mState.mInitializing = false;
}
}
bool IsInitializingRecursively() const { return !mGuardSet; }
private:
nsTextEditorState& mState;
bool mGuardSet;
};
friend class InitializationGuard;
friend class PrepareEditorEvent;
// The text control element owns this object, and ensures that this object
// has a smaller lifetime.
nsITextControlElement* MOZ_NON_OWNING_REF mTextCtrlElement;
RefPtr<nsTextInputSelectionImpl> mSelCon;
RefPtr<RestoreSelectionState> mRestoringSelection;
RefPtr<mozilla::TextEditor> mTextEditor;
nsTextControlFrame* mBoundFrame;
RefPtr<mozilla::TextInputListener> mTextListener;
mozilla::Maybe<nsString> mValue;
// mValueBeingSet is available only while SetValue() is requesting to commit
// composition. I.e., this is valid only while mIsCommittingComposition is
// true. While active composition is being committed, GetValue() needs
// the latest value which is set by SetValue(). So, this is cache for that.
nsString mValueBeingSet;
SelectionProperties mSelectionProperties;
bool mEverInited; // Have we ever been initialized?
bool mEditorInitialized;
bool mInitializing; // Whether we're in the process of initialization
bool mValueTransferInProgress; // Whether a value is being transferred to the
// frame
bool mSelectionCached; // Whether mSelectionProperties is valid
mutable bool mSelectionRestoreEagerInit; // Whether we're eager initing
// because of selection restore
bool mPlaceholderVisibility;
bool mPreviewVisibility;
bool mIsCommittingComposition;
};
inline void ImplCycleCollectionUnlink(nsTextEditorState& aField) {
aField.Unlink();
}
inline void ImplCycleCollectionTraverse(
nsCycleCollectionTraversalCallback& aCallback, nsTextEditorState& aField,
const char* aName, uint32_t aFlags = 0) {
aField.Traverse(aCallback);
}
#endif