summaryrefslogtreecommitdiffstats
path: root/dom/html/HTMLSelectElement.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/html/HTMLSelectElement.h550
1 files changed, 550 insertions, 0 deletions
diff --git a/dom/html/HTMLSelectElement.h b/dom/html/HTMLSelectElement.h
new file mode 100644
index 0000000000..3b7ab2ce17
--- /dev/null
+++ b/dom/html/HTMLSelectElement.h
@@ -0,0 +1,550 @@
+/* -*- 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_HTMLSelectElement_h
+#define mozilla_dom_HTMLSelectElement_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/ConstraintValidation.h"
+#include "nsGenericHTMLElement.h"
+
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/dom/HTMLOptionsCollection.h"
+#include "mozilla/EnumSet.h"
+#include "nsCheapSets.h"
+#include "nsCOMPtr.h"
+#include "nsError.h"
+#include "mozilla/dom/HTMLFormElement.h"
+#include "nsContentUtils.h"
+
+class nsContentList;
+class nsIDOMHTMLOptionElement;
+class nsIHTMLCollection;
+class nsISelectControlFrame;
+
+namespace mozilla {
+
+class ErrorResult;
+class EventChainPostVisitor;
+class EventChainPreVisitor;
+class SelectContentData;
+class PresState;
+
+namespace dom {
+
+class FormData;
+class HTMLSelectElement;
+
+class MOZ_STACK_CLASS SafeOptionListMutation {
+ public:
+ /**
+ * @param aSelect The select element which option list is being mutated.
+ * Can be null.
+ * @param aParent The content object which is being mutated.
+ * @param aKid If not null, a new child element is being inserted to
+ * aParent. Otherwise a child element will be removed.
+ * @param aIndex The index of the content object in the parent.
+ */
+ SafeOptionListMutation(nsIContent* aSelect, nsIContent* aParent,
+ nsIContent* aKid, uint32_t aIndex, bool aNotify);
+ ~SafeOptionListMutation();
+ void MutationFailed() { mNeedsRebuild = true; }
+
+ private:
+ static void* operator new(size_t) noexcept(true) { return 0; }
+ static void operator delete(void*, size_t) {}
+ /** The select element which option list is being mutated. */
+ RefPtr<HTMLSelectElement> mSelect;
+ /** true if the current mutation is the first one in the stack. */
+ bool mTopLevelMutation;
+ /** true if it is known that the option list must be recreated. */
+ bool mNeedsRebuild;
+ /** Whether we should be notifying when we make various method calls on
+ mSelect */
+ const bool mNotify;
+ /** The selected option at mutation start. */
+ RefPtr<HTMLOptionElement> mInitialSelectedOption;
+ /** Option list must be recreated if more than one mutation is detected. */
+ nsMutationGuard mGuard;
+};
+
+/**
+ * Implementation of &lt;select&gt;
+ */
+class HTMLSelectElement final : public nsGenericHTMLFormControlElementWithState,
+ public ConstraintValidation {
+ public:
+ /**
+ * IsSelected whether to set the option(s) to true or false
+ *
+ * ClearAll whether to clear all other options (for example, if you
+ * are normal-clicking on the current option)
+ *
+ * SetDisabled whether it is permissible to set disabled options
+ * (for JavaScript)
+ *
+ * Notify whether to notify frames and such
+ *
+ * NoReselect no need to select something after an option is
+ * deselected (for reset)
+ *
+ * InsertingOptions if an option has just been inserted some bailouts can't
+ * be taken
+ */
+ enum class OptionFlag : uint8_t {
+ IsSelected,
+ ClearAll,
+ SetDisabled,
+ Notify,
+ NoReselect,
+ InsertingOptions
+ };
+ using OptionFlags = EnumSet<OptionFlag>;
+
+ using ConstraintValidation::GetValidationMessage;
+
+ explicit HTMLSelectElement(
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
+ FromParser aFromParser = NOT_FROM_PARSER);
+
+ NS_IMPL_FROMNODE_HTML_WITH_TAG(HTMLSelectElement, select)
+
+ // nsISupports
+ NS_DECL_ISUPPORTS_INHERITED
+
+ int32_t TabIndexDefault() override;
+
+ // Element
+ bool IsInteractiveHTMLContent() const override { return true; }
+
+ // WebIdl HTMLSelectElement
+ void GetAutocomplete(DOMString& aValue);
+ void SetAutocomplete(const nsAString& aValue, ErrorResult& aRv) {
+ SetHTMLAttr(nsGkAtoms::autocomplete, aValue, aRv);
+ }
+
+ void GetAutocompleteInfo(AutocompleteInfo& aInfo);
+
+ bool Disabled() const { return GetBoolAttr(nsGkAtoms::disabled); }
+ void SetDisabled(bool aVal, ErrorResult& aRv) {
+ SetHTMLBoolAttr(nsGkAtoms::disabled, aVal, aRv);
+ }
+ bool Multiple() const { return GetBoolAttr(nsGkAtoms::multiple); }
+ void SetMultiple(bool aVal, ErrorResult& aRv) {
+ SetHTMLBoolAttr(nsGkAtoms::multiple, aVal, aRv);
+ }
+
+ void GetName(DOMString& aValue) { GetHTMLAttr(nsGkAtoms::name, aValue); }
+ void SetName(const nsAString& aName, ErrorResult& aRv) {
+ SetHTMLAttr(nsGkAtoms::name, aName, aRv);
+ }
+ bool Required() const { return State().HasState(ElementState::REQUIRED); }
+ void SetRequired(bool aVal, ErrorResult& aRv) {
+ SetHTMLBoolAttr(nsGkAtoms::required, aVal, aRv);
+ }
+ uint32_t Size() const { return GetUnsignedIntAttr(nsGkAtoms::size, 0); }
+ void SetSize(uint32_t aSize, ErrorResult& aRv) {
+ SetUnsignedIntAttr(nsGkAtoms::size, aSize, 0, aRv);
+ }
+
+ void GetType(nsAString& aValue);
+
+ HTMLOptionsCollection* Options() const { return mOptions; }
+ uint32_t Length() const { return mOptions->Length(); }
+ void SetLength(uint32_t aLength, ErrorResult& aRv);
+ Element* IndexedGetter(uint32_t aIdx, bool& aFound) const {
+ return mOptions->IndexedGetter(aIdx, aFound);
+ }
+ HTMLOptionElement* Item(uint32_t aIdx) const {
+ return mOptions->ItemAsOption(aIdx);
+ }
+ HTMLOptionElement* NamedItem(const nsAString& aName) const {
+ return mOptions->GetNamedItem(aName);
+ }
+ void Add(const HTMLOptionElementOrHTMLOptGroupElement& aElement,
+ const Nullable<HTMLElementOrLong>& aBefore, ErrorResult& aRv);
+ void Remove(int32_t aIndex) const;
+ void IndexedSetter(uint32_t aIndex, HTMLOptionElement* aOption,
+ ErrorResult& aRv) {
+ mOptions->IndexedSetter(aIndex, aOption, aRv);
+ }
+
+ static bool MatchSelectedOptions(Element* aElement, int32_t, nsAtom*, void*);
+
+ nsIHTMLCollection* SelectedOptions();
+
+ int32_t SelectedIndex() const { return mSelectedIndex; }
+ void SetSelectedIndex(int32_t aIdx) { SetSelectedIndexInternal(aIdx, true); }
+ void GetValue(DOMString& aValue) const;
+ void SetValue(const nsAString& aValue);
+
+ // Override SetCustomValidity so we update our state properly when it's called
+ // via bindings.
+ void SetCustomValidity(const nsAString& aError);
+
+ using nsINode::Remove;
+
+ // nsINode
+ JSObject* WrapNode(JSContext*, JS::Handle<JSObject*> aGivenProto) override;
+
+ // nsIContent
+ void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
+ MOZ_CAN_RUN_SCRIPT
+ nsresult PostHandleEvent(EventChainPostVisitor& aVisitor) override;
+
+ bool IsHTMLFocusable(bool aWithMouse, bool* aIsFocusable,
+ int32_t* aTabIndex) override;
+ void InsertChildBefore(nsIContent* aKid, nsIContent* aBeforeThis,
+ bool aNotify, ErrorResult& aRv) override;
+ void RemoveChildNode(nsIContent* aKid, bool aNotify) override;
+
+ // nsGenericHTMLElement
+ bool IsDisabledForEvents(WidgetEvent* aEvent) override;
+
+ // nsGenericHTMLFormElement
+ void SaveState() override;
+ bool RestoreState(PresState* aState) override;
+
+ // Overriden nsIFormControl methods
+ NS_IMETHOD Reset() override;
+ NS_IMETHOD SubmitNamesValues(FormData* aFormData) override;
+
+ void FieldSetDisabledChanged(bool aNotify) override;
+
+ ElementState IntrinsicState() const override;
+
+ /**
+ * To be called when stuff is added under a child of the select--but *before*
+ * they are actually added.
+ *
+ * @param aOptions the content that was added (usually just an option, but
+ * could be an optgroup node with many child options)
+ * @param aParent the parent the options were added to (could be an optgroup)
+ * @param aContentIndex the index where the options are being added within the
+ * parent (if the parent is an optgroup, the index within the optgroup)
+ */
+ NS_IMETHOD WillAddOptions(nsIContent* aOptions, nsIContent* aParent,
+ int32_t aContentIndex, bool aNotify);
+
+ /**
+ * To be called when stuff is removed under a child of the select--but
+ * *before* they are actually removed.
+ *
+ * @param aParent the parent the option(s) are being removed from
+ * @param aContentIndex the index of the option(s) within the parent (if the
+ * parent is an optgroup, the index within the optgroup)
+ */
+ NS_IMETHOD WillRemoveOptions(nsIContent* aParent, int32_t aContentIndex,
+ bool aNotify);
+
+ /**
+ * Checks whether an option is disabled (even if it's part of an optgroup)
+ *
+ * @param aIndex the index of the option to check
+ * @return whether the option is disabled
+ */
+ NS_IMETHOD IsOptionDisabled(int32_t aIndex, bool* aIsDisabled);
+ bool IsOptionDisabled(HTMLOptionElement* aOption) const;
+
+ /**
+ * Sets multiple options (or just sets startIndex if select is single)
+ * and handles notifications and cleanup and everything under the sun.
+ * When this method exits, the select will be in a consistent state. i.e.
+ * if you set the last option to false, it will select an option anyway.
+ *
+ * @param aStartIndex the first index to set
+ * @param aEndIndex the last index to set (set same as first index for one
+ * option)
+ * @param aOptionsMask determines whether to set, clear all or disable
+ * options and whether frames are to be notified of such.
+ * @return whether any options were actually changed
+ */
+ bool SetOptionsSelectedByIndex(int32_t aStartIndex, int32_t aEndIndex,
+ OptionFlags aOptionsMask);
+
+ /**
+ * Called when an attribute is about to be changed
+ */
+ nsresult BindToTree(BindContext&, nsINode& aParent) override;
+ void UnbindFromTree(bool aNullParent) override;
+ void BeforeSetAttr(int32_t aNameSpaceID, nsAtom* aName,
+ const nsAttrValue* aValue, bool aNotify) override;
+ void AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
+ const nsAttrValue* aValue, const nsAttrValue* aOldValue,
+ nsIPrincipal* aSubjectPrincipal, bool aNotify) override;
+
+ void DoneAddingChildren(bool aHaveNotified) override;
+ bool IsDoneAddingChildren() override { return mIsDoneAddingChildren; }
+
+ bool ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
+ const nsAString& aValue,
+ nsIPrincipal* aMaybeScriptedPrincipal,
+ nsAttrValue& aResult) override;
+ nsMapRuleToAttributesFunc GetAttributeMappingFunction() const override;
+ nsChangeHint GetAttributeChangeHint(const nsAtom* aAttribute,
+ int32_t aModType) const override;
+ NS_IMETHOD_(bool) IsAttributeMapped(const nsAtom* aAttribute) const override;
+
+ nsresult Clone(dom::NodeInfo*, nsINode** aResult) const override;
+
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(
+ HTMLSelectElement, nsGenericHTMLFormControlElementWithState)
+
+ HTMLOptionsCollection* GetOptions() { return mOptions; }
+
+ // ConstraintValidation
+ nsresult GetValidationMessage(nsAString& aValidationMessage,
+ ValidityStateType aType) override;
+
+ void UpdateValueMissingValidityState();
+ /**
+ * Insert aElement before the node given by aBefore
+ */
+ void Add(nsGenericHTMLElement& aElement, nsGenericHTMLElement* aBefore,
+ ErrorResult& aError);
+ void Add(nsGenericHTMLElement& aElement, int32_t aIndex,
+ ErrorResult& aError) {
+ // If item index is out of range, insert to last.
+ // (since beforeElement becomes null, it is inserted to last)
+ nsIContent* beforeContent = mOptions->GetElementAt(aIndex);
+ return Add(aElement, nsGenericHTMLElement::FromNodeOrNull(beforeContent),
+ aError);
+ }
+
+ /**
+ * Is this a combobox?
+ */
+ bool IsCombobox() const { return !Multiple() && Size() <= 1; }
+
+ bool OpenInParentProcess() const { return mIsOpenInParentProcess; }
+ void SetOpenInParentProcess(bool aVal) { mIsOpenInParentProcess = aVal; }
+
+ void GetPreviewValue(nsAString& aValue) { aValue = mPreviewValue; }
+ void SetPreviewValue(const nsAString& aValue);
+
+ protected:
+ virtual ~HTMLSelectElement() = default;
+
+ friend class SafeOptionListMutation;
+
+ // Helper Methods
+ /**
+ * Check whether the option specified by the index is selected
+ * @param aIndex the index
+ * @return whether the option at the index is selected
+ */
+ bool IsOptionSelectedByIndex(int32_t aIndex) const;
+ /**
+ * Starting with (and including) aStartIndex, find the first selected index
+ * and set mSelectedIndex to it.
+ * @param aStartIndex the index to start with
+ */
+ void FindSelectedIndex(int32_t aStartIndex, bool aNotify);
+ /**
+ * Select some option if possible (generally the first non-disabled option).
+ * @return true if something was selected, false otherwise
+ */
+ bool SelectSomething(bool aNotify);
+ /**
+ * Call SelectSomething(), but only if nothing is selected
+ * @see SelectSomething()
+ * @return true if something was selected, false otherwise
+ */
+ bool CheckSelectSomething(bool aNotify);
+ /**
+ * Called to trigger notifications of frames and fixing selected index
+ *
+ * @param aSelectFrame the frame for this content (could be null)
+ * @param aIndex the index that was selected or deselected
+ * @param aSelected whether the index was selected or deselected
+ * @param aChangeOptionState if false, don't do anything to the
+ * HTMLOptionElement at aIndex. If true, change
+ * its selected state to aSelected.
+ * @param aNotify whether to notify the style system and such
+ */
+ void OnOptionSelected(nsISelectControlFrame* aSelectFrame, int32_t aIndex,
+ bool aSelected, bool aChangeOptionState, bool aNotify);
+ /**
+ * Restore state to a particular state string (representing the options)
+ * @param aNewSelected the state string to restore to
+ */
+ void RestoreStateTo(const SelectContentData& aNewSelected);
+
+ // Adding options
+ /**
+ * Insert option(s) into the options[] array and perform notifications
+ * @param aOptions the option or optgroup being added
+ * @param aListIndex the index to start adding options into the list at
+ * @param aDepth the depth of aOptions (1=direct child of select ...)
+ */
+ void InsertOptionsIntoList(nsIContent* aOptions, int32_t aListIndex,
+ int32_t aDepth, bool aNotify);
+ /**
+ * Remove option(s) from the options[] array
+ * @param aOptions the option or optgroup being added
+ * @param aListIndex the index to start removing options from the list at
+ * @param aDepth the depth of aOptions (1=direct child of select ...)
+ */
+ nsresult RemoveOptionsFromList(nsIContent* aOptions, int32_t aListIndex,
+ int32_t aDepth, bool aNotify);
+
+ // nsIConstraintValidation
+ void UpdateBarredFromConstraintValidation();
+ bool IsValueMissing() const;
+
+ /**
+ * Get the index of the first option at, under or following the content in
+ * the select, or length of options[] if none are found
+ * @param aOptions the content
+ * @return the index of the first option
+ */
+ int32_t GetOptionIndexAt(nsIContent* aOptions);
+ /**
+ * Get the next option following the content in question (not at or under)
+ * (this could include siblings of the current content or siblings of the
+ * parent or children of siblings of the parent).
+ * @param aOptions the content
+ * @return the index of the next option after the content
+ */
+ int32_t GetOptionIndexAfter(nsIContent* aOptions);
+ /**
+ * Get the first option index at or under the content in question.
+ * @param aOptions the content
+ * @return the index of the first option at or under the content
+ */
+ int32_t GetFirstOptionIndex(nsIContent* aOptions);
+ /**
+ * Get the first option index under the content in question, within the
+ * range specified.
+ * @param aOptions the content
+ * @param aStartIndex the first child to look at
+ * @param aEndIndex the child *after* the last child to look at
+ * @return the index of the first option at or under the content
+ */
+ int32_t GetFirstChildOptionIndex(nsIContent* aOptions, int32_t aStartIndex,
+ int32_t aEndIndex);
+
+ /**
+ * Get the frame as an nsISelectControlFrame (MAY RETURN nullptr)
+ * @return the select frame, or null
+ */
+ nsISelectControlFrame* GetSelectFrame();
+
+ /**
+ * Helper method for dispatching ContentReset notifications to list box
+ * frames.
+ */
+ void DispatchContentReset();
+
+ /**
+ * Rebuilds the options array from scratch as a fallback in error cases.
+ */
+ void RebuildOptionsArray(bool aNotify);
+
+#ifdef DEBUG
+ void VerifyOptionsArray();
+#endif
+
+ void SetSelectedIndexInternal(int32_t aIndex, bool aNotify);
+
+ void SetSelectionChanged(bool aValue, bool aNotify);
+
+ /**
+ * Marks the selectedOptions list as dirty, so that it'll populate itself
+ * again.
+ */
+ void UpdateSelectedOptions();
+
+ /**
+ * Return whether an element should have a 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 selection has been changed.
+ */
+ if (mForm && mForm->HasEverTriedInvalidSubmit()) {
+ return true;
+ }
+
+ return mSelectionHasChanged;
+ }
+
+ /** The options[] array */
+ RefPtr<HTMLOptionsCollection> mOptions;
+ nsContentUtils::AutocompleteAttrState mAutocompleteAttrState;
+ nsContentUtils::AutocompleteAttrState mAutocompleteInfoState;
+ /** false if the parser is in the middle of adding children. */
+ bool mIsDoneAddingChildren : 1;
+ /** true if our disabled state has changed from the default **/
+ bool mDisabledChanged : 1;
+ /** true if child nodes are being added or removed.
+ * Used by SafeOptionListMutation.
+ */
+ bool mMutating : 1;
+ /**
+ * True if DoneAddingChildren will get called but shouldn't restore state.
+ */
+ bool mInhibitStateRestoration : 1;
+ /**
+ * True if the selection has changed since the element's creation.
+ */
+ bool mSelectionHasChanged : 1;
+ /**
+ * True if the default selected option has been set.
+ */
+ bool mDefaultSelectionSet : 1;
+ /**
+ * True if :-moz-ui-invalid can be shown.
+ */
+ bool mCanShowInvalidUI : 1;
+ /**
+ * True if :-moz-ui-valid can be shown.
+ */
+ bool mCanShowValidUI : 1;
+
+ /** True if we're open in the parent process */
+ bool mIsOpenInParentProcess : 1;
+
+ /** The number of non-options as children of the select */
+ uint32_t mNonOptionChildren;
+ /** The number of optgroups anywhere under the select */
+ uint32_t mOptGroupCount;
+ /**
+ * The current selected index for selectedIndex (will be the first selected
+ * index if multiple are selected)
+ */
+ int32_t mSelectedIndex;
+ /**
+ * The temporary restore state in case we try to restore before parser is
+ * done adding options
+ */
+ UniquePtr<SelectContentData> mRestoreState;
+
+ /**
+ * The live list of selected options.
+ */
+ RefPtr<nsContentList> mSelectedOptions;
+
+ /**
+ * The current displayed preview text.
+ */
+ nsString mPreviewValue;
+
+ private:
+ static void MapAttributesIntoRule(const nsMappedAttributes* aAttributes,
+ MappedDeclarations&);
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_HTMLSelectElement_h