forked from mirrors/gecko-dev
3342b6100d
In order to speed up IsDisabled(), instead of querying for the @disabled attribute, we're now using the NS_EVENT_STATE_DISABLED flag to know whether an element is disabled. It is safe to use the NS_EVENT_STATE_DISABLED flag for the following reasons: - For form elements, nsGenericHTMLFormElement::IsDisabled() is only called on form elements that can be disabled; form elements that can't be disabled overrides IsDisabled() to return false directly. And, before this patch, NS_EVENT_STATE_DISABLED flag is set by nsGenericHTMLFormElement::IntrinsicState() if and only if IsDisabled() in all cases when CanBeDisabled() is true, and when CanBeDisabled() is false then IsDisabled() is always false and the flag is not set. - For non form elements, optgroup and option have the flag matching IsDisabled(). Note that option's IsDisabled() should also refer to optgroup's (if it exists) disabled state, which was not done before this patch. For this to work correctly, we need to set NS_EVENT_STATE_DISABLED earlier, that is, in AfterSetAttr(), before any consumer of IsDisabled(). We also need to update the flag whenever the element's parent (e.g. fieldset or optgroup) disabled state changes and when moving into/out of a parent container. Note that NS_EVENT_STATE_DISABLED/ENABLED is now part of the EXTERNALLY_MANAGED_STATES. MozReview-Commit-ID: KSceikeqvvU
141 lines
4.1 KiB
C++
141 lines
4.1 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/EventDispatcher.h"
|
|
#include "mozilla/EventStates.h"
|
|
#include "mozilla/dom/HTMLOptGroupElement.h"
|
|
#include "mozilla/dom/HTMLOptGroupElementBinding.h"
|
|
#include "mozilla/dom/HTMLSelectElement.h" // SafeOptionListMutation
|
|
#include "nsGkAtoms.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsIFormControlFrame.h"
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT(OptGroup)
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
|
|
/**
|
|
* The implementation of <optgroup>
|
|
*/
|
|
|
|
|
|
|
|
HTMLOptGroupElement::HTMLOptGroupElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
|
|
: nsGenericHTMLElement(aNodeInfo)
|
|
{
|
|
// We start off enabled
|
|
AddStatesSilently(NS_EVENT_STATE_ENABLED);
|
|
}
|
|
|
|
HTMLOptGroupElement::~HTMLOptGroupElement()
|
|
{
|
|
}
|
|
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(HTMLOptGroupElement, nsGenericHTMLElement,
|
|
nsIDOMHTMLOptGroupElement)
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLOptGroupElement)
|
|
|
|
|
|
nsresult
|
|
HTMLOptGroupElement::GetEventTargetParent(EventChainPreVisitor& aVisitor)
|
|
{
|
|
aVisitor.mCanHandle = false;
|
|
// Do not process any DOM events if the element is disabled
|
|
// XXXsmaug This is not the right thing to do. But what is?
|
|
if (HasAttr(kNameSpaceID_None, nsGkAtoms::disabled)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIFrame* frame = GetPrimaryFrame();
|
|
if (frame) {
|
|
const nsStyleUserInterface* uiStyle = frame->StyleUserInterface();
|
|
if (uiStyle->mUserInput == StyleUserInput::None ||
|
|
uiStyle->mUserInput == StyleUserInput::Disabled) {
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::GetEventTargetParent(aVisitor);
|
|
}
|
|
|
|
Element*
|
|
HTMLOptGroupElement::GetSelect()
|
|
{
|
|
Element* parent = nsINode::GetParentElement();
|
|
if (!parent || !parent->IsHTMLElement(nsGkAtoms::select)) {
|
|
return nullptr;
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
nsresult
|
|
HTMLOptGroupElement::InsertChildAt(nsIContent* aKid,
|
|
uint32_t aIndex,
|
|
bool aNotify)
|
|
{
|
|
SafeOptionListMutation safeMutation(GetSelect(), this, aKid, aIndex, aNotify);
|
|
nsresult rv = nsGenericHTMLElement::InsertChildAt(aKid, aIndex, aNotify);
|
|
if (NS_FAILED(rv)) {
|
|
safeMutation.MutationFailed();
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
void
|
|
HTMLOptGroupElement::RemoveChildAt(uint32_t aIndex, bool aNotify)
|
|
{
|
|
SafeOptionListMutation safeMutation(GetSelect(), this, nullptr, aIndex,
|
|
aNotify);
|
|
nsGenericHTMLElement::RemoveChildAt(aIndex, aNotify);
|
|
}
|
|
|
|
nsresult
|
|
HTMLOptGroupElement::AfterSetAttr(int32_t aNameSpaceID, nsIAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue, bool aNotify)
|
|
{
|
|
if (aNameSpaceID == kNameSpaceID_None && aName == nsGkAtoms::disabled) {
|
|
|
|
EventStates disabledStates;
|
|
if (aValue) {
|
|
disabledStates |= NS_EVENT_STATE_DISABLED;
|
|
} else {
|
|
disabledStates |= NS_EVENT_STATE_ENABLED;
|
|
}
|
|
|
|
EventStates oldDisabledStates = State() & DISABLED_STATES;
|
|
EventStates changedStates = disabledStates ^ oldDisabledStates;
|
|
|
|
if (!changedStates.IsEmpty()) {
|
|
ToggleStates(changedStates, aNotify);
|
|
|
|
// All our children <option> have their :disabled state depending on our
|
|
// disabled attribute. We should make sure their state is updated.
|
|
for (nsIContent* child = nsINode::GetFirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
if (auto optElement = HTMLOptionElement::FromContent(child)) {
|
|
optElement->OptGroupDisabledChanged(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::AfterSetAttr(aNameSpaceID, aName, aValue,
|
|
aOldValue, aNotify);
|
|
}
|
|
|
|
JSObject*
|
|
HTMLOptGroupElement::WrapNode(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
|
|
{
|
|
return HTMLOptGroupElementBinding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|