Masayuki Nakano
ca0029c572
They may dispatch `UAWidgetSetupOrChange` or `UAWidgetTeardown` chrome event to notify the UA widget of creation or destruction. That's required to the layout and making the UA widget start working. This is important especially when the call is caused by JS. Then, the next line may require the new UA widget. Therefore, we cannot make them use `NS_DispatchToCurrentThread` because it may run too late for JS. On the other hand, they are called during `BindToTree()`, `UnbindFromTree()` and `nsCSSFrameConstructor` working. In these cases, running script is blocked. Therefore, their `AddScriptRunner` dispatches the chrome events asynchronously but before returning to the JS world. To avoid to mark them as `MOZ_CAN_RUN_SCRIPT` and `BindToTree()`, `UnbindFromTree()` and `nsCSSFrameConstructor` methods as `MOZ_CAN_RUN_SCRIPT_BOUNDARY`, they should always dispatch chrome events asynchronously. Therefore, they will assert that they are called when script is blocked and this patch adds some callers put `nsAutoScriptBlocker` or `mozAutoDocUpdate`. Differential Revision: https://phabricator.services.mozilla.com/D311670
576 lines
22 KiB
C++
576 lines
22 KiB
C++
/* 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/EnumSet.h"
|
|
#include "mozilla/dom/BindingDeclarations.h"
|
|
#include "mozilla/dom/ConstraintValidation.h"
|
|
#include "mozilla/dom/HTMLFormElement.h"
|
|
#include "mozilla/dom/HTMLOptionsCollection.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsError.h"
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsStubMutationObserver.h"
|
|
|
|
class nsIDOMHTMLOptionElement;
|
|
class nsListControlFrame;
|
|
|
|
namespace mozilla {
|
|
|
|
class ErrorResult;
|
|
class EventChainPostVisitor;
|
|
class EventChainPreVisitor;
|
|
class SelectContentData;
|
|
class PresState;
|
|
class WidgetMouseEvent;
|
|
|
|
namespace dom {
|
|
|
|
class ContentList;
|
|
class FormData;
|
|
class HTMLButtonElement;
|
|
class HTMLCollection;
|
|
class HTMLElementOrLong;
|
|
class HTMLOptionElementOrHTMLOptGroupElement;
|
|
class HTMLSelectElement;
|
|
class HTMLSelectedContentElement;
|
|
|
|
enum class SelectedContentUpdateMode : uint8_t { MicroTask, ScriptRunner };
|
|
|
|
/**
|
|
* Implementation of <select>
|
|
*/
|
|
class HTMLSelectElement final : public nsGenericHTMLFormControlElementWithState,
|
|
public nsStubMutationObserver,
|
|
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
|
|
|
|
// For comboboxes, we need to keep the list up to date when options change.
|
|
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
|
|
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
|
|
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
|
|
|
|
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);
|
|
|
|
// Sets the user interacted flag and fires input/change events if needed.
|
|
MOZ_CAN_RUN_SCRIPT void UserFinishedInteracting(bool aChanged);
|
|
|
|
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 static_cast<HTMLOptionElement*>(
|
|
mOptions->NamedItem(aName, /* aDoFlush = */ true));
|
|
}
|
|
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*);
|
|
|
|
HTMLCollection* SelectedOptions();
|
|
|
|
int32_t SelectedIndex() const;
|
|
// During removal handling we might need to ignore some options that are
|
|
// getting removed.
|
|
using IgnoredOptionList = Span<RefPtr<HTMLOptionElement>>;
|
|
HTMLOptionElement* GetSelectedOption(IgnoredOptionList = {}) const;
|
|
void SetSelectedIndex(int32_t aIdx);
|
|
void GetValue(nsAString& 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);
|
|
|
|
MOZ_CAN_RUN_SCRIPT void ShowPicker(ErrorResult& aRv);
|
|
|
|
using nsINode::Remove;
|
|
|
|
// nsINode
|
|
JSObject* WrapNode(JSContext*, JS::Handle<JSObject*> aGivenProto) override;
|
|
|
|
// nsIContent
|
|
void GetEventTargetParent(EventChainPreVisitor& aVisitor) override;
|
|
MOZ_CAN_RUN_SCRIPT_BOUNDARY
|
|
nsresult PostHandleEvent(EventChainPostVisitor& aVisitor) override;
|
|
|
|
HTMLOptionElement* GetCurrentOption() const;
|
|
|
|
bool IsHTMLFocusable(IsFocusableFlags, bool* aIsFocusable,
|
|
int32_t* aTabIndex) override;
|
|
|
|
// nsGenericHTMLElement
|
|
bool IsDisabledForEvents(WidgetEvent* aEvent) override;
|
|
|
|
// nsGenericHTMLFormElement
|
|
void SaveState() override;
|
|
bool RestoreState(PresState* aState) override;
|
|
|
|
// Overriden nsIFormControl methods
|
|
MOZ_CAN_RUN_SCRIPT NS_IMETHOD Reset() override;
|
|
NS_IMETHOD SubmitNamesValues(FormData* aFormData) override;
|
|
|
|
void FieldSetDisabledChanged(bool aNotify) override;
|
|
|
|
/**
|
|
* 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(UnbindContext&) 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() const { 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,
|
|
AttrModType 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(IgnoredOptionList = {});
|
|
void UpdateValidityElementStates(bool aNotify);
|
|
/**
|
|
* 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)
|
|
Element* beforeContent = mOptions->Item(aIndex);
|
|
return Add(aElement, nsGenericHTMLElement::FromNodeOrNull(beforeContent),
|
|
aError);
|
|
}
|
|
|
|
/** Is this a combobox? */
|
|
bool IsCombobox() const { return !Multiple() && Size() <= 1; }
|
|
|
|
bool IsBaseSelectAppearance() const;
|
|
nsGenericHTMLElement* GetPickerElement() const;
|
|
MOZ_CAN_RUN_SCRIPT void TogglePickerInternal(
|
|
bool aIsSourceTouchEvent = false);
|
|
|
|
bool OpenInParentProcess() const { return mIsOpenInParentProcess; }
|
|
void SetOpenInParentProcess(bool aVal) {
|
|
mIsOpenInParentProcess = aVal;
|
|
SetStates(ElementState::OPEN, aVal);
|
|
}
|
|
|
|
void OnPopoverStateChanged(bool aOpen) {
|
|
SetStates(ElementState::OPEN, aOpen);
|
|
}
|
|
|
|
void GetPreviewValue(nsAString& aValue) { aValue = mPreviewValue; }
|
|
void SetPreviewValue(const nsAString& aValue);
|
|
|
|
void SetAutofillState(const nsAString& aState) {
|
|
SetFormAutofillState(aState);
|
|
}
|
|
void GetAutofillState(nsAString& aState) { GetFormAutofillState(aState); }
|
|
|
|
HTMLButtonElement* GetFirstButton() const;
|
|
|
|
void SetupShadowTree();
|
|
void GetSlotNameFor(const ShadowRoot&, const nsIContent&,
|
|
nsAString&) const override;
|
|
void OnChildBeforeSlotted(ShadowRoot&, nsIContent&) override;
|
|
void OnChildUnslotted(ShadowRoot&, nsIContent&) override;
|
|
|
|
// Returns the text node that has the selected <option>'s text.
|
|
// Note that it might return null for printing.
|
|
Text* GetSelectedContentText() const;
|
|
void SelectedContentTextMightHaveChanged(bool aNotify = true,
|
|
IgnoredOptionList = {});
|
|
|
|
// https://html.spec.whatwg.org/#selectedness-setting-algorithm
|
|
// aIgnored: options to skip (for pre-removal handling where options are still
|
|
// in the list but about to be unbound).
|
|
void RunSelectednessSettingAlgorithm(bool aNotify = true,
|
|
bool aSkipSelectedcontentUpdate = false,
|
|
IgnoredOptionList aIgnored = {});
|
|
|
|
// Schedules an update of all descendant selectedcontent elements.
|
|
// Multiple calls coalesce into a single update.
|
|
// aForceUpdate: skips IsInComposedDoc and mSelectedContentUpdatePending
|
|
// guards. Used by spec algorithms (select.value, select.selectedIndex) that
|
|
// must update selectedcontent even on disconnected selects and must not be
|
|
// coalesced with deferred mutation-driven updates.
|
|
void ScheduleSelectedContentUpdate(
|
|
SelectedContentUpdateMode aMode = SelectedContentUpdateMode::MicroTask,
|
|
bool aForceUpdate = false);
|
|
|
|
// https://html.spec.whatwg.org/#update-a-select's-descendant-selectedcontent-elements
|
|
MOZ_CAN_RUN_SCRIPT void UpdateDescendantSelectedContentElements();
|
|
// Runs UpdateDescendantSelectedContentElements only if an update is still
|
|
// pending. Entry point for the microtask and script-runner schedulers so they
|
|
// coalesce into a single update.
|
|
MOZ_CAN_RUN_SCRIPT void RunPendingSelectedContentUpdate();
|
|
// https://html.spec.whatwg.org/#update-a-selectedcontent
|
|
MOZ_CAN_RUN_SCRIPT void UpdateSelectedContentElement(
|
|
HTMLSelectedContentElement* aSelectedContent);
|
|
// https://html.spec.whatwg.org/#clone-an-option-into-a-selectedcontent
|
|
MOZ_CAN_RUN_SCRIPT void CloneOptionIntoSelectedContent(
|
|
HTMLOptionElement* aOption, HTMLSelectedContentElement* aSelectedContent);
|
|
|
|
void ScrollToSelectedOption() { return ScrollToOption(SelectedIndex()); }
|
|
|
|
void ResetListBoxSelection(bool aAllowScrolling);
|
|
|
|
protected:
|
|
virtual ~HTMLSelectElement();
|
|
|
|
// 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);
|
|
/**
|
|
* Called to trigger notifications of frames and fixing selected index
|
|
*
|
|
* @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(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);
|
|
|
|
// nsIConstraintValidation
|
|
void UpdateBarredFromConstraintValidation();
|
|
bool IsValueMissing(IgnoredOptionList = {}) 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 nsListControlFrame (MAY RETURN nullptr) */
|
|
nsListControlFrame* GetListBoxFrame();
|
|
|
|
void SetSelectedIndexInternal(int32_t aIndex, bool aNotify);
|
|
|
|
void OnSelectionChanged();
|
|
|
|
/**
|
|
* Marks the selectedOptions list as dirty, so that it'll populate itself
|
|
* again.
|
|
*/
|
|
void UpdateSelectedOptions();
|
|
|
|
void SetUserInteracted(bool) final;
|
|
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleKeyDown(EventChainPostVisitor&);
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleKeyPress(EventChainPostVisitor&);
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleMouseDown(EventChainPostVisitor&);
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleMouseUp(EventChainPostVisitor&);
|
|
MOZ_CAN_RUN_SCRIPT nsresult HandleMouseMove(EventChainPostVisitor&);
|
|
|
|
// Returns the option targeted by aEvent, using the listbox frame
|
|
// for the necessary hit-testing geometry.
|
|
HTMLOptionElement* GetListBoxOptionFromEvent(const WidgetMouseEvent&);
|
|
|
|
// Grabs/releases mouse capture for listbox drag-selection.
|
|
void CaptureMouseEvents(bool aGrabMouseEvents);
|
|
|
|
// Selection-model helpers shared by the keyboard and mouse handlers above.
|
|
// The selection range (mStartSelectionIndex/mEndSelectionIndex) is only
|
|
// meaningful for a listbox, hence the nsListControlFrame argument used for
|
|
// the associated view updates (scrolling, focus invalidation and a11y
|
|
// events).
|
|
MOZ_CAN_RUN_SCRIPT
|
|
bool PerformListBoxSelection(int32_t aClickedIndex, bool aIsShift,
|
|
bool aIsControl);
|
|
MOZ_CAN_RUN_SCRIPT
|
|
bool ListBoxSingleSelection(int32_t aClickedIndex, bool aDoToggle);
|
|
bool ExtendedSelection(int32_t aStartIndex, int32_t aEndIndex,
|
|
bool aClearAll);
|
|
bool ToggleOptionSelected(int32_t aIndex);
|
|
void InitListBoxSelectionRange(int32_t aClickedIndex);
|
|
MOZ_CAN_RUN_SCRIPT void UpdateSelection();
|
|
MOZ_CAN_RUN_SCRIPT
|
|
void UpdateListBoxSelectionAfterKeyEvent(int32_t aNewIndex,
|
|
uint32_t aCharCode, bool aIsShift,
|
|
bool aIsControlOrMeta);
|
|
void RemoveOptionFromListBoxSelection(HTMLOptionElement& aOption);
|
|
void ScrollToOption(int32_t aIndex);
|
|
MOZ_CAN_RUN_SCRIPT void DoScrollToOption(int32_t aIndex);
|
|
void AdjustIndexForDisabledOpt(int32_t aStartIndex, int32_t& aNewIndex,
|
|
int32_t aNumOptions, int32_t aDoAdjustInc,
|
|
int32_t aDoAdjustIncNext);
|
|
void MaybeFireMenuItemActiveEvent(nsIContent* aPreviousCurrentOption);
|
|
bool IsOptionInteractivelySelectable(uint32_t aIndex) const;
|
|
int32_t GetEndSelectionIndex() const;
|
|
int32_t ItemsPerPage() const;
|
|
|
|
MOZ_CAN_RUN_SCRIPT
|
|
void PostHandleKeyEvent(int32_t aNewIndex, uint32_t aCharCode, bool aIsShift,
|
|
bool aIsControlOrMeta);
|
|
|
|
HTMLOptionElement* GetNonDisabledOptionFrom(
|
|
int32_t aFromIndex, int32_t* aFoundIndex = nullptr) const;
|
|
|
|
MOZ_CAN_RUN_SCRIPT void FireDropDownEvent(bool aShow,
|
|
bool aIsSourceTouchEvent);
|
|
|
|
void ContentAppendedOrInserted(nsIContent* aFirstNewContent, bool aIsAppend);
|
|
|
|
/** 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 = false;
|
|
/** True if DoneAddingChildren will get called but shouldn't restore state. */
|
|
bool mInhibitStateRestoration : 1;
|
|
/** https://html.spec.whatwg.org/#user-interacted */
|
|
bool mUserInteracted : 1 = false;
|
|
/** True if the default selected option has been set. */
|
|
bool mDefaultSelectionSet : 1 = false;
|
|
/** True if we're open in the parent process */
|
|
bool mIsOpenInParentProcess : 1 = false;
|
|
bool mButtonDown : 1 = false;
|
|
bool mControlSelectMode : 1 = false;
|
|
/**
|
|
* True once a selectedcontent update has been scheduled (as a microtask or a
|
|
* script runner) but has not run yet. Used to coalesce multiple mutations
|
|
* into a single update.
|
|
*/
|
|
bool mSelectedContentUpdatePending : 1 = false;
|
|
/**
|
|
* True while we are cloning the selected option into our descendant
|
|
* selectedcontent elements. Used to ignore the mutation observer
|
|
* notifications caused by that cloning, which would otherwise schedule a
|
|
* redundant update.
|
|
*/
|
|
bool mIsUpdatingSelectedContent : 1 = false;
|
|
/**
|
|
* True if the selection changed since the last mousedown that started a
|
|
* drag, used to decide whether to fire input/change on the matching
|
|
* mouseup.
|
|
*/
|
|
bool mListBoxSelectionChangedSinceDragStart : 1 = false;
|
|
/**
|
|
* 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<ContentList> mSelectedOptions;
|
|
|
|
/**
|
|
* The current displayed preview text.
|
|
*/
|
|
nsString mPreviewValue;
|
|
|
|
static constexpr int32_t kNothingSelected = -1;
|
|
|
|
/**
|
|
* Listbox selection range, only meaningful while a listbox frame exists.
|
|
* mEnd is the option focused for keyboard navigation.
|
|
*/
|
|
struct {
|
|
RefPtr<HTMLOptionElement> mStart;
|
|
RefPtr<HTMLOptionElement> mEnd;
|
|
// Whether mStart's index <= mEnd's index.
|
|
bool mStartIsLow = true;
|
|
|
|
void SetTo(HTMLOptionElement* aOption) {
|
|
mStart = mEnd = aOption;
|
|
mStartIsLow = true;
|
|
}
|
|
|
|
void Clear() {
|
|
mStart = mEnd = nullptr;
|
|
mStartIsLow = true;
|
|
}
|
|
} mListBoxSelection;
|
|
|
|
private:
|
|
static void MapAttributesIntoRule(MappedDeclarationsBuilder&);
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_dom_HTMLSelectElement_h
|