Keith Cirkel
36658b19bd
Bug 2038588, replaced `TrySelectSomething`, so that option selectedness is only dirty via `OnSelectionChanged`. `OnSelectionChanged` returns early unless `mDefaultSelectionSet` is set, and only `DoneAddingChildren` sets it. This means it never runs for a select built by script. Removing the last unselected option from such a combobox, or resetting its form, re-selects the first enabled option but leaves `selectedOptions` stale. This change moves to initialise `mIsDoneAddingChildren` in the constructor. It's already set when the select is not parser-created. The result is that the early return is skipped, allowing the selected option list to become dirty. Differential Revision: https://phabricator.services.mozilla.com/D323244
2910 lines
96 KiB
C++
2910 lines
96 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/. */
|
|
|
|
#include "mozilla/dom/HTMLSelectElement.h"
|
|
|
|
#include "ButtonControlFrame.h"
|
|
#include "mozilla/BasicEvents.h"
|
|
#include "mozilla/BuiltInStyleSheets.h"
|
|
#include "mozilla/Casting.h"
|
|
#include "mozilla/ClearOnShutdown.h"
|
|
#include "mozilla/CycleCollectedJSContext.h"
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStateManager.h"
|
|
#include "mozilla/MappedDeclarationsBuilder.h"
|
|
#include "mozilla/MouseEvents.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/PresState.h"
|
|
#include "mozilla/StaticPrefs_ui.h"
|
|
#include "mozilla/TextEvents.h"
|
|
#include "mozilla/dom/AncestorIterator.h"
|
|
#include "mozilla/dom/BindContext.h"
|
|
#include "mozilla/dom/ContentList.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/dom/DocumentFragment.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/FormData.h"
|
|
#include "mozilla/dom/HTMLButtonElement.h"
|
|
#include "mozilla/dom/HTMLOptGroupElement.h"
|
|
#include "mozilla/dom/HTMLOptionElement.h"
|
|
#include "mozilla/dom/HTMLSelectElementBinding.h"
|
|
#include "mozilla/dom/HTMLSelectedContentElement.h"
|
|
#include "mozilla/dom/HTMLSlotElement.h"
|
|
#include "mozilla/dom/HTMLSlotElementBinding.h"
|
|
#include "mozilla/dom/MouseEventBinding.h"
|
|
#include "mozilla/dom/NameSpaceConstants.h"
|
|
#include "mozilla/dom/ShadowRoot.h"
|
|
#include "mozilla/dom/ShadowRootBinding.h"
|
|
#include "mozilla/dom/UnionTypes.h"
|
|
#include "mozilla/dom/WindowGlobalChild.h"
|
|
#include "nsComboboxControlFrame.h"
|
|
#include "nsComputedDOMStyle.h"
|
|
#include "nsContentCreatorFunctions.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsError.h"
|
|
#include "nsGenericHTMLElement.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsListControlFrame.h"
|
|
#include "nsStyleConsts.h"
|
|
|
|
#ifdef ACCESSIBILITY
|
|
# include "nsAccessibilityService.h"
|
|
#endif
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(Select)
|
|
|
|
static bool IsOptionInteractivelySelectable(
|
|
const mozilla::dom::HTMLSelectElement& aSelect,
|
|
mozilla::dom::HTMLOptionElement& aOption) {
|
|
if (aSelect.IsOptionDisabled(&aOption)) {
|
|
return false;
|
|
}
|
|
if (!aSelect.IsCombobox()) {
|
|
return aOption.GetPrimaryFrame();
|
|
}
|
|
for (mozilla::dom::Element* el = &aOption; el && el != &aSelect;
|
|
el = el->GetParentElement()) {
|
|
RefPtr style = nsComputedDOMStyle::GetComputedStyleNoFlush(el);
|
|
if (!style) {
|
|
return false;
|
|
}
|
|
auto display = style->StyleDisplay()->mDisplay;
|
|
if (display == mozilla::StyleDisplay::None) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static mozilla::StaticAutoPtr<nsString> sIncrementalString;
|
|
static mozilla::TimeStamp gLastKeyTime;
|
|
static uintptr_t sLastSelectKeyHandler = 0;
|
|
|
|
static nsString& GetIncrementalString() {
|
|
MOZ_ASSERT(sLastSelectKeyHandler != 0);
|
|
if (!sIncrementalString) {
|
|
sIncrementalString = new nsString();
|
|
mozilla::ClearOnShutdown(&sIncrementalString);
|
|
}
|
|
return *sIncrementalString;
|
|
}
|
|
|
|
namespace mozilla::dom {
|
|
|
|
//----------------------------------------------------------------------
|
|
//
|
|
// HTMLSelectElement
|
|
//
|
|
|
|
// construction, destruction
|
|
|
|
HTMLSelectElement::HTMLSelectElement(
|
|
already_AddRefed<mozilla::dom::NodeInfo> aNodeInfo, FromParser aFromParser)
|
|
: nsGenericHTMLFormControlElementWithState(
|
|
std::move(aNodeInfo), aFromParser, FormControlType::Select),
|
|
mOptions(new HTMLOptionsCollection(this, !!aFromParser)),
|
|
mAutocompleteAttrState(nsContentUtils::eAutocompleteAttrState_Unknown),
|
|
mAutocompleteInfoState(nsContentUtils::eAutocompleteAttrState_Unknown),
|
|
mIsDoneAddingChildren(!aFromParser),
|
|
mInhibitStateRestoration(!!(aFromParser & FROM_PARSER_FRAGMENT)),
|
|
mDefaultSelectionSet(!aFromParser) {
|
|
SetHasWeirdParserInsertionMode();
|
|
// Set up our default state: enabled, optional, and valid.
|
|
AddStatesSilently(ElementState::ENABLED | ElementState::OPTIONAL_ |
|
|
ElementState::VALID);
|
|
AddMutationObserver(this);
|
|
}
|
|
|
|
HTMLButtonElement* HTMLSelectElement::GetFirstButton() const {
|
|
return HTMLButtonElement::FromNodeOrNull(nsINode::GetFirstElementChild());
|
|
}
|
|
|
|
/* https://html.spec.whatwg.org/#the-select-element-2:the-select-element-13 */
|
|
void HTMLSelectElement::SetupShadowTree() {
|
|
AttachAndSetUAShadowRoot(NotifyUAWidget::No, DelegatesFocus::No,
|
|
CustomSlotDispatch::Yes);
|
|
// When a select is being rendered as a drop-down box with base appearance, it
|
|
// is expected to render with a shadow tree that contains the following
|
|
// elements:
|
|
RefPtr<ShadowRoot> sr = GetShadowRoot();
|
|
if (NS_WARN_IF(!sr)) {
|
|
return;
|
|
}
|
|
sr->AppendBuiltInStyleSheet(BuiltInStyleSheet::Select);
|
|
Document* doc = OwnerDoc();
|
|
// A select button slot, which is a slot element. It is appended to the
|
|
// select's shadow root as the first child. It is expected to take the first
|
|
// child element of the select if the first child element is a button.
|
|
{
|
|
RefPtr slot = doc->CreateHTMLElement(nsGkAtoms::slot);
|
|
slot->SetAttr(kNameSpaceID_None, nsGkAtoms::name,
|
|
u"internal-select-button"_ns, false);
|
|
sr->AppendChildTo(slot, false, IgnoreErrors());
|
|
}
|
|
|
|
// A select fallback button text, which is a div element. It is appended to
|
|
// the select button slot.
|
|
{
|
|
RefPtr label = doc->CreateHTMLElement(nsGkAtoms::label);
|
|
label->SetPseudoElementType(PseudoStyleType::MozSelectContent);
|
|
{
|
|
RefPtr text = doc->CreateTextNode(u"\ufeff"_ns);
|
|
label->AppendChildTo(text, false, IgnoreErrors());
|
|
}
|
|
sr->AppendChildTo(label, false, IgnoreErrors());
|
|
}
|
|
|
|
// A select popover, which is a div element. It is appended to the select's
|
|
// shadow root as the second child, after the select button slot. The select
|
|
// element's '::picker' pseudo-element is the select popover if the provided
|
|
// argument is select.
|
|
RefPtr picker = doc->CreateHTMLElement(nsGkAtoms::div);
|
|
picker->SetPseudoElementType(PseudoStyleType::Picker);
|
|
picker->SetAttr(nsGkAtoms::name, u"select"_ns, IgnoreErrors());
|
|
{
|
|
nsAutoString popoverstate;
|
|
picker->SetAttr(kNameSpaceID_None, nsGkAtoms::popover, popoverstate, false);
|
|
// SetAttr queues AfterSetPopoverAttr asynchronously, but
|
|
// ShowPopoverInternal needs PopoverAttributeState set immediately.
|
|
picker->EnsurePopoverData().SetPopoverAttributeState(
|
|
PopoverAttributeState::Auto);
|
|
|
|
// A select popover slot, which is a slot element. It is appended to the
|
|
// select popover. It is expected to take all child nodes of the select
|
|
// except for the first child button, which is taken by the select button
|
|
// slot.
|
|
RefPtr pickerSlot = doc->CreateHTMLElement(nsGkAtoms::slot);
|
|
picker->AppendChildTo(pickerSlot, false, IgnoreErrors());
|
|
}
|
|
sr->AppendChildTo(picker, false, IgnoreErrors());
|
|
}
|
|
|
|
bool HTMLSelectElement::IsBaseSelectAppearance() const {
|
|
RefPtr<const ComputedStyle> style =
|
|
nsComputedDOMStyle::GetComputedStyleNoFlush(this);
|
|
if (!style) {
|
|
return false;
|
|
}
|
|
auto appearance = style->StyleDisplay()->EffectiveAppearance();
|
|
return appearance == StyleAppearance::BaseSelect ||
|
|
appearance == StyleAppearance::Base;
|
|
}
|
|
|
|
nsGenericHTMLElement* HTMLSelectElement::GetPickerElement() const {
|
|
return nsGenericHTMLElement::FromNodeOrNull(
|
|
FindShadowPseudo(PseudoStyleType::Picker));
|
|
}
|
|
|
|
void HTMLSelectElement::TogglePickerInternal(bool aIsSourceTouchEvent) {
|
|
if (IsBaseSelectAppearance()) {
|
|
if (RefPtr<nsGenericHTMLElement> picker = GetPickerElement()) {
|
|
IgnoredErrorResult rv;
|
|
if (picker->PopoverOpen()) {
|
|
picker->HidePopover(rv);
|
|
} else {
|
|
picker->ShowPopoverInternal(this, rv);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
if (!OpenInParentProcess()) {
|
|
FireDropDownEvent(true, aIsSourceTouchEvent);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::GetSlotNameFor(const ShadowRoot& aShadow,
|
|
const nsIContent& aContent,
|
|
nsAString& aName) const {
|
|
const auto* button = HTMLButtonElement::FromNode(aContent);
|
|
if (!button) {
|
|
return;
|
|
}
|
|
const auto* select = HTMLSelectElement::FromNodeOrNull(button->GetParent());
|
|
if (select && select->GetFirstButton() == button) {
|
|
aName.AssignLiteral("internal-select-button");
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::OnChildBeforeSlotted(ShadowRoot& aShadow,
|
|
nsIContent& aChild) {
|
|
if (!aChild.IsHTMLElement(nsGkAtoms::button)) {
|
|
return;
|
|
}
|
|
HTMLSlotElement* slot =
|
|
aShadow.GetFirstNamedSlot(u"internal-select-button"_ns);
|
|
MOZ_RELEASE_ASSERT(slot);
|
|
auto assigned = slot->AssignedNodes();
|
|
if (assigned.IsEmpty()) {
|
|
return;
|
|
}
|
|
if (auto* button = HTMLButtonElement::FromNode(assigned[0])) {
|
|
aShadow.MaybeReassignContent(*button);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::OnChildUnslotted(ShadowRoot& aShadow,
|
|
nsIContent& aChild) {
|
|
if (!aChild.IsHTMLElement(nsGkAtoms::button)) {
|
|
return;
|
|
}
|
|
if (!MOZ_LIKELY(aShadow.GetHost())) {
|
|
return;
|
|
}
|
|
auto* select = HTMLSelectElement::FromNode(aShadow.GetHost());
|
|
MOZ_DIAGNOSTIC_ASSERT(select);
|
|
if (HTMLButtonElement* newButton = select->GetFirstButton()) {
|
|
aShadow.MaybeReassignContent(*newButton);
|
|
}
|
|
}
|
|
|
|
Text* HTMLSelectElement::GetSelectedContentText() const {
|
|
auto* sr = GetShadowRoot();
|
|
if (!sr) {
|
|
MOZ_ASSERT(OwnerDoc()->IsStaticDocument() || !IsInComposedDoc());
|
|
return nullptr;
|
|
}
|
|
auto* slot = sr->GetFirstChild();
|
|
MOZ_DIAGNOSTIC_ASSERT(slot);
|
|
MOZ_DIAGNOSTIC_ASSERT(slot->IsHTMLElement(nsGkAtoms::slot));
|
|
auto* label = slot->GetNextSibling();
|
|
MOZ_DIAGNOSTIC_ASSERT(label);
|
|
MOZ_DIAGNOSTIC_ASSERT(label->IsHTMLElement(nsGkAtoms::label));
|
|
MOZ_DIAGNOSTIC_ASSERT(label->GetFirstChild());
|
|
MOZ_DIAGNOSTIC_ASSERT(label->GetFirstChild()->IsText());
|
|
return label->GetFirstChild()->AsText();
|
|
}
|
|
|
|
// ISupports
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLSelectElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(
|
|
HTMLSelectElement, nsGenericHTMLFormControlElementWithState)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mValidity)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOptions)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelectedOptions)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListBoxSelection.mStart)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListBoxSelection.mEnd)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(
|
|
HTMLSelectElement, nsGenericHTMLFormControlElementWithState)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mValidity)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelectedOptions)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mListBoxSelection.mStart)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mListBoxSelection.mEnd)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(
|
|
HTMLSelectElement, nsGenericHTMLFormControlElementWithState,
|
|
nsIConstraintValidation)
|
|
|
|
// nsIDOMHTMLSelectElement
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLSelectElement)
|
|
|
|
void HTMLSelectElement::SetCustomValidity(const nsAString& aError) {
|
|
ConstraintValidation::SetCustomValidity(aError);
|
|
UpdateValidityElementStates(true);
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/multipage/input.html#dom-input-showpicker
|
|
void HTMLSelectElement::ShowPicker(ErrorResult& aRv) {
|
|
// Step 1. If this is not mutable, then throw an "InvalidStateError"
|
|
// DOMException.
|
|
if (IsDisabled()) {
|
|
return aRv.ThrowInvalidStateError("This select is disabled.");
|
|
}
|
|
|
|
// Step 2. If this's relevant settings object's origin is not same origin with
|
|
// this's relevant settings object's top-level origin, and this is a select
|
|
// element, [...], then throw a "SecurityError" DOMException.
|
|
nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
|
|
WindowGlobalChild* windowGlobalChild =
|
|
window ? window->GetWindowGlobalChild() : nullptr;
|
|
if (!windowGlobalChild || !windowGlobalChild->SameOriginWithTop()) {
|
|
return aRv.ThrowSecurityError(
|
|
"Call was blocked because the current origin isn't same-origin with "
|
|
"top.");
|
|
}
|
|
|
|
// Step 3. If this's relevant global object does not have transient
|
|
// activation, then throw a "NotAllowedError" DOMException.
|
|
if (!OwnerDoc()->HasValidTransientUserGestureActivation()) {
|
|
return aRv.ThrowNotAllowedError(
|
|
"Call was blocked due to lack of user activation.");
|
|
}
|
|
|
|
// Step 4. If this is a select element, and this is not being rendered, then
|
|
// throw a "NotSupportedError" DOMException.
|
|
|
|
// Flush frames so that IsRendered returns up-to-date results.
|
|
(void)GetPrimaryFrame(FlushType::Frames);
|
|
if (!IsRendered()) {
|
|
return aRv.ThrowNotSupportedError("This select isn't being rendered.");
|
|
}
|
|
|
|
// Step 5. Show the picker, if applicable, for this.
|
|
// https://html.spec.whatwg.org/multipage/input.html#show-the-picker,-if-applicable
|
|
// To show the picker, if applicable for an input element element:
|
|
// We already checked if mutable and user activation earlier, so skip 1 & 2.
|
|
|
|
// Step 3. Consume user activation given element's relevant global object.
|
|
OwnerDoc()->ConsumeTransientUserGestureActivation();
|
|
|
|
// Step 5. Otherwise, the user agent should show any relevant user interface
|
|
// for selecting a value for element, in the way it normally would when the
|
|
// user interacts with the control.
|
|
#if !defined(ANDROID)
|
|
if (!IsCombobox()) {
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
if (!IsInActiveTab(OwnerDoc())) {
|
|
return;
|
|
}
|
|
|
|
TogglePickerInternal();
|
|
}
|
|
|
|
void HTMLSelectElement::GetAutocomplete(DOMString& aValue) {
|
|
const nsAttrValue* attributeVal = GetParsedAttr(nsGkAtoms::autocomplete);
|
|
|
|
mAutocompleteAttrState = nsContentUtils::SerializeAutocompleteAttribute(
|
|
attributeVal, aValue, mAutocompleteAttrState);
|
|
}
|
|
|
|
void HTMLSelectElement::GetAutocompleteInfo(AutocompleteInfo& aInfo) {
|
|
const nsAttrValue* attributeVal = GetParsedAttr(nsGkAtoms::autocomplete);
|
|
mAutocompleteInfoState = nsContentUtils::SerializeAutocompleteAttribute(
|
|
attributeVal, aInfo, mAutocompleteInfoState, true);
|
|
}
|
|
|
|
int32_t HTMLSelectElement::GetOptionIndexAt(nsIContent* aOptions) {
|
|
// Search this node and below.
|
|
// If not found, find the first one *after* this node.
|
|
int32_t retval = GetFirstOptionIndex(aOptions);
|
|
if (retval == -1) {
|
|
retval = GetOptionIndexAfter(aOptions);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int32_t HTMLSelectElement::GetOptionIndexAfter(nsIContent* aOptions) {
|
|
// - If this is the select, the next option is the last.
|
|
// - If not, search all the options after aOptions and up to the last option
|
|
// in the parent.
|
|
// - If it's not there, search for the first option after the parent.
|
|
if (aOptions == this) {
|
|
return Length();
|
|
}
|
|
|
|
int32_t retval = -1;
|
|
|
|
nsCOMPtr<nsIContent> parent = aOptions->GetParent();
|
|
|
|
if (parent) {
|
|
const int32_t index = parent->ComputeIndexOf_Deprecated(aOptions);
|
|
const int32_t count = static_cast<int32_t>(parent->GetChildCount());
|
|
|
|
retval = GetFirstChildOptionIndex(parent, index + 1, count);
|
|
|
|
if (retval == -1) {
|
|
retval = GetOptionIndexAfter(parent);
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
int32_t HTMLSelectElement::GetFirstOptionIndex(nsIContent* aOptions) {
|
|
int32_t listIndex = -1;
|
|
HTMLOptionElement* optElement = HTMLOptionElement::FromNode(aOptions);
|
|
if (optElement) {
|
|
mOptions->GetOptionIndex(optElement, 0, true, &listIndex);
|
|
return listIndex;
|
|
}
|
|
|
|
listIndex = GetFirstChildOptionIndex(aOptions, 0, aOptions->GetChildCount());
|
|
|
|
return listIndex;
|
|
}
|
|
|
|
int32_t HTMLSelectElement::GetFirstChildOptionIndex(nsIContent* aOptions,
|
|
int32_t aStartIndex,
|
|
int32_t aEndIndex) {
|
|
int32_t retval = -1;
|
|
|
|
for (int32_t i = aStartIndex; i < aEndIndex; ++i) {
|
|
retval = GetFirstOptionIndex(aOptions->GetChildAt_Deprecated(i));
|
|
if (retval != -1) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
nsListControlFrame* HTMLSelectElement::GetListBoxFrame() {
|
|
return do_QueryFrame(GetPrimaryFrame());
|
|
}
|
|
|
|
void HTMLSelectElement::Add(
|
|
const HTMLOptionElementOrHTMLOptGroupElement& aElement,
|
|
const Nullable<HTMLElementOrLong>& aBefore, ErrorResult& aRv) {
|
|
nsGenericHTMLElement& element =
|
|
aElement.IsHTMLOptionElement() ? static_cast<nsGenericHTMLElement&>(
|
|
aElement.GetAsHTMLOptionElement())
|
|
: static_cast<nsGenericHTMLElement&>(
|
|
aElement.GetAsHTMLOptGroupElement());
|
|
|
|
if (aBefore.IsNull()) {
|
|
Add(element, static_cast<nsGenericHTMLElement*>(nullptr), aRv);
|
|
} else if (aBefore.Value().IsHTMLElement()) {
|
|
Add(element, &aBefore.Value().GetAsHTMLElement(), aRv);
|
|
} else {
|
|
Add(element, aBefore.Value().GetAsLong(), aRv);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::Add(nsGenericHTMLElement& aElement,
|
|
nsGenericHTMLElement* aBefore,
|
|
ErrorResult& aError) {
|
|
if (!aBefore) {
|
|
Element::AppendChild(aElement, aError);
|
|
return;
|
|
}
|
|
|
|
// Just in case we're not the parent, get the parent of the reference
|
|
// element
|
|
nsCOMPtr<nsINode> parent = aBefore->Element::GetParentNode();
|
|
if (!parent || !parent->IsInclusiveDescendantOf(this)) {
|
|
// NOT_FOUND_ERR: Raised if before is not a descendant of the SELECT
|
|
// element.
|
|
aError.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
|
|
return;
|
|
}
|
|
|
|
// If the before parameter is not null, we are equivalent to the
|
|
// insertBefore method on the parent of before.
|
|
nsCOMPtr<nsINode> refNode = aBefore;
|
|
parent->InsertBefore(aElement, refNode, aError);
|
|
}
|
|
|
|
void HTMLSelectElement::Remove(int32_t aIndex) const {
|
|
if (aIndex < 0) {
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsINode> option = Item(static_cast<uint32_t>(aIndex));
|
|
if (!option) {
|
|
return;
|
|
}
|
|
|
|
option->Remove();
|
|
}
|
|
|
|
void HTMLSelectElement::GetType(nsAString& aType) {
|
|
if (HasAttr(nsGkAtoms::multiple)) {
|
|
aType.AssignLiteral("select-multiple");
|
|
} else {
|
|
aType.AssignLiteral("select-one");
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::SetLength(uint32_t aLength, ErrorResult& aRv) {
|
|
constexpr uint32_t kMaxDynamicSelectLength = 100000;
|
|
|
|
uint32_t curlen = Length();
|
|
|
|
if (curlen > aLength) { // Remove extra options
|
|
for (uint32_t i = curlen; i > aLength; --i) {
|
|
Remove(i - 1);
|
|
}
|
|
} else if (aLength > curlen) {
|
|
if (aLength > kMaxDynamicSelectLength) {
|
|
nsAutoString strOptionsLength;
|
|
strOptionsLength.AppendInt(aLength);
|
|
|
|
nsAutoString strLimit;
|
|
strLimit.AppendInt(kMaxDynamicSelectLength);
|
|
|
|
nsContentUtils::ReportToConsole(
|
|
nsIScriptError::warningFlag, "DOM"_ns, OwnerDoc(),
|
|
PropertiesFile::DOM_PROPERTIES,
|
|
"SelectOptionsLengthAssignmentWarning",
|
|
{std::move(strOptionsLength), std::move(strLimit)});
|
|
return;
|
|
}
|
|
|
|
RefPtr<mozilla::dom::NodeInfo> nodeInfo;
|
|
|
|
nsContentUtils::QNameChanged(mNodeInfo, nsGkAtoms::option,
|
|
getter_AddRefs(nodeInfo));
|
|
|
|
nsCOMPtr<nsINode> node = NS_NewHTMLOptionElement(nodeInfo.forget());
|
|
for (uint32_t i = curlen; i < aLength; i++) {
|
|
nsINode::AppendChild(*node, aRv);
|
|
if (aRv.Failed()) {
|
|
return;
|
|
}
|
|
|
|
if (i + 1 < aLength) {
|
|
node = node->CloneNode(true, aRv);
|
|
if (aRv.Failed()) {
|
|
return;
|
|
}
|
|
MOZ_ASSERT(node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
bool HTMLSelectElement::MatchSelectedOptions(Element* aElement,
|
|
int32_t /* unused */,
|
|
nsAtom* /* unused */,
|
|
void* aData) {
|
|
HTMLOptionElement* option = HTMLOptionElement::FromNode(aElement);
|
|
return option &&
|
|
option->GetSelect() == static_cast<HTMLSelectElement*>(aData) &&
|
|
option->Selected();
|
|
}
|
|
|
|
HTMLCollection* HTMLSelectElement::SelectedOptions() {
|
|
if (!mSelectedOptions) {
|
|
mSelectedOptions = new ContentList(this, MatchSelectedOptions, nullptr,
|
|
this, /* deep */ true);
|
|
}
|
|
return mSelectedOptions;
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#option-element-nearest-ancestor-select
|
|
// Generalised to any node, so that the same walk decides the option, optgroup
|
|
// and hr membership of a select's option list.
|
|
/* static */
|
|
auto HTMLSelectElement::ComputeNearestAncestors(const nsINode& aNode)
|
|
-> NearestAncestors {
|
|
// 1. Let ancestorOptgroup be null.
|
|
HTMLOptGroupElement* ancestorOptGroup = nullptr;
|
|
// 2. For each ancestor of element's ancestors, in reverse tree order:
|
|
for (nsINode* ancestor : Ancestors(aNode)) {
|
|
// 2.1. If ancestor is a datalist, hr, or option element, return null.
|
|
if (ancestor->IsAnyOfHTMLElements(nsGkAtoms::datalist, nsGkAtoms::hr,
|
|
nsGkAtoms::option)) {
|
|
return {nullptr, ancestorOptGroup};
|
|
}
|
|
// 2.2. If ancestor is an optgroup element:
|
|
if (auto* optgroup = HTMLOptGroupElement::FromNode(ancestor)) {
|
|
// 2.2.1. If ancestorOptgroup is not null, return null.
|
|
if (ancestorOptGroup) {
|
|
return {nullptr, ancestorOptGroup};
|
|
}
|
|
// 2.2.2. Set ancestorOptgroup to ancestor.
|
|
ancestorOptGroup = optgroup;
|
|
continue;
|
|
}
|
|
// 2.3. If ancestor is a select element, return ancestor.
|
|
if (auto* select = FromNode(ancestor)) {
|
|
return {select, ancestorOptGroup};
|
|
}
|
|
}
|
|
// 3. Return null.
|
|
return {nullptr, ancestorOptGroup};
|
|
}
|
|
|
|
/* static */
|
|
bool HTMLSelectElement::IsOptionListItem(const Element& aElement,
|
|
const nsINode& aRoot) {
|
|
MOZ_ASSERT(aRoot.IsAnyOfHTMLElements(nsGkAtoms::optgroup, nsGkAtoms::select),
|
|
"Why are we providing a non-select/optgroup root?");
|
|
const bool isOptGroup = aElement.IsHTMLElement(nsGkAtoms::optgroup);
|
|
if (!isOptGroup &&
|
|
!aElement.IsAnyOfHTMLElements(nsGkAtoms::option, nsGkAtoms::hr)) {
|
|
return false;
|
|
}
|
|
const auto ancestors = ComputeNearestAncestors(aElement);
|
|
if (const auto* group = HTMLOptGroupElement::FromNode(&aRoot)) {
|
|
// The members of a group. An optgroup never groups another optgroup.
|
|
return !isOptGroup && ancestors.mOptGroup == group;
|
|
}
|
|
// The items of a select that no optgroup groups.
|
|
return ancestors.mSelect == &aRoot && !ancestors.mOptGroup;
|
|
}
|
|
|
|
// Calls `aCallback` for each item of the option list rooted at `aRoot`, in tree
|
|
// order.
|
|
template <typename Callback>
|
|
static void ForEachOptionListItem(nsINode& aRoot, Callback&& aCallback) {
|
|
for (nsIContent* c = aRoot.GetFirstChild(); c; c = c->GetNextNode(&aRoot)) {
|
|
Element* element = Element::FromNode(c);
|
|
if (element && HTMLSelectElement::IsOptionListItem(*element, aRoot)) {
|
|
aCallback(*element);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t HTMLSelectElement::CountRenderedRows() {
|
|
uint32_t count = 0;
|
|
auto countOption = [&count](Element& aItem) {
|
|
if (auto* option = HTMLOptionElement::FromNode(&aItem)) {
|
|
count += !!option->GetPrimaryFrame();
|
|
}
|
|
};
|
|
ForEachOptionListItem(*this, [&](Element& aItem) {
|
|
if (auto* group = HTMLOptGroupElement::FromNode(&aItem)) {
|
|
nsAutoString label;
|
|
group->GetLabel(label);
|
|
// XXX bug 1499176: skip empty <optgroup> labels for now.
|
|
count += !label.IsEmpty();
|
|
ForEachOptionListItem(*group, countOption);
|
|
return;
|
|
}
|
|
countOption(aItem);
|
|
});
|
|
return count;
|
|
}
|
|
|
|
HTMLOptionElement* HTMLSelectElement::GetSelectedOption(
|
|
IgnoredOptionList aIgnored) const {
|
|
uint32_t len = Length();
|
|
for (uint32_t i = 0; i < len; ++i) {
|
|
auto* option = Item(i);
|
|
if (option->Selected() && !aIgnored.Contains(option)) {
|
|
return option;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
int32_t HTMLSelectElement::SelectedIndex() const {
|
|
uint32_t len = Length();
|
|
for (uint32_t i = 0; i < len; ++i) {
|
|
if (Item(i)->Selected()) {
|
|
return static_cast<int32_t>(i);
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void HTMLSelectElement::SetSelectedIndex(int32_t aIdx) {
|
|
SetSelectedIndexInternal(aIdx, true);
|
|
// https://html.spec.whatwg.org/#dom-select-selectedindex
|
|
// Step 4: Run update a select's descendant selectedcontent elements.
|
|
ScheduleSelectedContentUpdate(SelectedContentUpdateMode::ScriptRunner,
|
|
/* aForceUpdate = */ true);
|
|
}
|
|
|
|
void HTMLSelectElement::ScrollToOption(int32_t aIndex) {
|
|
if (aIndex < 0) {
|
|
return;
|
|
}
|
|
OwnerDoc()->Dispatch(
|
|
NewRunnableMethod<int32_t>("HTMLSelectElement::DoScrollToOption", this,
|
|
&HTMLSelectElement::DoScrollToOption, aIndex));
|
|
}
|
|
|
|
void HTMLSelectElement::DoScrollToOption(int32_t aIndex) {
|
|
RefPtr option = Item(aIndex);
|
|
if (!option) {
|
|
return;
|
|
}
|
|
if (nsIFrame* childFrame = option->GetPrimaryFrame()) {
|
|
RefPtr<mozilla::PresShell> presShell = childFrame->PresShell();
|
|
presShell->ScrollFrameIntoView(childFrame, Nothing(), AxisScrollParams(),
|
|
AxisScrollParams(),
|
|
ScrollFlags::ScrollOverflowHidden |
|
|
ScrollFlags::ScrollFirstAncestorOnly);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::SetSelectedIndexInternal(int32_t aIndex, bool aNotify) {
|
|
OptionFlags mask{OptionFlag::IsSelected, OptionFlag::ClearAll,
|
|
OptionFlag::SetDisabled};
|
|
if (aNotify) {
|
|
mask += OptionFlag::Notify;
|
|
}
|
|
SetOptionsSelectedByIndex(aIndex, aIndex, mask);
|
|
if (!IsCombobox()) {
|
|
#ifdef ACCESSIBILITY
|
|
nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
|
|
#endif
|
|
mListBoxSelection.SetTo(Item(aIndex));
|
|
if (nsListControlFrame* listBox = GetListBoxFrame()) {
|
|
listBox->InvalidateFocus();
|
|
}
|
|
ScrollToOption(aIndex);
|
|
#ifdef ACCESSIBILITY
|
|
MaybeFireMenuItemActiveEvent(prevOption);
|
|
#endif
|
|
}
|
|
|
|
OnSelectionChanged();
|
|
}
|
|
|
|
bool HTMLSelectElement::IsOptionSelectedByIndex(int32_t aIndex) const {
|
|
HTMLOptionElement* option = Item(static_cast<uint32_t>(aIndex));
|
|
return option && option->Selected();
|
|
}
|
|
|
|
void HTMLSelectElement::OnOptionSelected(int32_t aIndex, bool aSelected,
|
|
bool aChangeOptionState,
|
|
bool aNotify) {
|
|
if (aChangeOptionState) {
|
|
// Tell the option to get its bad self selected
|
|
if (RefPtr option = Item(static_cast<uint32_t>(aIndex))) {
|
|
option->SetSelectedInternal(aSelected, aNotify);
|
|
}
|
|
}
|
|
|
|
OnSelectionChanged();
|
|
|
|
if (aSelected && !IsCombobox()) {
|
|
ScrollToOption(aIndex);
|
|
}
|
|
|
|
#ifdef ACCESSIBILITY
|
|
if (nsAccessibilityService* acc = GetAccService(); acc && IsCombobox()) {
|
|
acc->ComboboxValueChanged(this);
|
|
}
|
|
#endif
|
|
|
|
UpdateSelectedOptions();
|
|
UpdateValueMissingValidityState();
|
|
UpdateValidityElementStates(aNotify);
|
|
}
|
|
|
|
// XXX Consider splitting this into two functions for ease of reading:
|
|
// SelectOptionsByIndex(startIndex, endIndex, clearAll, checkDisabled)
|
|
// startIndex, endIndex - the range of options to turn on
|
|
// (-1, -1) will clear all indices no matter what.
|
|
// clearAll - will clear all other options unless checkDisabled is on
|
|
// and all the options attempted to be set are disabled
|
|
// (note that if it is not multiple, and an option is selected,
|
|
// everything else will be cleared regardless).
|
|
// checkDisabled - if this is TRUE, and an option is disabled, it will not be
|
|
// changed regardless of whether it is selected or not.
|
|
// Generally the UI passes TRUE and JS passes FALSE.
|
|
// (setDisabled currently is the opposite)
|
|
// DeselectOptionsByIndex(startIndex, endIndex, checkDisabled)
|
|
// startIndex, endIndex - the range of options to turn on
|
|
// (-1, -1) will clear all indices no matter what.
|
|
// checkDisabled - if this is TRUE, and an option is disabled, it will not be
|
|
// changed regardless of whether it is selected or not.
|
|
// Generally the UI passes TRUE and JS passes FALSE.
|
|
// (setDisabled currently is the opposite)
|
|
//
|
|
// XXXbz the above comment is pretty confusing. Maybe we should actually
|
|
// document the args to this function too, in addition to documenting what
|
|
// things might end up looking like? In particular, pay attention to the
|
|
// setDisabled vs checkDisabled business.
|
|
bool HTMLSelectElement::SetOptionsSelectedByIndex(int32_t aStartIndex,
|
|
int32_t aEndIndex,
|
|
OptionFlags aOptionsMask) {
|
|
#if 0
|
|
printf("SetOption(%d-%d, %c, ClearAll=%c)\n", aStartIndex, aEndIndex,
|
|
(aOptionsMask.contains(OptionFlag::IsSelected) ? 'Y' : 'N'),
|
|
(aOptionsMask.contains(OptionFlag::ClearAll) ? 'Y' : 'N'));
|
|
#endif
|
|
// Don't bother if the select is disabled
|
|
if (!aOptionsMask.contains(OptionFlag::SetDisabled) && IsDisabled()) {
|
|
return false;
|
|
}
|
|
|
|
// Don't bother if there are no options
|
|
uint32_t numItems = Length();
|
|
if (numItems == 0) {
|
|
return false;
|
|
}
|
|
|
|
// First, find out whether multiple items can be selected
|
|
bool isMultiple = Multiple();
|
|
|
|
// These variables tell us whether any options were selected
|
|
// or deselected.
|
|
bool optionsSelected = false;
|
|
bool optionsDeselected = false;
|
|
|
|
if (aOptionsMask.contains(OptionFlag::IsSelected)) {
|
|
// Setting selectedIndex to an out-of-bounds index means -1. (HTML5)
|
|
if (aStartIndex < 0 || AssertedCast<uint32_t>(aStartIndex) >= numItems ||
|
|
aEndIndex < 0 || AssertedCast<uint32_t>(aEndIndex) >= numItems) {
|
|
aStartIndex = -1;
|
|
aEndIndex = -1;
|
|
}
|
|
|
|
// Only select the first value if it's not multiple
|
|
if (!isMultiple) {
|
|
aEndIndex = aStartIndex;
|
|
}
|
|
|
|
// This variable tells whether or not all of the options we attempted to
|
|
// select are disabled. If ClearAll is passed in as true, and we do not
|
|
// select anything because the options are disabled, we will not clear the
|
|
// other options. (This is to make the UI work the way one might expect.)
|
|
bool allDisabled = !aOptionsMask.contains(OptionFlag::SetDisabled);
|
|
|
|
//
|
|
// Select the requested indices
|
|
//
|
|
// If index is -1, everything will be deselected (bug 28143)
|
|
if (aStartIndex != -1) {
|
|
MOZ_ASSERT(aStartIndex >= 0);
|
|
MOZ_ASSERT(aEndIndex >= 0);
|
|
// Loop through the options and select them (if they are not disabled and
|
|
// if they are not already selected).
|
|
for (uint32_t optIndex = AssertedCast<uint32_t>(aStartIndex);
|
|
optIndex <= AssertedCast<uint32_t>(aEndIndex); optIndex++) {
|
|
RefPtr<HTMLOptionElement> option = Item(optIndex);
|
|
|
|
// Ignore disabled options.
|
|
if (!aOptionsMask.contains(OptionFlag::SetDisabled)) {
|
|
if (option && IsOptionDisabled(option)) {
|
|
continue;
|
|
}
|
|
allDisabled = false;
|
|
}
|
|
|
|
// If the index is already selected, ignore it. On the other hand when
|
|
// the option has just been inserted we have to get in sync with it.
|
|
if (option && (aOptionsMask.contains(OptionFlag::InsertingOptions) ||
|
|
!option->Selected())) {
|
|
OnOptionSelected(optIndex, true, !option->Selected(),
|
|
aOptionsMask.contains(OptionFlag::Notify));
|
|
optionsSelected = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Next remove all other options if single select or all is clear
|
|
// If index is -1, everything will be deselected (bug 28143)
|
|
if (((!isMultiple && optionsSelected) ||
|
|
(aOptionsMask.contains(OptionFlag::ClearAll) && !allDisabled) ||
|
|
aStartIndex == -1)) {
|
|
for (uint32_t optIndex = 0; optIndex < numItems; optIndex++) {
|
|
if (static_cast<int32_t>(optIndex) < aStartIndex ||
|
|
static_cast<int32_t>(optIndex) > aEndIndex) {
|
|
HTMLOptionElement* option = Item(optIndex);
|
|
// If the index is already deselected, ignore it.
|
|
if (option && option->Selected()) {
|
|
OnOptionSelected(optIndex, false, true,
|
|
aOptionsMask.contains(OptionFlag::Notify));
|
|
optionsDeselected = true;
|
|
|
|
// Only need to deselect one option if not multiple, or if we're
|
|
// inserting options (if multiple of the options we're inserting are
|
|
// selected we need to deselect them all but one).
|
|
if (!isMultiple &&
|
|
!aOptionsMask.contains(OptionFlag::InsertingOptions)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// If we're deselecting, loop through all selected items and deselect
|
|
// any that are in the specified range.
|
|
for (int32_t optIndex = aStartIndex; optIndex <= aEndIndex; optIndex++) {
|
|
HTMLOptionElement* option = Item(optIndex);
|
|
if (!aOptionsMask.contains(OptionFlag::SetDisabled) &&
|
|
IsOptionDisabled(option)) {
|
|
continue;
|
|
}
|
|
|
|
// If the index is already selected, ignore it.
|
|
if (option->Selected()) {
|
|
OnOptionSelected(optIndex, false, true,
|
|
aOptionsMask.contains(OptionFlag::Notify));
|
|
optionsDeselected = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure something is selected unless we were set to -1 (none)
|
|
if (optionsDeselected && aStartIndex != -1 &&
|
|
!aOptionsMask.contains(OptionFlag::NoReselect)) {
|
|
RunSelectednessSettingAlgorithm(aOptionsMask.contains(OptionFlag::Notify));
|
|
}
|
|
|
|
// Let the caller know whether anything was changed
|
|
return optionsSelected || optionsDeselected;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLSelectElement::IsOptionDisabled(int32_t aIndex, bool* aIsDisabled) {
|
|
*aIsDisabled = false;
|
|
RefPtr<HTMLOptionElement> option = Item(aIndex);
|
|
NS_ENSURE_TRUE(option, NS_ERROR_FAILURE);
|
|
|
|
*aIsDisabled = IsOptionDisabled(option);
|
|
return NS_OK;
|
|
}
|
|
|
|
bool HTMLSelectElement::IsOptionDisabled(HTMLOptionElement* aOption) const {
|
|
MOZ_ASSERT(aOption);
|
|
if (aOption->Disabled()) {
|
|
return true;
|
|
}
|
|
// https://html.spec.whatwg.org/#concept-option-disabled
|
|
auto* optgroup = ComputeNearestAncestors(*aOption).mOptGroup;
|
|
return optgroup && optgroup->Disabled();
|
|
}
|
|
|
|
void HTMLSelectElement::GetValue(nsAString& aValue) const {
|
|
int32_t selectedIndex = SelectedIndex();
|
|
if (selectedIndex < 0) {
|
|
return;
|
|
}
|
|
|
|
RefPtr<HTMLOptionElement> option = Item(static_cast<uint32_t>(selectedIndex));
|
|
|
|
if (!option) {
|
|
return;
|
|
}
|
|
|
|
option->GetValue(aValue);
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#dom-select-value
|
|
void HTMLSelectElement::SetValue(const nsAString& aValue) {
|
|
uint32_t length = Length();
|
|
int32_t matchIndex = -1;
|
|
for (uint32_t i = 0; i < length; i++) {
|
|
RefPtr<HTMLOptionElement> option = Item(i);
|
|
if (!option) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoString optionVal;
|
|
option->GetValue(optionVal);
|
|
if (optionVal.Equals(aValue)) {
|
|
matchIndex = int32_t(i);
|
|
break;
|
|
}
|
|
}
|
|
SetSelectedIndexInternal(matchIndex, true);
|
|
// https://html.spec.whatwg.org/#dom-select-value
|
|
// Step 4: Run update a select's descendant selectedcontent elements.
|
|
ScheduleSelectedContentUpdate(SelectedContentUpdateMode::ScriptRunner,
|
|
/* aForceUpdate = */ true);
|
|
}
|
|
|
|
int32_t HTMLSelectElement::TabIndexDefault() { return 0; }
|
|
|
|
bool HTMLSelectElement::IsHTMLFocusable(IsFocusableFlags aFlags,
|
|
bool* aIsFocusable,
|
|
int32_t* aTabIndex) {
|
|
if (nsGenericHTMLFormControlElementWithState::IsHTMLFocusable(
|
|
aFlags, aIsFocusable, aTabIndex)) {
|
|
return true;
|
|
}
|
|
|
|
*aIsFocusable = !IsDisabled();
|
|
|
|
return false;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::BindToTree(BindContext& aContext,
|
|
nsINode& aParent) {
|
|
MOZ_TRY(
|
|
nsGenericHTMLFormControlElementWithState::BindToTree(aContext, aParent));
|
|
|
|
// If there is a disabled fieldset in the parent chain, the element is now
|
|
// barred from constraint validation.
|
|
// XXXbz is this still needed now that fieldset changes always call
|
|
// FieldSetDisabledChanged?
|
|
UpdateBarredFromConstraintValidation();
|
|
|
|
// And now make sure our state is up to date
|
|
UpdateValidityElementStates(false);
|
|
|
|
if (IsInComposedDoc()) {
|
|
if (!GetShadowRoot()) {
|
|
SetupShadowTree();
|
|
}
|
|
SelectedContentTextMightHaveChanged(false);
|
|
ScheduleSelectedContentUpdate();
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void HTMLSelectElement::UnbindFromTree(UnbindContext& aContext) {
|
|
// We don't bother clearing up the shadow tree here if we already have it
|
|
// around.
|
|
nsGenericHTMLFormControlElementWithState::UnbindFromTree(aContext);
|
|
|
|
// We might be no longer disabled because our parent chain changed.
|
|
// XXXbz is this still needed now that fieldset changes always call
|
|
// FieldSetDisabledChanged?
|
|
UpdateBarredFromConstraintValidation();
|
|
|
|
// And now make sure our state is up to date
|
|
UpdateValidityElementStates(false);
|
|
}
|
|
|
|
void HTMLSelectElement::BeforeSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue, bool aNotify) {
|
|
if (aNameSpaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::disabled) {
|
|
if (aNotify) {
|
|
mDisabledChanged = true;
|
|
}
|
|
} else if (aName == nsGkAtoms::multiple) {
|
|
if (!aValue && aNotify) {
|
|
// We're changing from being a multi-select to a single-select.
|
|
// Make sure we only have one option selected before we do that.
|
|
// Note that this needs to come before we really unset the attr,
|
|
// since SetOptionsSelectedByIndex does some bail-out type
|
|
// optimization for cases when the select is not multiple that
|
|
// would lead to only a single option getting deselected.
|
|
SetSelectedIndexInternal(SelectedIndex(), aNotify);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLFormControlElementWithState::BeforeSetAttr(
|
|
aNameSpaceID, aName, aValue, aNotify);
|
|
}
|
|
|
|
void HTMLSelectElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue,
|
|
nsIPrincipal* aSubjectPrincipal,
|
|
bool aNotify) {
|
|
if (aNameSpaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::disabled) {
|
|
// This *has* to be called *before* validity state check because
|
|
// UpdateBarredFromConstraintValidation and
|
|
// UpdateValueMissingValidityState depend on our disabled state.
|
|
UpdateDisabledState(aNotify);
|
|
|
|
UpdateValueMissingValidityState();
|
|
UpdateBarredFromConstraintValidation();
|
|
UpdateValidityElementStates(aNotify);
|
|
} else if (aName == nsGkAtoms::required) {
|
|
// This *has* to be called *before* UpdateValueMissingValidityState
|
|
// because UpdateValueMissingValidityState depends on our required
|
|
// state.
|
|
UpdateRequiredState(!!aValue, aNotify);
|
|
UpdateValueMissingValidityState();
|
|
UpdateValidityElementStates(aNotify);
|
|
} else if (aName == nsGkAtoms::autocomplete) {
|
|
// Clear the cached @autocomplete attribute and autocompleteInfo state.
|
|
mAutocompleteAttrState = nsContentUtils::eAutocompleteAttrState_Unknown;
|
|
mAutocompleteInfoState = nsContentUtils::eAutocompleteAttrState_Unknown;
|
|
} else if (aName == nsGkAtoms::multiple) {
|
|
if (!aValue && aNotify) {
|
|
// We might have become a combobox; make sure _something_ gets
|
|
// selected in that case
|
|
RunSelectednessSettingAlgorithm(aNotify);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLFormControlElementWithState::AfterSetAttr(
|
|
aNameSpaceID, aName, aValue, aOldValue, aSubjectPrincipal, aNotify);
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#selectedness-setting-algorithm
|
|
void HTMLSelectElement::RunSelectednessSettingAlgorithm(
|
|
bool aNotify, bool aSkipSelectedcontentUpdate, IgnoredOptionList aIgnored) {
|
|
// 1. If element has the multiple attribute, then return.
|
|
if (Multiple()) {
|
|
UpdateValueMissingValidityState(aIgnored);
|
|
UpdateValidityElementStates(aNotify);
|
|
return;
|
|
}
|
|
// 2. Let updateSelectedcontent be false.
|
|
bool updateSelectedcontent = false;
|
|
// 3. Let firstEnabledOption be null.
|
|
RefPtr<HTMLOptionElement> firstEnabledOption;
|
|
// 4. Let lastSelectedOption be null.
|
|
RefPtr<HTMLOptionElement> lastSelectedOption;
|
|
|
|
// 5. For each option of element's list of options:
|
|
const uint32_t count = Length();
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
RefPtr<HTMLOptionElement> option = Item(i);
|
|
if (!option || aIgnored.Contains(option)) {
|
|
continue;
|
|
}
|
|
// 5.1. If option's selectedness is true:
|
|
if (option->Selected()) {
|
|
// 5.1.1. If lastSelectedOption is not null:
|
|
if (lastSelectedOption) {
|
|
// 5.1.1.1. Set lastSelectedOption's selectedness to false.
|
|
lastSelectedOption->SetSelectedInternal(false, aNotify);
|
|
// 5.1.1.2. Set updateSelectedcontent to true.
|
|
updateSelectedcontent = true;
|
|
}
|
|
// 5.1.2. Set lastSelectedOption to option.
|
|
lastSelectedOption = option;
|
|
}
|
|
// 5.2. If firstEnabledOption is null and option is not disabled, then
|
|
// set firstEnabledOption to option.
|
|
if (!firstEnabledOption && !IsOptionDisabled(option)) {
|
|
firstEnabledOption = option;
|
|
}
|
|
}
|
|
|
|
// 6. If lastSelectedOption is null and firstEnabledOption is not null and
|
|
// element's display size is 1:
|
|
if (!lastSelectedOption && Size() <= 1 && firstEnabledOption) {
|
|
// 6.1. Set firstEnabledOption's selectedness to true.
|
|
firstEnabledOption->SetSelectedInternal(true, aNotify);
|
|
// 6.2. Set updateSelectedcontent to true.
|
|
updateSelectedcontent = true;
|
|
}
|
|
|
|
if (updateSelectedcontent) {
|
|
OnSelectionChanged();
|
|
}
|
|
UpdateValueMissingValidityState(aIgnored);
|
|
UpdateValidityElementStates(aNotify);
|
|
|
|
// 7. If updateSelectedcontent is true and skipSelectedcontentUpdate is
|
|
// false, then update a select's descendant selectedcontent elements
|
|
// given element.
|
|
// NOTE: Callers pass true from insertion/removal steps, where the update is
|
|
// handled separately (post-connection steps for insertion, a queued
|
|
// microtask for removal).
|
|
if (updateSelectedcontent && !aSkipSelectedcontentUpdate) {
|
|
ScheduleSelectedContentUpdate();
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::DoneAddingChildren(bool aHaveNotified) {
|
|
mIsDoneAddingChildren = true;
|
|
|
|
// PrototypeDocumentContentSink and innerHTML (and maybe XMLContentSink?) may
|
|
// not notify for all children during parsing, so mark the options list dirty
|
|
// at this point.
|
|
mOptions->SetDirty();
|
|
|
|
if (nsIContent* firstChild = GetFirstChild()) {
|
|
ContentAppendedOrInserted(firstChild, /* aIsAppend = */ true);
|
|
}
|
|
|
|
// If we foolishly tried to restore before we were done adding
|
|
// content, restore the rest of the options proper-like
|
|
if (mRestoreState) {
|
|
RestoreStateTo(*mRestoreState);
|
|
mRestoreState = nullptr;
|
|
}
|
|
|
|
// Notify the frame
|
|
ResetListBoxSelection(/* aAllowScrolling = */ true);
|
|
|
|
if (!mInhibitStateRestoration) {
|
|
GenerateStateKey();
|
|
RestoreFormControlState();
|
|
}
|
|
|
|
mDefaultSelectionSet = true;
|
|
}
|
|
|
|
bool HTMLSelectElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
|
|
const nsAString& aValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
nsAttrValue& aResult) {
|
|
if (kNameSpaceID_None == aNamespaceID) {
|
|
if (aAttribute == nsGkAtoms::size) {
|
|
return aResult.ParsePositiveIntValue(aValue);
|
|
}
|
|
if (aAttribute == nsGkAtoms::autocomplete) {
|
|
aResult.ParseAtomArray(aValue);
|
|
return true;
|
|
}
|
|
}
|
|
return nsGenericHTMLFormControlElementWithState::ParseAttribute(
|
|
aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult);
|
|
}
|
|
|
|
void HTMLSelectElement::MapAttributesIntoRule(
|
|
MappedDeclarationsBuilder& aBuilder) {
|
|
nsGenericHTMLFormControlElementWithState::MapImageAlignAttributeInto(
|
|
aBuilder);
|
|
nsGenericHTMLFormControlElementWithState::MapCommonAttributesInto(aBuilder);
|
|
}
|
|
|
|
nsChangeHint HTMLSelectElement::GetAttributeChangeHint(
|
|
const nsAtom* aAttribute, AttrModType aModType) const {
|
|
nsChangeHint retval =
|
|
nsGenericHTMLFormControlElementWithState::GetAttributeChangeHint(
|
|
aAttribute, aModType);
|
|
if (aAttribute == nsGkAtoms::multiple || aAttribute == nsGkAtoms::size) {
|
|
retval |= nsChangeHint_ReconstructFrame;
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
bool HTMLSelectElement::IsNoNamespaceAttrMapped(
|
|
const nsAtom* aAttribute) const {
|
|
static const MappedAttributeEntry* const map[] = {sCommonAttributeMap,
|
|
sImageAlignAttributeMap};
|
|
|
|
return FindAttributeDependence(aAttribute, map);
|
|
}
|
|
|
|
nsMapRuleToAttributesFunc HTMLSelectElement::GetAttributeMappingFunction()
|
|
const {
|
|
return &MapAttributesIntoRule;
|
|
}
|
|
|
|
bool HTMLSelectElement::IsDisabledForEvents(WidgetEvent* aEvent) {
|
|
return IsElementDisabledForEvents(aEvent, GetPrimaryFrame());
|
|
}
|
|
|
|
void HTMLSelectElement::GetEventTargetParent(EventChainPreVisitor& aVisitor) {
|
|
aVisitor.mCanHandle = false;
|
|
if (IsDisabledForEvents(aVisitor.mEvent)) {
|
|
return;
|
|
}
|
|
|
|
nsGenericHTMLFormControlElementWithState::GetEventTargetParent(aVisitor);
|
|
}
|
|
|
|
void HTMLSelectElement::UpdateValidityElementStates(bool aNotify) {
|
|
AutoStateChangeNotifier notifier(*this, aNotify);
|
|
RemoveStatesSilently(ElementState::VALIDITY_STATES);
|
|
if (!IsCandidateForConstraintValidation()) {
|
|
return;
|
|
}
|
|
|
|
ElementState state;
|
|
if (IsValid()) {
|
|
state |= ElementState::VALID;
|
|
if (mUserInteracted) {
|
|
state |= ElementState::USER_VALID;
|
|
}
|
|
} else {
|
|
state |= ElementState::INVALID;
|
|
if (mUserInteracted) {
|
|
state |= ElementState::USER_INVALID;
|
|
}
|
|
}
|
|
|
|
AddStatesSilently(state);
|
|
}
|
|
|
|
void HTMLSelectElement::SaveState() {
|
|
PresState* presState = GetPrimaryPresState();
|
|
if (!presState) {
|
|
return;
|
|
}
|
|
|
|
SelectContentData state;
|
|
|
|
uint32_t len = Length();
|
|
|
|
for (uint32_t optIndex = 0; optIndex < len; optIndex++) {
|
|
HTMLOptionElement* option = Item(optIndex);
|
|
if (option && option->Selected()) {
|
|
nsAutoString value;
|
|
option->GetValue(value);
|
|
if (value.IsEmpty()) {
|
|
state.indices().AppendElement(optIndex);
|
|
} else {
|
|
state.values().AppendElement(std::move(value));
|
|
}
|
|
}
|
|
}
|
|
|
|
presState->contentData() = std::move(state);
|
|
|
|
if (mDisabledChanged) {
|
|
// We do not want to save the real disabled state but the disabled
|
|
// attribute.
|
|
presState->disabled() = HasAttr(nsGkAtoms::disabled);
|
|
presState->disabledSet() = true;
|
|
}
|
|
}
|
|
|
|
bool HTMLSelectElement::RestoreState(PresState* aState) {
|
|
// Get the presentation state object to retrieve our stuff out of.
|
|
const PresContentData& state = aState->contentData();
|
|
if (state.type() == PresContentData::TSelectContentData) {
|
|
RestoreStateTo(state.get_SelectContentData());
|
|
ResetListBoxSelection(/* aAllowScrolling = */ true);
|
|
}
|
|
|
|
if (aState->disabledSet() && !aState->disabled()) {
|
|
SetDisabled(false, IgnoreErrors());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void HTMLSelectElement::RestoreStateTo(const SelectContentData& aNewSelected) {
|
|
if (!mIsDoneAddingChildren) {
|
|
// Make a copy of the state for us to restore from in the future.
|
|
mRestoreState = MakeUnique<SelectContentData>(aNewSelected);
|
|
return;
|
|
}
|
|
|
|
uint32_t len = Length();
|
|
OptionFlags mask{OptionFlag::IsSelected, OptionFlag::ClearAll,
|
|
OptionFlag::SetDisabled, OptionFlag::Notify};
|
|
|
|
// First clear all
|
|
SetOptionsSelectedByIndex(-1, -1, mask);
|
|
|
|
// Select by index.
|
|
for (uint32_t idx : aNewSelected.indices()) {
|
|
if (idx < len) {
|
|
SetOptionsSelectedByIndex(idx, idx,
|
|
{OptionFlag::IsSelected,
|
|
OptionFlag::SetDisabled, OptionFlag::Notify});
|
|
}
|
|
}
|
|
|
|
// Select by value.
|
|
for (uint32_t i = 0; i < len; ++i) {
|
|
HTMLOptionElement* option = Item(i);
|
|
if (option) {
|
|
nsAutoString value;
|
|
option->GetValue(value);
|
|
if (aNewSelected.values().Contains(value)) {
|
|
SetOptionsSelectedByIndex(
|
|
i, i,
|
|
{OptionFlag::IsSelected, OptionFlag::SetDisabled,
|
|
OptionFlag::Notify});
|
|
}
|
|
}
|
|
}
|
|
|
|
RunSelectednessSettingAlgorithm();
|
|
ScheduleSelectedContentUpdate();
|
|
}
|
|
|
|
// nsIFormControl
|
|
|
|
NS_IMETHODIMP
|
|
HTMLSelectElement::Reset() {
|
|
//
|
|
// Cycle through the options array and reset the options
|
|
//
|
|
uint32_t numOptions = Length();
|
|
|
|
for (uint32_t i = 0; i < numOptions; i++) {
|
|
RefPtr<HTMLOptionElement> option = Item(i);
|
|
if (option) {
|
|
//
|
|
// Reset the option to its default value
|
|
//
|
|
|
|
OptionFlags mask = {OptionFlag::SetDisabled, OptionFlag::Notify,
|
|
OptionFlag::NoReselect};
|
|
if (option->DefaultSelected()) {
|
|
mask += OptionFlag::IsSelected;
|
|
}
|
|
|
|
SetOptionsSelectedByIndex(i, i, mask);
|
|
option->SetSelectedChanged(false);
|
|
}
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#concept-form-reset-control step 3
|
|
RunSelectednessSettingAlgorithm();
|
|
|
|
OnSelectionChanged();
|
|
SetUserInteracted(false);
|
|
ResetListBoxSelection(/* aAllowScrolling = */ true);
|
|
|
|
// https://html.spec.whatwg.org/#update-a-select's-descendant-selectedcontent-elements
|
|
UpdateDescendantSelectedContentElements();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
HTMLSelectElement::SubmitNamesValues(FormData* aFormData) {
|
|
//
|
|
// Get the name (if no name, no submit)
|
|
//
|
|
nsAutoString name;
|
|
GetAttr(nsGkAtoms::name, name);
|
|
if (name.IsEmpty()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
//
|
|
// Submit
|
|
//
|
|
uint32_t len = Length();
|
|
|
|
for (uint32_t optIndex = 0; optIndex < len; optIndex++) {
|
|
HTMLOptionElement* option = Item(optIndex);
|
|
|
|
// Don't send disabled options
|
|
if (!option || IsOptionDisabled(option)) {
|
|
continue;
|
|
}
|
|
|
|
if (!option->Selected()) {
|
|
continue;
|
|
}
|
|
|
|
nsString value;
|
|
option->GetValue(value);
|
|
|
|
aFormData->AddNameValuePair(name, value);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void HTMLSelectElement::ResetListBoxSelection(bool aAllowScrolling) {
|
|
if (!IsDoneAddingChildren() || IsCombobox()) {
|
|
return;
|
|
}
|
|
mListBoxSelection.Clear();
|
|
if (nsListControlFrame* listFrame = GetListBoxFrame()) {
|
|
listFrame->OnSelectionReset();
|
|
}
|
|
if (aAllowScrolling) {
|
|
ScrollToSelectedOption();
|
|
}
|
|
}
|
|
|
|
bool HTMLSelectElement::IsValueMissing(IgnoredOptionList aIgnored) const {
|
|
if (!Required()) {
|
|
return false;
|
|
}
|
|
|
|
uint32_t length = Length();
|
|
|
|
bool first = true;
|
|
for (uint32_t i = 0; i < length; ++i) {
|
|
RefPtr<HTMLOptionElement> option = Item(i);
|
|
// Check for a placeholder label option, don't count it as a valid value.
|
|
if (first) {
|
|
if (aIgnored.Contains(option)) {
|
|
// We need to eagerly check for aIgnored to keep `first` correct,
|
|
// effectively.
|
|
continue;
|
|
}
|
|
first = false;
|
|
// https://html.spec.whatwg.org/#placeholder-label-option
|
|
// The option must be in our option list directly, rather than via an
|
|
// optgroup. Wrapper elements are transparent.
|
|
if (IsCombobox() && !ComputeNearestAncestors(*option).mOptGroup) {
|
|
nsAutoString value;
|
|
option->GetValue(value);
|
|
if (value.IsEmpty()) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if (!option->Selected() || aIgnored.Contains(option)) {
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void HTMLSelectElement::UpdateValueMissingValidityState(
|
|
IgnoredOptionList aIgnored) {
|
|
SetValidityState(VALIDITY_STATE_VALUE_MISSING, IsValueMissing(aIgnored));
|
|
}
|
|
|
|
nsresult HTMLSelectElement::GetValidationMessage(nsAString& aValidationMessage,
|
|
ValidityStateType aType) {
|
|
switch (aType) {
|
|
case VALIDITY_STATE_VALUE_MISSING: {
|
|
nsAutoString message;
|
|
nsresult rv = nsContentUtils::GetMaybeLocalizedString(
|
|
PropertiesFile::DOM_PROPERTIES, "FormValidationSelectMissing",
|
|
OwnerDoc(), message);
|
|
aValidationMessage = std::move(message);
|
|
return rv;
|
|
}
|
|
default: {
|
|
return ConstraintValidation::GetValidationMessage(aValidationMessage,
|
|
aType);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::UpdateBarredFromConstraintValidation() {
|
|
SetBarredFromConstraintValidation(
|
|
HasFlag(ELEMENT_IS_DATALIST_OR_HAS_DATALIST_ANCESTOR) || IsDisabled());
|
|
}
|
|
|
|
void HTMLSelectElement::FieldSetDisabledChanged(bool aNotify) {
|
|
// This *has* to be called before UpdateBarredFromConstraintValidation and
|
|
// UpdateValueMissingValidityState because these two functions depend on our
|
|
// disabled state.
|
|
nsGenericHTMLFormControlElementWithState::FieldSetDisabledChanged(aNotify);
|
|
|
|
UpdateValueMissingValidityState();
|
|
UpdateBarredFromConstraintValidation();
|
|
UpdateValidityElementStates(aNotify);
|
|
}
|
|
|
|
void HTMLSelectElement::OnSelectionChanged() {
|
|
SelectedContentTextMightHaveChanged();
|
|
if (!mDefaultSelectionSet) {
|
|
return;
|
|
}
|
|
|
|
if (State().HasState(ElementState::AUTOFILL)) {
|
|
RemoveStates(ElementState::AUTOFILL | ElementState::AUTOFILL_PREVIEW);
|
|
}
|
|
|
|
UpdateSelectedOptions();
|
|
}
|
|
|
|
void HTMLSelectElement::UpdateSelectedOptions() {
|
|
if (mSelectedOptions) {
|
|
mSelectedOptions->SetDirty();
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::SetUserInteracted(bool aInteracted) {
|
|
if (mUserInteracted == aInteracted) {
|
|
return;
|
|
}
|
|
mUserInteracted = aInteracted;
|
|
UpdateValidityElementStates(true);
|
|
}
|
|
|
|
void HTMLSelectElement::SetPreviewValue(const nsAString& aValue) {
|
|
mPreviewValue = aValue;
|
|
nsContentUtils::RemoveNewlines(mPreviewValue);
|
|
SelectedContentTextMightHaveChanged();
|
|
}
|
|
|
|
static void OptionValueMightHaveChanged(nsIContent* aMutatingNode) {
|
|
#ifdef ACCESSIBILITY
|
|
if (nsAccessibilityService* acc = GetAccService()) {
|
|
acc->ComboboxOptionMaybeChanged(aMutatingNode->OwnerDoc()->GetPresShell(),
|
|
aMutatingNode);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void HTMLSelectElement::SelectedContentTextMightHaveChanged(
|
|
bool aNotify, IgnoredOptionList aIgnored) {
|
|
RefPtr textNode = GetSelectedContentText();
|
|
if (!textNode) {
|
|
return;
|
|
}
|
|
nsAutoString newText;
|
|
if (!mPreviewValue.IsEmpty()) {
|
|
newText.Assign(mPreviewValue);
|
|
} else if (auto* selectedOption = GetSelectedOption(aIgnored)) {
|
|
selectedOption->GetRenderedLabel(newText);
|
|
}
|
|
ButtonControlFrame::EnsureNonEmptyLabel(newText);
|
|
textNode->SetText(newText, aNotify);
|
|
#ifdef ACCESSIBILITY
|
|
if (nsAccessibilityService* acc = GetAccService()) {
|
|
if (nsIFrame* f = GetPrimaryFrame()) {
|
|
acc->ScheduleAccessibilitySubtreeUpdate(f->PresShell(), this);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#send-select-update-notifications
|
|
void HTMLSelectElement::UserFinishedInteracting(bool aChanged) {
|
|
// 1. Set element's user validity to true.
|
|
SetUserInteracted(true);
|
|
if (!aChanged) {
|
|
return;
|
|
}
|
|
|
|
// 2. Run update a select's descendant selectedcontent elements given element.
|
|
UpdateDescendantSelectedContentElements();
|
|
|
|
// 3. Run clone selected option into select button given element.
|
|
SelectedContentTextMightHaveChanged();
|
|
|
|
// 4. Fire an event named input at element, with the bubbles and composed
|
|
// attributes initialized to true.
|
|
DebugOnly<nsresult> rvIgnored = nsContentUtils::DispatchInputEvent(this);
|
|
NS_WARNING_ASSERTION(NS_SUCCEEDED(rvIgnored),
|
|
"Failed to dispatch input event");
|
|
|
|
// 5. Fire an event named change at element, with the bubbles attribute
|
|
// initialized to true.
|
|
nsContentUtils::DispatchTrustedEvent(this, u"change"_ns, CanBubble::eYes,
|
|
Cancelable::eNo);
|
|
}
|
|
|
|
void HTMLSelectElement::AttributeChanged(dom::Element* aElement,
|
|
int32_t aNameSpaceID,
|
|
nsAtom* aAttribute, AttrModType,
|
|
const nsAttrValue* aOldValue) {
|
|
if (aElement->IsHTMLElement(nsGkAtoms::option) &&
|
|
aNameSpaceID == kNameSpaceID_None && aAttribute == nsGkAtoms::label) {
|
|
// A11y has its own mutation listener for this so no need to do
|
|
// OptionValueMightHaveChanged().
|
|
SelectedContentTextMightHaveChanged();
|
|
if (!mIsUpdatingSelectedContent) {
|
|
ScheduleSelectedContentUpdate();
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool InsideSelectedOption(nsIContent* aContent,
|
|
HTMLSelectElement* aLimit) {
|
|
for (nsIContent* cur = aContent->GetParent(); cur != aLimit;
|
|
cur = cur->GetParent()) {
|
|
if (auto* option = HTMLOptionElement::FromNode(cur)) {
|
|
return option->Selected();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void HTMLSelectElement::CharacterDataChanged(nsIContent* aContent,
|
|
const CharacterDataChangeInfo&) {
|
|
if (IsInComposedDoc() && IsCombobox() &&
|
|
nsContentUtils::IsInSameAnonymousTree(this, aContent)) {
|
|
OptionValueMightHaveChanged(aContent);
|
|
if (InsideSelectedOption(aContent, this)) {
|
|
// We deliberately only refresh the select button text here, not the
|
|
// descendant selectedcontent elements: the spec's trigger set doesn't
|
|
// include in-place mutation of the selected option's subtree, so the
|
|
// selectedcontent clone goes stale until the next selection/insertion/
|
|
// removal. This matches Chromium. Whether that is the right behavior is
|
|
// tracked in https://github.com/whatwg/html/issues/12509.
|
|
SelectedContentTextMightHaveChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
using MutatedOptions = AutoTArray<RefPtr<HTMLOptionElement>, 8>;
|
|
|
|
// Collect all the options valid for `aSelect` in `aChild`'s subtree into
|
|
// `aOptions`. Returns true if there is any selected option.
|
|
static bool CollectOptions(const HTMLSelectElement& aSelect, nsIContent* aChild,
|
|
MutatedOptions& aOptions) {
|
|
if (auto* option = HTMLOptionElement::FromNode(aChild)) {
|
|
if (!HTMLOptionsCollection::IsValidOption(*option, aSelect)) {
|
|
return false;
|
|
}
|
|
// Options inside options are not a thing.
|
|
aOptions.AppendElement(option);
|
|
return option->Selected();
|
|
}
|
|
bool anySelected = false;
|
|
for (auto* c = aChild->GetFirstChild(); c; c = c->GetNextNode(aChild)) {
|
|
auto* option = HTMLOptionElement::FromNode(c);
|
|
if (!option || !HTMLOptionsCollection::IsValidOption(*option, aSelect)) {
|
|
continue;
|
|
}
|
|
aOptions.AppendElement(option);
|
|
if (option->Selected()) {
|
|
anySelected = true;
|
|
}
|
|
}
|
|
return anySelected;
|
|
}
|
|
|
|
void HTMLSelectElement::ContentWillBeRemoved(nsIContent* aChild,
|
|
const ContentRemoveInfo& aInfo) {
|
|
if (!nsContentUtils::IsInSameAnonymousTree(this, aChild)) {
|
|
return;
|
|
}
|
|
MutatedOptions options;
|
|
const bool anySelected = CollectOptions(*this, aChild, options);
|
|
const bool combobox = IsCombobox();
|
|
if (!options.IsEmpty() && !combobox) {
|
|
for (auto& option : options) {
|
|
RemoveOptionFromListBoxSelection(*option);
|
|
}
|
|
}
|
|
const bool selectedOptionMayHaveChanged =
|
|
anySelected || (!options.IsEmpty() && combobox && SelectedIndex() < 0);
|
|
if (selectedOptionMayHaveChanged) {
|
|
RunSelectednessSettingAlgorithm(/*aNotify=*/true,
|
|
/*aSkipSelectedcontentUpdate=*/true,
|
|
options);
|
|
}
|
|
if (IsInComposedDoc() && combobox) {
|
|
OptionValueMightHaveChanged(aChild);
|
|
if (selectedOptionMayHaveChanged) {
|
|
// If the selected option might've changed, we need to update the selected
|
|
// content text ignoring the options here to get the correct text.
|
|
SelectedContentTextMightHaveChanged(true, options);
|
|
} else if (InsideSelectedOption(aChild, this)) {
|
|
// If content mutates in our selected option, we need to use a script
|
|
// runner to make sure the algorithm doesn't look at the pre-removal text.
|
|
nsContentUtils::AddScriptRunner(
|
|
NewRunnableMethod<bool, Span<RefPtr<HTMLOptionElement>>>(
|
|
"SelectedContentTextMightHaveChangedAfterRemoval", this,
|
|
&HTMLSelectElement::SelectedContentTextMightHaveChanged, true,
|
|
Span<RefPtr<HTMLOptionElement>>{}));
|
|
}
|
|
}
|
|
if (!options.IsEmpty()) {
|
|
// NOTE(emilio): This is a bit of a hack. Our mOptions list gets notified of
|
|
// mutations before us, which is generally what we want. However, for
|
|
// removal it is _not_ what we want, since we look at the pre-removal
|
|
// options list here. If any code above brings it up to date, then there's
|
|
// no other notification for it to invalidate again, which would leave stale
|
|
// options in the list. So gotta invalidate it manually here.
|
|
mOptions->SetDirty();
|
|
}
|
|
if (selectedOptionMayHaveChanged && !mIsUpdatingSelectedContent) {
|
|
ScheduleSelectedContentUpdate();
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::ContentAppendedOrInserted(nsIContent* aFirstNewContent,
|
|
bool aIsAppend) {
|
|
if (!nsContentUtils::IsInSameAnonymousTree(this, aFirstNewContent)) {
|
|
return;
|
|
}
|
|
MutatedOptions options;
|
|
// Inserting selected options de-selects all others per spec.
|
|
bool anySelected = false;
|
|
for (auto* cur = aFirstNewContent; cur; cur = cur->GetNextSibling()) {
|
|
anySelected |= CollectOptions(*this, cur, options);
|
|
if (!aIsAppend) {
|
|
break;
|
|
}
|
|
}
|
|
if (!options.IsEmpty()) {
|
|
if (nsListControlFrame* listBox = GetListBoxFrame()) {
|
|
listBox->OptionsAdded();
|
|
}
|
|
}
|
|
if (anySelected && !Multiple()) {
|
|
// Select the last selected option.
|
|
HTMLOptionElement* lastSelected = nullptr;
|
|
for (HTMLOptionElement* opt : Reversed(options)) {
|
|
if (opt->Selected()) {
|
|
lastSelected = opt;
|
|
break;
|
|
}
|
|
}
|
|
MOZ_ASSERT(lastSelected, "How?");
|
|
int32_t indexToSelect = lastSelected->Index();
|
|
const OptionFlags mask{OptionFlag::IsSelected, OptionFlag::ClearAll,
|
|
OptionFlag::SetDisabled, OptionFlag::Notify,
|
|
OptionFlag::InsertingOptions};
|
|
SetOptionsSelectedByIndex(indexToSelect, indexToSelect, mask);
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#selectedness-setting-algorithm
|
|
// Run once per mutation (not per-option) since caches are already set by
|
|
// each option's BindToTree → UpdateNearestAncestorSelect.
|
|
const bool selectedOptionMayHaveChanged =
|
|
anySelected ||
|
|
(!options.IsEmpty() && IsCombobox() && SelectedIndex() < 0);
|
|
if (selectedOptionMayHaveChanged) {
|
|
RunSelectednessSettingAlgorithm(/*aNotify=*/true,
|
|
/*aSkipSelectedcontentUpdate=*/true);
|
|
}
|
|
|
|
if (!anySelected && IsCombobox() && IsInComposedDoc()) {
|
|
OptionValueMightHaveChanged(aFirstNewContent);
|
|
if (InsideSelectedOption(aFirstNewContent, this)) {
|
|
SelectedContentTextMightHaveChanged();
|
|
}
|
|
}
|
|
// Per the option post-connection steps, the selectedcontent update only
|
|
// happens when an option was inserted (not for content inserted inside an
|
|
// existing option, which is not a trigger in the spec). Gate on
|
|
// selectedOptionMayHaveChanged. Whether that's the right thing to do is
|
|
// tracked in https://github.com/whatwg/html/issues/12509.
|
|
if (selectedOptionMayHaveChanged && !mIsUpdatingSelectedContent) {
|
|
ScheduleSelectedContentUpdate(SelectedContentUpdateMode::ScriptRunner);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::ContentAppended(nsIContent* aFirstNewContent,
|
|
const ContentAppendInfo&) {
|
|
ContentAppendedOrInserted(aFirstNewContent, true);
|
|
}
|
|
|
|
void HTMLSelectElement::ContentInserted(nsIContent* aChild,
|
|
const ContentInsertInfo&) {
|
|
ContentAppendedOrInserted(aChild, false);
|
|
}
|
|
|
|
JSObject* HTMLSelectElement::WrapNode(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return HTMLSelectElement_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
HTMLSelectElement::~HTMLSelectElement() {
|
|
if (sLastSelectKeyHandler == uintptr_t(this)) {
|
|
sLastSelectKeyHandler = 0;
|
|
}
|
|
}
|
|
|
|
static const uint32_t kMaxDropdownRows = 20;
|
|
|
|
class MOZ_RAII AutoIncrementalSearchResetter {
|
|
public:
|
|
explicit AutoIncrementalSearchResetter(HTMLSelectElement& aElement) {
|
|
if (sLastSelectKeyHandler != uintptr_t(&aElement)) {
|
|
sLastSelectKeyHandler = uintptr_t(&aElement);
|
|
GetIncrementalString().Truncate();
|
|
gLastKeyTime = TimeStamp::Now() -
|
|
TimeDuration::FromMilliseconds(
|
|
StaticPrefs::ui_menu_incremental_search_timeout() * 2);
|
|
}
|
|
}
|
|
~AutoIncrementalSearchResetter() {
|
|
if (!mResettingCancelled) {
|
|
GetIncrementalString().Truncate();
|
|
}
|
|
}
|
|
void CancelResetting() { mResettingCancelled = true; }
|
|
|
|
private:
|
|
bool mResettingCancelled = false;
|
|
};
|
|
|
|
int32_t HTMLSelectElement::GetEndSelectionIndex() const {
|
|
if (IsCombobox()) {
|
|
return SelectedIndex();
|
|
}
|
|
return mListBoxSelection.mEnd ? mListBoxSelection.mEnd->Index()
|
|
: kNothingSelected;
|
|
}
|
|
|
|
bool HTMLSelectElement::IsOptionInteractivelySelectable(uint32_t aIndex) const {
|
|
HTMLOptionElement* option = Item(aIndex);
|
|
return option && ::IsOptionInteractivelySelectable(*this, *option);
|
|
}
|
|
|
|
int32_t HTMLSelectElement::ItemsPerPage() const {
|
|
uint32_t size = [&] {
|
|
if (IsCombobox()) {
|
|
return kMaxDropdownRows;
|
|
}
|
|
if (nsListControlFrame* lf = do_QueryFrame(GetPrimaryFrame())) {
|
|
return lf->GetNumDisplayRows();
|
|
}
|
|
return Size();
|
|
}();
|
|
if (size <= 1) {
|
|
return 1;
|
|
}
|
|
if (MOZ_UNLIKELY(size > INT32_MAX)) {
|
|
return INT32_MAX - 1;
|
|
}
|
|
return AssertedCast<int32_t>(size - 1u);
|
|
}
|
|
|
|
void HTMLSelectElement::AdjustIndexForDisabledOpt(int32_t aStartIndex,
|
|
int32_t& aNewIndex,
|
|
int32_t aNumOptions,
|
|
int32_t aDoAdjustInc,
|
|
int32_t aDoAdjustIncNext) {
|
|
if (aNumOptions == 0) {
|
|
aNewIndex = kNothingSelected;
|
|
return;
|
|
}
|
|
|
|
bool doingReverse = false;
|
|
int32_t bottom = 0;
|
|
int32_t top = aNumOptions;
|
|
|
|
int32_t startIndex = aStartIndex;
|
|
if (startIndex < bottom) {
|
|
startIndex = SelectedIndex();
|
|
}
|
|
int32_t newIndex = startIndex + aDoAdjustInc;
|
|
|
|
if (newIndex < bottom) {
|
|
newIndex = 0;
|
|
} else if (newIndex >= top) {
|
|
newIndex = aNumOptions - 1;
|
|
}
|
|
|
|
while (true) {
|
|
if (IsOptionInteractivelySelectable(newIndex)) {
|
|
break;
|
|
}
|
|
|
|
newIndex += aDoAdjustIncNext;
|
|
|
|
if (newIndex < bottom) {
|
|
if (doingReverse) {
|
|
return;
|
|
}
|
|
newIndex = bottom;
|
|
aDoAdjustIncNext = 1;
|
|
doingReverse = true;
|
|
top = startIndex;
|
|
} else if (newIndex >= top) {
|
|
if (doingReverse) {
|
|
return;
|
|
}
|
|
newIndex = top - 1;
|
|
aDoAdjustIncNext = -1;
|
|
doingReverse = true;
|
|
bottom = startIndex;
|
|
}
|
|
}
|
|
|
|
aNewIndex = newIndex;
|
|
}
|
|
|
|
HTMLOptionElement* HTMLSelectElement::GetCurrentOption() const {
|
|
int32_t endIndex = GetEndSelectionIndex();
|
|
int32_t focusedIndex =
|
|
endIndex == kNothingSelected ? SelectedIndex() : endIndex;
|
|
if (focusedIndex >= 0) {
|
|
return Item(AssertedCast<uint32_t>(focusedIndex));
|
|
}
|
|
return GetNonDisabledOptionFrom(0);
|
|
}
|
|
|
|
HTMLOptionElement* HTMLSelectElement::GetNonDisabledOptionFrom(
|
|
int32_t aFromIndex, int32_t* aFoundIndex) const {
|
|
const uint32_t length = Length();
|
|
for (uint32_t i = std::max(aFromIndex, 0); i < length; ++i) {
|
|
if (IsOptionInteractivelySelectable(i)) {
|
|
if (aFoundIndex) {
|
|
*aFoundIndex = i;
|
|
}
|
|
return Item(i);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void HTMLSelectElement::FireDropDownEvent(bool aShow,
|
|
bool aIsSourceTouchEvent) {
|
|
const auto eventName = [&] {
|
|
if (aShow) {
|
|
return aIsSourceTouchEvent ? u"mozshowdropdown-sourcetouch"_ns
|
|
: u"mozshowdropdown"_ns;
|
|
}
|
|
return u"mozhidedropdown"_ns;
|
|
}();
|
|
nsContentUtils::DispatchChromeEvent(this, eventName, CanBubble::eYes,
|
|
Cancelable::eNo);
|
|
}
|
|
|
|
void HTMLSelectElement::PostHandleKeyEvent(int32_t aNewIndex,
|
|
uint32_t aCharCode, bool aIsShift,
|
|
bool aIsControlOrMeta) {
|
|
if (aNewIndex == kNothingSelected) {
|
|
int32_t endIndex = GetEndSelectionIndex();
|
|
int32_t focusedIndex =
|
|
endIndex == kNothingSelected ? SelectedIndex() : endIndex;
|
|
if (focusedIndex != kNothingSelected) {
|
|
return;
|
|
}
|
|
if (!GetNonDisabledOptionFrom(0, &aNewIndex)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (IsCombobox()) {
|
|
RefPtr<HTMLOptionElement> newOption = Item(aNewIndex);
|
|
MOZ_ASSERT(newOption);
|
|
if (newOption->Selected()) {
|
|
return;
|
|
}
|
|
newOption->SetSelected(true);
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
return;
|
|
}
|
|
UpdateListBoxSelectionAfterKeyEvent(aNewIndex, aCharCode, aIsShift,
|
|
aIsControlOrMeta);
|
|
}
|
|
|
|
void HTMLSelectElement::CaptureMouseEvents(bool aGrabMouseEvents) {
|
|
if (aGrabMouseEvents) {
|
|
PresShell::SetCapturingContent(this, CaptureFlags::IgnoreAllowedState);
|
|
} else if (PresShell::GetCapturingContent() == this) {
|
|
// Only clear the capturing content if *we* are the ones doing the
|
|
// capturing. It could be a scrollbar inside this listbox which is actually
|
|
// grabbing.
|
|
PresShell::ReleaseCapturingContent();
|
|
}
|
|
}
|
|
|
|
HTMLOptionElement* HTMLSelectElement::GetListBoxOptionFromEvent(
|
|
const WidgetMouseEvent& aEvent) {
|
|
nsListControlFrame* lf = GetListBoxFrame();
|
|
if (NS_WARN_IF(!lf)) {
|
|
return nullptr;
|
|
}
|
|
if (PresShell::GetCapturingContent() != this) {
|
|
// If we're not capturing, then ignore movement in the border.
|
|
nsPoint pt =
|
|
nsLayoutUtils::GetEventCoordinatesRelativeTo(&aEvent, RelativeTo{lf});
|
|
nsRect borderInnerEdge = lf->GetScrollPortRect();
|
|
if (!borderInnerEdge.Contains(pt)) {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
HTMLOptionElement* option = nullptr;
|
|
for (nsIContent* content =
|
|
lf->PresContext()->EventStateManager()->GetEventTargetContent();
|
|
content && !option; content = content->GetParent()) {
|
|
option = HTMLOptionElement::FromNode(content);
|
|
}
|
|
|
|
MOZ_ASSERT(!option || option->Index() >= 0);
|
|
return option;
|
|
}
|
|
|
|
static HTMLOptionElement* AdjacentOption(const HTMLSelectElement& aSelect,
|
|
HTMLOptionElement& aFrom,
|
|
bool aForward) {
|
|
auto Step = [&](const nsINode* aNode) {
|
|
return aForward ? aNode->GetNextNode(&aSelect)
|
|
: aNode->GetPrevNode(&aSelect);
|
|
};
|
|
for (nsIContent* cur = Step(&aFrom); cur; cur = Step(cur)) {
|
|
if (auto* opt = HTMLOptionElement::FromNode(cur)) {
|
|
if (HTMLOptionsCollection::IsValidOption(*opt, aSelect)) {
|
|
return opt;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void HTMLSelectElement::RemoveOptionFromListBoxSelection(
|
|
HTMLOptionElement& aOption) {
|
|
NS_ASSERTION(!!mListBoxSelection.mStart == !!mListBoxSelection.mEnd, "");
|
|
|
|
bool startIsLow = mListBoxSelection.mStartIsLow;
|
|
if (mListBoxSelection.mStart == &aOption &&
|
|
mListBoxSelection.mEnd == &aOption) {
|
|
mListBoxSelection.Clear();
|
|
} else if (mListBoxSelection.mStart == &aOption) {
|
|
mListBoxSelection.mStart =
|
|
AdjacentOption(*this, aOption, /* aForward = */ startIsLow);
|
|
} else if (mListBoxSelection.mEnd == &aOption) {
|
|
mListBoxSelection.mEnd =
|
|
AdjacentOption(*this, aOption, /* aForward = */ !startIsLow);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (nsListControlFrame* lf = GetListBoxFrame()) {
|
|
lf->InvalidateFocus();
|
|
}
|
|
}
|
|
|
|
bool HTMLSelectElement::ExtendedSelection(int32_t aStartIndex,
|
|
int32_t aEndIndex, bool aClearAll) {
|
|
OptionFlags mask = OptionFlag::Notify;
|
|
mask += OptionFlag::IsSelected;
|
|
if (aClearAll) {
|
|
mask += OptionFlag::ClearAll;
|
|
}
|
|
return SetOptionsSelectedByIndex(aStartIndex, aEndIndex, mask);
|
|
}
|
|
|
|
bool HTMLSelectElement::ToggleOptionSelected(int32_t aIndex) {
|
|
RefPtr<HTMLOptionElement> option = Item(static_cast<uint32_t>(aIndex));
|
|
NS_ENSURE_TRUE(option, false);
|
|
|
|
OptionFlags mask = OptionFlag::Notify;
|
|
if (!option->Selected()) {
|
|
mask += OptionFlag::IsSelected;
|
|
}
|
|
return SetOptionsSelectedByIndex(aIndex, aIndex, mask);
|
|
}
|
|
|
|
void HTMLSelectElement::InitListBoxSelectionRange(int32_t aClickedIndex) {
|
|
// If nothing is selected, set the start selection depending on where
|
|
// the user clicked and what the initial selection is:
|
|
// - if the user clicked *before* selectedIndex, set the start index to
|
|
// the end of the first contiguous selection.
|
|
// - if the user clicked *after* the end of the first contiguous
|
|
// selection, set the start index to selectedIndex.
|
|
// - if the user clicked *within* the first contiguous selection, set the
|
|
// start index to selectedIndex.
|
|
// The last two rules, of course, boil down to the same thing: if the user
|
|
// clicked >= selectedIndex, return selectedIndex.
|
|
//
|
|
// This makes it so that shift click works properly when you first click
|
|
// in a multiple select.
|
|
int32_t firstSelectedIndex = SelectedIndex();
|
|
if (firstSelectedIndex >= 0) {
|
|
// Get the end of the contiguous selection
|
|
RefPtr<HTMLOptionsCollection> options = Options();
|
|
NS_ASSERTION(options, "Collection of options is null!");
|
|
uint32_t numOptions = options->Length();
|
|
// Push i to one past the last selected index in the group.
|
|
uint32_t i;
|
|
for (i = firstSelectedIndex + 1; i < numOptions; i++) {
|
|
if (!options->ItemAsOption(i)->Selected()) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (aClickedIndex < firstSelectedIndex) {
|
|
// User clicked before selection, so start selection at end of
|
|
// contiguous selection
|
|
mListBoxSelection.mStart = Item(i - 1);
|
|
mListBoxSelection.mEnd = Item(firstSelectedIndex);
|
|
mListBoxSelection.mStartIsLow = false;
|
|
} else {
|
|
// User clicked after selection, so start selection at start of
|
|
// contiguous selection
|
|
mListBoxSelection.mStart = Item(firstSelectedIndex);
|
|
mListBoxSelection.mEnd = Item(i - 1);
|
|
mListBoxSelection.mStartIsLow = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool HTMLSelectElement::ListBoxSingleSelection(int32_t aClickedIndex,
|
|
bool aDoToggle) {
|
|
#ifdef ACCESSIBILITY
|
|
nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
|
|
#endif
|
|
bool wasChanged = false;
|
|
// Get Current selection
|
|
if (aDoToggle) {
|
|
wasChanged = ToggleOptionSelected(aClickedIndex);
|
|
} else {
|
|
wasChanged = ExtendedSelection(aClickedIndex, aClickedIndex, true);
|
|
}
|
|
mListBoxSelection.SetTo(Item(aClickedIndex));
|
|
ScrollToOption(aClickedIndex);
|
|
if (nsListControlFrame* listBox = GetListBoxFrame()) {
|
|
listBox->InvalidateFocus();
|
|
}
|
|
#ifdef ACCESSIBILITY
|
|
MaybeFireMenuItemActiveEvent(prevOption);
|
|
#endif
|
|
|
|
return wasChanged;
|
|
}
|
|
|
|
bool HTMLSelectElement::PerformListBoxSelection(int32_t aClickedIndex,
|
|
bool aIsShift,
|
|
bool aIsControl) {
|
|
if (aClickedIndex == kNothingSelected) {
|
|
// Ignore kNothingSelected.
|
|
return false;
|
|
}
|
|
if (!Multiple()) {
|
|
return ListBoxSingleSelection(aClickedIndex, false);
|
|
}
|
|
bool wasChanged = false;
|
|
if (aIsShift) {
|
|
// Make sure shift+click actually does something expected when
|
|
// the user has never clicked on the select
|
|
if (!mListBoxSelection.mStart) {
|
|
InitListBoxSelectionRange(aClickedIndex);
|
|
}
|
|
|
|
// Get the range from beginning (low) to end (high)
|
|
// Shift *always* works, even if the current option is disabled
|
|
int32_t startIndex;
|
|
int32_t endIndex;
|
|
if (!mListBoxSelection.mStart) {
|
|
startIndex = aClickedIndex;
|
|
endIndex = aClickedIndex;
|
|
} else {
|
|
int32_t anchorIndex = mListBoxSelection.mStart->Index();
|
|
if (anchorIndex <= aClickedIndex) {
|
|
startIndex = anchorIndex;
|
|
endIndex = aClickedIndex;
|
|
} else {
|
|
startIndex = aClickedIndex;
|
|
endIndex = anchorIndex;
|
|
}
|
|
}
|
|
|
|
// Clear only if control was not pressed
|
|
wasChanged = ExtendedSelection(startIndex, endIndex, !aIsControl);
|
|
ScrollToOption(aClickedIndex);
|
|
if (!mListBoxSelection.mStart) {
|
|
mListBoxSelection.mStart = Item(aClickedIndex);
|
|
}
|
|
#ifdef ACCESSIBILITY
|
|
nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
|
|
#endif
|
|
mListBoxSelection.mEnd = Item(aClickedIndex);
|
|
mListBoxSelection.mStartIsLow =
|
|
mListBoxSelection.mStart->Index() <= aClickedIndex;
|
|
if (nsListControlFrame* listBox = GetListBoxFrame()) {
|
|
listBox->InvalidateFocus();
|
|
}
|
|
#ifdef ACCESSIBILITY
|
|
MaybeFireMenuItemActiveEvent(prevOption);
|
|
#endif
|
|
} else {
|
|
wasChanged = ListBoxSingleSelection(aClickedIndex, aIsControl);
|
|
}
|
|
return wasChanged;
|
|
}
|
|
|
|
// Dispatch event and such
|
|
void HTMLSelectElement::UpdateSelection() {
|
|
if (IsDoneAddingChildren()) {
|
|
// Note that after UserFinishedInteracting we might be dead, as that can
|
|
// run script.
|
|
RefPtr<HTMLSelectElement> kungFuDeathGrip = this;
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
}
|
|
}
|
|
|
|
void HTMLSelectElement::UpdateListBoxSelectionAfterKeyEvent(
|
|
int32_t aNewIndex, uint32_t aCharCode, bool aIsShift,
|
|
bool aIsControlOrMeta) {
|
|
bool wasChanged = false;
|
|
if (aIsControlOrMeta && !aIsShift && aCharCode != ' ') {
|
|
#ifdef ACCESSIBILITY
|
|
nsCOMPtr<nsIContent> prevOption = GetCurrentOption();
|
|
#endif
|
|
mListBoxSelection.SetTo(Item(aNewIndex));
|
|
if (nsListControlFrame* listBox = GetListBoxFrame()) {
|
|
listBox->InvalidateFocus();
|
|
}
|
|
ScrollToOption(aNewIndex);
|
|
#ifdef ACCESSIBILITY
|
|
MaybeFireMenuItemActiveEvent(prevOption);
|
|
#endif
|
|
} else if (mControlSelectMode && aCharCode == ' ') {
|
|
wasChanged = ListBoxSingleSelection(aNewIndex, true);
|
|
} else {
|
|
wasChanged = PerformListBoxSelection(aNewIndex, aIsShift, aIsControlOrMeta);
|
|
}
|
|
if (wasChanged) {
|
|
UpdateSelection();
|
|
}
|
|
}
|
|
|
|
#ifdef ACCESSIBILITY
|
|
void HTMLSelectElement::MaybeFireMenuItemActiveEvent(
|
|
nsIContent* aPreviousOption) {
|
|
if (!State().HasState(ElementState::FOCUS)) {
|
|
return;
|
|
}
|
|
|
|
nsIContent* optionContent = GetCurrentOption();
|
|
if (aPreviousOption == optionContent) {
|
|
// No change
|
|
return;
|
|
}
|
|
|
|
if (aPreviousOption) {
|
|
MakeRefPtr<AsyncEventDispatcher>(aPreviousOption, u"DOMMenuItemInactive"_ns,
|
|
CanBubble::eYes, ChromeOnlyDispatch::eNo)
|
|
->PostDOMEvent();
|
|
}
|
|
|
|
if (optionContent) {
|
|
MakeRefPtr<AsyncEventDispatcher>(optionContent, u"DOMMenuItemActive"_ns,
|
|
CanBubble::eYes, ChromeOnlyDispatch::eNo)
|
|
->PostDOMEvent();
|
|
}
|
|
}
|
|
#endif
|
|
|
|
nsresult HTMLSelectElement::PostHandleEvent(EventChainPostVisitor& aVisitor) {
|
|
if (aVisitor.mEventStatus == nsEventStatus_eConsumeNoDefault) {
|
|
return NS_OK;
|
|
}
|
|
|
|
WidgetEvent* event = aVisitor.mEvent;
|
|
if (!event->IsTrusted()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
switch (event->mMessage) {
|
|
case eKeyDown:
|
|
return HandleKeyDown(aVisitor);
|
|
case eKeyPress:
|
|
return HandleKeyPress(aVisitor);
|
|
case eMouseDown:
|
|
if (event->DefaultPrevented()) {
|
|
return NS_OK;
|
|
}
|
|
return HandleMouseDown(aVisitor);
|
|
case eMouseUp:
|
|
// Don't try to honor defaultPrevented here - it's not web compatible.
|
|
// (bug 1194733)
|
|
return HandleMouseUp(aVisitor);
|
|
case eMouseMove:
|
|
return HandleMouseMove(aVisitor);
|
|
default:
|
|
break;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::HandleMouseDown(EventChainPostVisitor& aVisitor) {
|
|
if (IsDisabled()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
WidgetMouseEvent* mouseEvent = aVisitor.mEvent->AsMouseEvent();
|
|
if (!mouseEvent) {
|
|
return NS_OK;
|
|
}
|
|
|
|
const bool isLeftButton = mouseEvent->mButton == MouseButton::ePrimary;
|
|
if (!isLeftButton) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (IsCombobox()) {
|
|
nsCOMPtr<nsIContent> target =
|
|
nsIContent::FromEventTargetOrNull(aVisitor.mEvent->mOriginalTarget);
|
|
if (IsBaseSelectAppearance()) {
|
|
// Clicking an option in the base-appearance picker is handled on mouse
|
|
// up (where it commits that option and closes the picker). Don't let a
|
|
// mouse down on an option fall through and toggle the picker closed.
|
|
if (target && *target->InclusiveAncestorsOfType<HTMLOptionElement>()) {
|
|
return NS_OK;
|
|
}
|
|
} else if (OpenInParentProcess()) {
|
|
if (target && target->IsHTMLElement(nsGkAtoms::option)) {
|
|
return NS_OK;
|
|
}
|
|
}
|
|
const bool isSourceTouchEvent =
|
|
mouseEvent->mInputSource == MouseEvent_Binding::MOZ_SOURCE_TOUCH;
|
|
TogglePickerInternal(isSourceTouchEvent);
|
|
return NS_OK;
|
|
}
|
|
|
|
HTMLOptionElement* option = GetListBoxOptionFromEvent(*mouseEvent);
|
|
if (!option) {
|
|
return NS_OK;
|
|
}
|
|
|
|
mButtonDown = true;
|
|
CaptureMouseEvents(true);
|
|
bool isControlOrMeta;
|
|
#ifdef XP_MACOSX
|
|
isControlOrMeta = mouseEvent->IsMeta();
|
|
#else
|
|
isControlOrMeta = mouseEvent->IsControl();
|
|
#endif
|
|
// PerformSelection might destroy the frame, but we only need to record the
|
|
// result onto ourselves, which keeps us alive during event dispatch.
|
|
mListBoxSelectionChangedSinceDragStart = PerformListBoxSelection(
|
|
option->Index(), mouseEvent->IsShift(), isControlOrMeta);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::HandleMouseUp(EventChainPostVisitor& aVisitor) {
|
|
mButtonDown = false;
|
|
|
|
if (IsDisabled()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
CaptureMouseEvents(false);
|
|
|
|
if (IsCombobox()) {
|
|
if (IsBaseSelectAppearance()) {
|
|
WidgetMouseEvent* mouseEvent = aVisitor.mEvent->AsMouseEvent();
|
|
if (mouseEvent && mouseEvent->mButton == MouseButton::ePrimary) {
|
|
// Clicking an option in the base-appearance picker commits that option
|
|
// and closes the picker, rather than merely toggling it closed.
|
|
nsCOMPtr<nsIContent> target =
|
|
nsIContent::FromEventTargetOrNull(aVisitor.mEvent->mOriginalTarget);
|
|
if (RefPtr<HTMLOptionElement> option =
|
|
target ? *target->InclusiveAncestorsOfType<HTMLOptionElement>()
|
|
: nullptr) {
|
|
if (::IsOptionInteractivelySelectable(*this, *option)) {
|
|
if (!option->Selected()) {
|
|
option->SetSelected(true);
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
}
|
|
if (RefPtr<nsGenericHTMLElement> picker = GetPickerElement()) {
|
|
IgnoredErrorResult ignored;
|
|
picker->HidePopover(ignored);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
WidgetMouseEvent* mouseEvent = aVisitor.mEvent->AsMouseEvent();
|
|
if (!mouseEvent) {
|
|
return NS_OK;
|
|
}
|
|
|
|
const bool isLeftButton = mouseEvent->mButton == MouseButton::ePrimary;
|
|
if (!isLeftButton) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (mListBoxSelectionChangedSinceDragStart) {
|
|
// Reset this so that future MouseUps without a prior MouseDown won't fire
|
|
// onchange. Note that the call below runs script.
|
|
mListBoxSelectionChangedSinceDragStart = false;
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::HandleMouseMove(EventChainPostVisitor& aVisitor) {
|
|
if (!mButtonDown) {
|
|
return NS_OK;
|
|
}
|
|
|
|
WidgetMouseEvent* mouseEvent = aVisitor.mEvent->AsMouseEvent();
|
|
if (!mouseEvent) {
|
|
return NS_OK;
|
|
}
|
|
|
|
HTMLOptionElement* option = GetListBoxOptionFromEvent(*mouseEvent);
|
|
// Don't waste cycles if we already dragged over this item.
|
|
if (!option || option == mListBoxSelection.mEnd) {
|
|
return NS_OK;
|
|
}
|
|
bool isControlOrMeta;
|
|
#ifdef XP_MACOSX
|
|
isControlOrMeta = mouseEvent->IsMeta();
|
|
#else
|
|
isControlOrMeta = mouseEvent->IsControl();
|
|
#endif
|
|
// Turn SHIFT on when you are dragging, unless control is on.
|
|
const bool wasChanged = PerformListBoxSelection(
|
|
option->Index(), !isControlOrMeta, isControlOrMeta);
|
|
mListBoxSelectionChangedSinceDragStart |= wasChanged;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::HandleKeyPress(EventChainPostVisitor& aVisitor) {
|
|
if (IsDisabled()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
AutoIncrementalSearchResetter incrementalHandler(*this);
|
|
|
|
const WidgetKeyboardEvent* keyEvent = aVisitor.mEvent->AsKeyboardEvent();
|
|
MOZ_ASSERT(keyEvent,
|
|
"DOM event must have WidgetKeyboardEvent for its internal event");
|
|
|
|
if (keyEvent->DefaultPrevented()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (keyEvent->IsAlt()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// With some keyboard layout, space key causes non-ASCII space.
|
|
// So, the check in keydown event handler isn't enough, we need to check it
|
|
// again with keypress event.
|
|
if (keyEvent->mCharCode != ' ') {
|
|
mControlSelectMode = false;
|
|
}
|
|
|
|
const bool isCombobox = IsCombobox();
|
|
const bool isControlOrMeta = keyEvent->IsControl()
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
|| keyEvent->IsMeta()
|
|
#endif
|
|
;
|
|
if (isControlOrMeta && keyEvent->mCharCode != ' ') {
|
|
AutoShortcutKeyCandidateArray candidates;
|
|
keyEvent->GetShortcutKeyCandidates(candidates);
|
|
const bool isSelectAll =
|
|
Multiple() && !isCombobox &&
|
|
std::any_of(candidates.begin(), candidates.end(),
|
|
[](const ShortcutKeyCandidate& c) {
|
|
return c.mCharCode == 'a' || c.mCharCode == 'A';
|
|
});
|
|
if (isSelectAll) {
|
|
using OptionFlag = HTMLSelectElement::OptionFlag;
|
|
uint32_t numOptions = Length();
|
|
if (numOptions) {
|
|
HTMLSelectElement::OptionFlags mask = {
|
|
OptionFlag::IsSelected, OptionFlag::ClearAll, OptionFlag::Notify};
|
|
const bool wasChanged = SetOptionsSelectedByIndex(
|
|
0, AssertedCast<int32_t>(numOptions - 1), mask);
|
|
if (wasChanged) {
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
}
|
|
}
|
|
aVisitor.mEvent->PreventDefault();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
if (!keyEvent->mCharCode) {
|
|
if (keyEvent->mKeyCode == NS_VK_BACK) {
|
|
incrementalHandler.CancelResetting();
|
|
if (!GetIncrementalString().IsEmpty()) {
|
|
GetIncrementalString().Truncate(GetIncrementalString().Length() - 1);
|
|
}
|
|
aVisitor.mEvent->PreventDefault();
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
incrementalHandler.CancelResetting();
|
|
|
|
aVisitor.mEvent->PreventDefault();
|
|
|
|
if ((keyEvent->mTimeStamp - gLastKeyTime).ToMilliseconds() >
|
|
StaticPrefs::ui_menu_incremental_search_timeout()) {
|
|
if (keyEvent->mCharCode == ' ') {
|
|
PostHandleKeyEvent(GetEndSelectionIndex(), keyEvent->mCharCode,
|
|
keyEvent->IsShift(), isControlOrMeta);
|
|
return NS_OK;
|
|
}
|
|
GetIncrementalString().Truncate();
|
|
}
|
|
|
|
gLastKeyTime = keyEvent->mTimeStamp;
|
|
|
|
char16_t uniChar = ToLowerCase(static_cast<char16_t>(keyEvent->mCharCode));
|
|
GetIncrementalString().Append(uniChar);
|
|
|
|
nsAutoString incrementalString(GetIncrementalString());
|
|
uint32_t charIndex = 1, stringLength = incrementalString.Length();
|
|
while (charIndex < stringLength &&
|
|
incrementalString[charIndex] == incrementalString[charIndex - 1]) {
|
|
charIndex++;
|
|
}
|
|
if (charIndex == stringLength) {
|
|
incrementalString.Truncate(1);
|
|
stringLength = 1;
|
|
}
|
|
|
|
int32_t startIndex = SelectedIndex();
|
|
if (startIndex == kNothingSelected) {
|
|
startIndex = 0;
|
|
} else if (stringLength == 1) {
|
|
startIndex++;
|
|
}
|
|
|
|
RefPtr<HTMLOptionsCollection> options = Options();
|
|
uint32_t numOptions = options->Length();
|
|
|
|
for (uint32_t i = 0; i < numOptions; ++i) {
|
|
uint32_t index = (i + startIndex) % numOptions;
|
|
RefPtr<HTMLOptionElement> optionElement = options->ItemAsOption(index);
|
|
if (!optionElement ||
|
|
!::IsOptionInteractivelySelectable(*this, *optionElement)) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoString text;
|
|
optionElement->GetRenderedLabel(text);
|
|
if (!StringBeginsWith(
|
|
nsContentUtils::TrimWhitespace<
|
|
nsContentUtils::IsHTMLWhitespaceOrNBSP>(text, false),
|
|
incrementalString, nsCaseInsensitiveStringComparator)) {
|
|
continue;
|
|
}
|
|
|
|
if (isCombobox) {
|
|
if (optionElement->Selected()) {
|
|
return NS_OK;
|
|
}
|
|
optionElement->SetSelected(true);
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
return NS_OK;
|
|
}
|
|
|
|
bool wasChanged =
|
|
PerformListBoxSelection(index, keyEvent->IsShift(), isControlOrMeta);
|
|
if (wasChanged) {
|
|
UserFinishedInteracting(/* aChanged = */ true);
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult HTMLSelectElement::HandleKeyDown(EventChainPostVisitor& aVisitor) {
|
|
if (IsDisabled()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
AutoIncrementalSearchResetter incrementalHandler(*this);
|
|
|
|
if (aVisitor.mEvent->DefaultPrevented()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
const WidgetKeyboardEvent* keyEvent = aVisitor.mEvent->AsKeyboardEvent();
|
|
MOZ_ASSERT(keyEvent,
|
|
"DOM event must have WidgetKeyboardEvent for its internal event");
|
|
|
|
const bool isCombobox = IsCombobox();
|
|
bool dropDownMenuOnUpDown;
|
|
bool dropDownMenuOnSpace;
|
|
#ifdef XP_MACOSX
|
|
dropDownMenuOnUpDown = isCombobox && !OpenInParentProcess();
|
|
dropDownMenuOnSpace = isCombobox && !keyEvent->IsAlt() &&
|
|
!keyEvent->IsControl() && !keyEvent->IsMeta();
|
|
#else
|
|
dropDownMenuOnUpDown = isCombobox && keyEvent->IsAlt();
|
|
dropDownMenuOnSpace = isCombobox && !OpenInParentProcess();
|
|
#endif
|
|
bool withinIncrementalSearchTime =
|
|
(keyEvent->mTimeStamp - gLastKeyTime).ToMilliseconds() <=
|
|
StaticPrefs::ui_menu_incremental_search_timeout();
|
|
if ((dropDownMenuOnUpDown &&
|
|
(keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_DOWN)) ||
|
|
(dropDownMenuOnSpace && keyEvent->mKeyCode == NS_VK_SPACE &&
|
|
!withinIncrementalSearchTime)) {
|
|
TogglePickerInternal();
|
|
aVisitor.mEvent->PreventDefault();
|
|
return NS_OK;
|
|
}
|
|
if (keyEvent->IsAlt()) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// We should not change the selection if the popup is "opened in the parent
|
|
// process" (even when we're in single-process mode).
|
|
const bool shouldSelect = !isCombobox || !OpenInParentProcess();
|
|
|
|
RefPtr<HTMLOptionsCollection> options = Options();
|
|
uint32_t numOptions = options->Length();
|
|
|
|
int32_t newIndex = kNothingSelected;
|
|
|
|
bool isControlOrMeta = keyEvent->IsControl()
|
|
#if !defined(XP_WIN) && !defined(MOZ_WIDGET_GTK)
|
|
|| keyEvent->IsMeta()
|
|
#endif
|
|
;
|
|
if (isControlOrMeta && !Multiple() &&
|
|
(keyEvent->mKeyCode == NS_VK_PAGE_UP ||
|
|
keyEvent->mKeyCode == NS_VK_PAGE_DOWN)) {
|
|
return NS_OK;
|
|
}
|
|
if (isControlOrMeta &&
|
|
(keyEvent->mKeyCode == NS_VK_UP || keyEvent->mKeyCode == NS_VK_LEFT ||
|
|
keyEvent->mKeyCode == NS_VK_DOWN || keyEvent->mKeyCode == NS_VK_RIGHT ||
|
|
keyEvent->mKeyCode == NS_VK_HOME || keyEvent->mKeyCode == NS_VK_END)) {
|
|
isControlOrMeta = mControlSelectMode = Multiple();
|
|
} else if (keyEvent->mKeyCode != NS_VK_SPACE) {
|
|
mControlSelectMode = false;
|
|
}
|
|
|
|
auto isVerticalRL = [this]() -> bool {
|
|
if (nsIFrame* f = GetPrimaryFrame()) {
|
|
return f->GetWritingMode().IsVerticalRL();
|
|
}
|
|
return false;
|
|
};
|
|
|
|
switch (keyEvent->mKeyCode) {
|
|
case NS_VK_UP:
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), -1, -1);
|
|
}
|
|
break;
|
|
case NS_VK_LEFT:
|
|
if (shouldSelect) {
|
|
int dir = isVerticalRL() ? 1 : -1;
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), dir, dir);
|
|
}
|
|
break;
|
|
case NS_VK_DOWN:
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), 1, 1);
|
|
}
|
|
break;
|
|
case NS_VK_RIGHT:
|
|
if (shouldSelect) {
|
|
int dir = isVerticalRL() ? -1 : 1;
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), dir, dir);
|
|
}
|
|
break;
|
|
case NS_VK_RETURN:
|
|
if (!Multiple()) {
|
|
return NS_OK;
|
|
}
|
|
newIndex = GetEndSelectionIndex();
|
|
break;
|
|
case NS_VK_PAGE_UP: {
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), -ItemsPerPage(), -1);
|
|
}
|
|
break;
|
|
}
|
|
case NS_VK_PAGE_DOWN: {
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(GetEndSelectionIndex(), newIndex,
|
|
int32_t(numOptions), ItemsPerPage(), 1);
|
|
}
|
|
break;
|
|
}
|
|
case NS_VK_HOME:
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(0, newIndex, int32_t(numOptions), 0, 1);
|
|
}
|
|
break;
|
|
case NS_VK_END:
|
|
if (shouldSelect) {
|
|
AdjustIndexForDisabledOpt(int32_t(numOptions) - 1, newIndex,
|
|
int32_t(numOptions), 0, -1);
|
|
}
|
|
break;
|
|
default:
|
|
incrementalHandler.CancelResetting();
|
|
return NS_OK;
|
|
}
|
|
|
|
aVisitor.mEvent->PreventDefault();
|
|
|
|
PostHandleKeyEvent(newIndex, 0, keyEvent->IsShift(), isControlOrMeta);
|
|
return NS_OK;
|
|
}
|
|
|
|
class SelectedContentUpdateMicrotask final : public MicroTaskRunnable {
|
|
public:
|
|
explicit SelectedContentUpdateMicrotask(HTMLSelectElement* aSelect)
|
|
: mSelect(aSelect) {}
|
|
MOZ_CAN_RUN_SCRIPT void Run(AutoSlowOperation& aAso) override {
|
|
MOZ_KnownLive(mSelect)->RunPendingSelectedContentUpdate();
|
|
}
|
|
|
|
private:
|
|
const RefPtr<HTMLSelectElement> mSelect;
|
|
};
|
|
|
|
void HTMLSelectElement::ScheduleSelectedContentUpdate(
|
|
SelectedContentUpdateMode aMode, bool aForceUpdate) {
|
|
if (!StaticPrefs::dom_select_customizable_select_enabled()) {
|
|
return;
|
|
}
|
|
if (!aForceUpdate && (!IsInComposedDoc() || mSelectedContentUpdatePending)) {
|
|
return;
|
|
}
|
|
mSelectedContentUpdatePending = true;
|
|
if (aMode == SelectedContentUpdateMode::ScriptRunner) {
|
|
nsContentUtils::AddScriptRunner(NewRunnableMethod(
|
|
"HTMLSelectElement::RunPendingSelectedContentUpdate", this,
|
|
&HTMLSelectElement::RunPendingSelectedContentUpdate));
|
|
return;
|
|
}
|
|
CycleCollectedJSContext* ccjsc = CycleCollectedJSContext::Get();
|
|
if (!ccjsc) {
|
|
return;
|
|
}
|
|
RefPtr<MicroTaskRunnable> task = new SelectedContentUpdateMicrotask(this);
|
|
ccjsc->DispatchToMicroTask(task.forget());
|
|
}
|
|
|
|
void HTMLSelectElement::RunPendingSelectedContentUpdate() {
|
|
// Multiple schedulers (a synchronous script runner and a coalesced microtask)
|
|
// can target the same update. Whichever runs first clears the pending flag in
|
|
// UpdateDescendantSelectedContentElements; the rest become no-ops here so the
|
|
// clone runs exactly once.
|
|
if (mSelectedContentUpdatePending) {
|
|
UpdateDescendantSelectedContentElements();
|
|
}
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#update-a-select's-descendant-selectedcontent-elements
|
|
void HTMLSelectElement::UpdateDescendantSelectedContentElements() {
|
|
// All schedulers bail while we're updating, so this must never be re-entrant.
|
|
MOZ_ASSERT(!mIsUpdatingSelectedContent);
|
|
mSelectedContentUpdatePending = false;
|
|
if (!StaticPrefs::dom_select_customizable_select_enabled()) {
|
|
return;
|
|
}
|
|
// 1. If select has the multiple attribute, then return.
|
|
if (Multiple()) {
|
|
return;
|
|
}
|
|
|
|
// 2. Let descendantSelectedcontents be select's descendant selectedcontent
|
|
// elements which are not disabled, in tree order.
|
|
AutoTArray<RefPtr<HTMLSelectedContentElement>, 1> elements;
|
|
for (nsIContent* node = GetFirstChild(); node;
|
|
node = node->GetNextNode(this)) {
|
|
if (auto* sc = HTMLSelectedContentElement::FromNode(node)) {
|
|
if (!sc->IsDisabled()) {
|
|
elements.AppendElement(sc);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. For each selectedcontent of descendantSelectedcontents:
|
|
// Guard against re-entrant scheduling from mutation observer callbacks
|
|
// triggered by our own DOM cloning into selectedcontent elements.
|
|
mIsUpdatingSelectedContent = true;
|
|
for (const auto& sc : elements) {
|
|
// 3.1 Update a selectedcontent given select and selectedcontent.
|
|
UpdateSelectedContentElement(MOZ_KnownLive(sc));
|
|
}
|
|
mIsUpdatingSelectedContent = false;
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#update-a-selectedcontent
|
|
void HTMLSelectElement::UpdateSelectedContentElement(
|
|
HTMLSelectedContentElement* aSelectedContent) {
|
|
MOZ_ASSERT(aSelectedContent);
|
|
// 1. Let option be the first option in select's list of options whose
|
|
// selectedness is true, if any such option exists; otherwise null.
|
|
const int32_t selectedIndex = SelectedIndex();
|
|
RefPtr<HTMLOptionElement> option =
|
|
selectedIndex >= 0 ? Item(static_cast<uint32_t>(selectedIndex)) : nullptr;
|
|
|
|
// 2. If option is null, then clear a selectedcontent given selectedcontent.
|
|
if (!option) {
|
|
aSelectedContent->ClearContent();
|
|
return;
|
|
}
|
|
|
|
// 3. Otherwise, clone an option into a selectedcontent given option and
|
|
// selectedcontent.
|
|
CloneOptionIntoSelectedContent(option, aSelectedContent);
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/#clone-an-option-into-a-selectedcontent
|
|
void HTMLSelectElement::CloneOptionIntoSelectedContent(
|
|
HTMLOptionElement* aOption, HTMLSelectedContentElement* aSelectedContent) {
|
|
MOZ_ASSERT(aOption);
|
|
MOZ_ASSERT(aSelectedContent);
|
|
// 1. If selectedcontent's disabled is true, then return.
|
|
if (aSelectedContent->IsDisabled()) {
|
|
return;
|
|
}
|
|
// 2. Let documentFragment be a new DocumentFragment whose node document is
|
|
// option's node document.
|
|
RefPtr<Document> doc = aOption->OwnerDoc();
|
|
RefPtr<DocumentFragment> fragment = doc->CreateDocumentFragment();
|
|
|
|
// 3. For each child of option's children:
|
|
for (nsIContent* child = aOption->GetFirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
// 3.1 Let childClone be the result of running clone given child with
|
|
// subtree set to true.
|
|
if (RefPtr childClone = child->CloneNode(true, IgnoreErrors())) {
|
|
// 3.2 Append childClone to documentFragment.
|
|
fragment->AppendChild(*childClone, IgnoreErrors());
|
|
}
|
|
}
|
|
|
|
// 4. Replace all with documentFragment within selectedcontent.
|
|
aSelectedContent->ReplaceChildren(fragment, IgnoreErrors());
|
|
}
|
|
|
|
} // namespace mozilla::dom
|