/* -*- 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 mozilla_dom_HTMLTextAreaElement_h #define mozilla_dom_HTMLTextAreaElement_h #include "mozilla/Attributes.h" #include "nsIDOMHTMLTextAreaElement.h" #include "nsITextControlElement.h" #include "nsIControllers.h" #include "nsIDOMNSEditableElement.h" #include "nsCOMPtr.h" #include "nsGenericHTMLElement.h" #include "nsStubMutationObserver.h" #include "nsIConstraintValidation.h" #include "mozilla/dom/HTMLFormElement.h" #include "mozilla/dom/HTMLInputElementBinding.h" #include "nsGkAtoms.h" #include "nsTextEditorState.h" class nsIControllers; class nsIDocument; class nsPresContext; class nsPresState; namespace mozilla { class EventChainPostVisitor; class EventChainPreVisitor; class EventStates; namespace dom { class HTMLFormSubmission; class HTMLTextAreaElement final : public nsGenericHTMLFormElementWithState, public nsIDOMHTMLTextAreaElement, public nsITextControlElement, public nsIDOMNSEditableElement, public nsStubMutationObserver, public nsIConstraintValidation { public: using nsIConstraintValidation::GetValidationMessage; explicit HTMLTextAreaElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo, FromParser aFromParser = NOT_FROM_PARSER); // nsISupports NS_DECL_ISUPPORTS_INHERITED virtual int32_t TabIndexDefault() override; // Element virtual bool IsInteractiveHTMLContent(bool aIgnoreTabindex) const override { return true; } // nsIDOMHTMLTextAreaElement NS_DECL_NSIDOMHTMLTEXTAREAELEMENT // nsIDOMNSEditableElement NS_IMETHOD GetEditor(nsIEditor** aEditor) override { return nsGenericHTMLElement::GetEditor(aEditor); } NS_IMETHOD SetUserInput(const nsAString& aInput) override; // nsIFormControl NS_IMETHOD_(uint32_t) GetType() const override { return NS_FORM_TEXTAREA; } NS_IMETHOD Reset() override; NS_IMETHOD SubmitNamesValues(HTMLFormSubmission* aFormSubmission) override; NS_IMETHOD SaveState() override; virtual bool RestoreState(nsPresState* aState) override; virtual bool IsDisabledForEvents(EventMessage aMessage) override; virtual void FieldSetDisabledChanged(bool aNotify) override; virtual EventStates IntrinsicState() const override; // nsITextControlElemet NS_IMETHOD SetValueChanged(bool aValueChanged) override; NS_IMETHOD_(bool) IsSingleLineTextControl() const override; NS_IMETHOD_(bool) IsTextArea() const override; NS_IMETHOD_(bool) IsPlainTextControl() const override; NS_IMETHOD_(bool) IsPasswordTextControl() const override; NS_IMETHOD_(int32_t) GetCols() override; NS_IMETHOD_(int32_t) GetWrapCols() override; NS_IMETHOD_(int32_t) GetRows() override; NS_IMETHOD_(void) GetDefaultValueFromContent(nsAString& aValue) override; NS_IMETHOD_(bool) ValueChanged() const override; NS_IMETHOD_(void) GetTextEditorValue(nsAString& aValue, bool aIgnoreWrap) const override; NS_IMETHOD_(nsIEditor*) GetTextEditor() override; NS_IMETHOD_(nsISelectionController*) GetSelectionController() override; NS_IMETHOD_(nsFrameSelection*) GetConstFrameSelection() override; NS_IMETHOD BindToFrame(nsTextControlFrame* aFrame) override; NS_IMETHOD_(void) UnbindFromFrame(nsTextControlFrame* aFrame) override; NS_IMETHOD CreateEditor() override; NS_IMETHOD_(nsIContent*) GetRootEditorNode() override; NS_IMETHOD_(Element*) CreatePlaceholderNode() override; NS_IMETHOD_(Element*) GetPlaceholderNode() override; NS_IMETHOD_(void) UpdatePlaceholderVisibility(bool aNotify) override; NS_IMETHOD_(bool) GetPlaceholderVisibility() override; NS_IMETHOD_(void) InitializeKeyboardEventListeners() override; NS_IMETHOD_(void) OnValueChanged(bool aNotify, bool aWasInteractiveUserChange) override; NS_IMETHOD_(bool) HasCachedSelection() override; // nsIContent virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent, nsIContent* aBindingParent, bool aCompileEventHandlers) override; virtual void UnbindFromTree(bool aDeep = true, bool aNullParent = true) override; virtual bool ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute, const nsAString& aValue, nsAttrValue& aResult) override; virtual nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override; virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute, int32_t aModType) const override; NS_IMETHOD_(bool) IsAttributeMapped(const nsIAtom* aAttribute) const override; virtual nsresult PreHandleEvent(EventChainPreVisitor& aVisitor) override; virtual nsresult PostHandleEvent( EventChainPostVisitor& aVisitor) override; virtual bool IsHTMLFocusable(bool aWithMouse, bool *aIsFocusable, int32_t *aTabIndex) override; virtual void DoneAddingChildren(bool aHaveNotified) override; virtual bool IsDoneAddingChildren() override; virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const override; nsresult CopyInnerTo(Element* aDest); /** * Called when an attribute is about to be changed */ virtual nsresult BeforeSetAttr(int32_t aNameSpaceID, nsIAtom* aName, nsAttrValueOrString* aValue, bool aNotify) override; // nsIMutationObserver NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLTextAreaElement, nsGenericHTMLFormElementWithState) // nsIConstraintValidation bool IsTooLong(); bool IsTooShort(); bool IsValueMissing() const; void UpdateTooLongValidityState(); void UpdateTooShortValidityState(); void UpdateValueMissingValidityState(); void UpdateBarredFromConstraintValidation(); nsresult GetValidationMessage(nsAString& aValidationMessage, ValidityStateType aType) override; // Web IDL binding methods bool Autofocus() { return GetBoolAttr(nsGkAtoms::autofocus); } void SetAutofocus(bool aAutoFocus, ErrorResult& aError) { SetHTMLBoolAttr(nsGkAtoms::autofocus, aAutoFocus, aError); } uint32_t Cols() { return GetIntAttr(nsGkAtoms::cols, DEFAULT_COLS); } void SetCols(uint32_t aCols, ErrorResult& aError) { uint32_t cols = aCols ? aCols : DEFAULT_COLS; SetUnsignedIntAttr(nsGkAtoms::cols, cols, DEFAULT_COLS, aError); } bool Disabled() { return GetBoolAttr(nsGkAtoms::disabled); } void SetDisabled(bool aDisabled, ErrorResult& aError) { SetHTMLBoolAttr(nsGkAtoms::disabled, aDisabled, aError); } // nsGenericHTMLFormElementWithState::GetForm is fine using nsGenericHTMLFormElementWithState::GetForm; int32_t MaxLength() { return GetIntAttr(nsGkAtoms::maxlength, -1); } void SetMaxLength(int32_t aMaxLength, ErrorResult& aError) { int32_t minLength = MinLength(); if (aMaxLength < 0 || (minLength >= 0 && aMaxLength < minLength)) { aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); } else { SetHTMLIntAttr(nsGkAtoms::maxlength, aMaxLength, aError); } } int32_t MinLength() { return GetIntAttr(nsGkAtoms::minlength, -1); } void SetMinLength(int32_t aMinLength, ErrorResult& aError) { int32_t maxLength = MaxLength(); if (aMinLength < 0 || (maxLength >= 0 && aMinLength > maxLength)) { aError.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR); } else { SetHTMLIntAttr(nsGkAtoms::minlength, aMinLength, aError); } } // XPCOM GetName is fine void SetName(const nsAString& aName, ErrorResult& aError) { SetHTMLAttr(nsGkAtoms::name, aName, aError); } // XPCOM GetPlaceholder is fine void SetPlaceholder(const nsAString& aPlaceholder, ErrorResult& aError) { SetHTMLAttr(nsGkAtoms::placeholder, aPlaceholder, aError); } bool ReadOnly() { return GetBoolAttr(nsGkAtoms::readonly); } void SetReadOnly(bool aReadOnly, ErrorResult& aError) { SetHTMLBoolAttr(nsGkAtoms::readonly, aReadOnly, aError); } bool Required() { return GetBoolAttr(nsGkAtoms::required); } void SetRangeText(const nsAString& aReplacement, ErrorResult& aRv); void SetRangeText(const nsAString& aReplacement, uint32_t aStart, uint32_t aEnd, const SelectionMode& aSelectMode, ErrorResult& aRv, int32_t aSelectionStart = -1, int32_t aSelectionEnd = -1); void SetRequired(bool aRequired, ErrorResult& aError) { SetHTMLBoolAttr(nsGkAtoms::required, aRequired, aError); } uint32_t Rows() { return GetIntAttr(nsGkAtoms::rows, DEFAULT_ROWS_TEXTAREA); } void SetRows(uint32_t aRows, ErrorResult& aError) { uint32_t rows = aRows ? aRows : DEFAULT_ROWS_TEXTAREA; SetUnsignedIntAttr(nsGkAtoms::rows, rows, DEFAULT_ROWS_TEXTAREA, aError); } // XPCOM GetWrap is fine void SetWrap(const nsAString& aWrap, ErrorResult& aError) { SetHTMLAttr(nsGkAtoms::wrap, aWrap, aError); } // XPCOM GetType is fine // XPCOM GetDefaultValue is fine void SetDefaultValue(const nsAString& aDefaultValue, ErrorResult& aError); // XPCOM GetValue/SetValue are fine uint32_t GetTextLength(); // nsIConstraintValidation::WillValidate is fine. // nsIConstraintValidation::Validity() is fine. // nsIConstraintValidation::GetValidationMessage() is fine. // nsIConstraintValidation::CheckValidity() is fine. using nsIConstraintValidation::CheckValidity; using nsIConstraintValidation::ReportValidity; // nsIConstraintValidation::SetCustomValidity() is fine. // XPCOM Select is fine Nullable<uint32_t> GetSelectionStart(ErrorResult& aError); void SetSelectionStart(const Nullable<uint32_t>& aSelectionStart, ErrorResult& aError); Nullable<uint32_t> GetSelectionEnd(ErrorResult& aError); void SetSelectionEnd(const Nullable<uint32_t>& aSelectionEnd, ErrorResult& aError); void GetSelectionDirection(nsAString& aDirection, ErrorResult& aError); void SetSelectionDirection(const nsAString& aDirection, ErrorResult& aError); void SetSelectionRange(uint32_t aSelectionStart, uint32_t aSelectionEnd, const Optional<nsAString>& aDirecton, ErrorResult& aError); nsIControllers* GetControllers(ErrorResult& aError); nsIEditor* GetEditor() { return mState.GetEditor(); } protected: virtual ~HTMLTextAreaElement() {} // get rid of the compiler warning using nsGenericHTMLFormElementWithState::IsSingleLineTextControl; virtual JSObject* WrapNode(JSContext *aCx, JS::Handle<JSObject*> aGivenProto) override; nsCOMPtr<nsIControllers> mControllers; /** Whether or not the value has changed since its default value was given. */ bool mValueChanged; /** Whether or not the last change to the value was made interactively by the user. */ bool mLastValueChangeWasInteractive; /** Whether or not we are already handling select event. */ bool mHandlingSelect; /** Whether or not we are done adding children (always true if not created by a parser */ bool mDoneAddingChildren; /** Whether state restoration should be inhibited in DoneAddingChildren. */ bool mInhibitStateRestoration; /** Whether our disabled state has changed from the default **/ bool mDisabledChanged; /** Whether we should make :-moz-ui-invalid apply on the element. **/ bool mCanShowInvalidUI; /** Whether we should make :-moz-ui-valid apply on the element. **/ bool mCanShowValidUI; void FireChangeEventIfNeeded(); nsString mFocusedValue; /** The state of the text editor (selection controller and the editor) **/ nsTextEditorState mState; NS_IMETHOD SelectAll(nsPresContext* aPresContext); /** * Get the value, whether it is from the content or the frame. * @param aValue the value [out] * @param aIgnoreWrap whether to ignore the wrap attribute when getting the * value. If this is true, linebreaks will not be inserted even if * wrap=hard. */ void GetValueInternal(nsAString& aValue, bool aIgnoreWrap) const; /** * Setting the value. * * @param aValue String to set. * @param aFlags See nsTextEditorState::SetValueFlags. */ nsresult SetValueInternal(const nsAString& aValue, uint32_t aFlags); nsresult GetSelectionRange(int32_t* aSelectionStart, int32_t* aSelectionEnd); /** * Common method to call from the various mutation observer methods. * aContent is a content node that's either the one that changed or its * parent; we should only respond to the change if aContent is non-anonymous. */ void ContentChanged(nsIContent* aContent); virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom *aName, const nsAttrValue* aValue, bool aNotify) override; /** * Return if an element should have a specific validity UI * (with :-moz-ui-invalid and :-moz-ui-valid pseudo-classes). * * @return Whether the element should have a validity UI. */ bool ShouldShowValidityUI() const { /** * Always show the validity UI if the form has already tried to be submitted * but was invalid. * * Otherwise, show the validity UI if the element's value has been changed. */ if (mForm && mForm->HasEverTriedInvalidSubmit()) { return true; } return mValueChanged; } /** * Get the mutable state of the element. */ bool IsMutable() const; /** * Returns whether the current value is the empty string. * * @return whether the current value is the empty string. */ bool IsValueEmpty() const; private: static void MapAttributesIntoRule(const nsMappedAttributes* aAttributes, nsRuleData* aData); }; } // namespace dom } // namespace mozilla #endif