diff options
Diffstat (limited to '')
| -rw-r--r-- | accessible/html/HTMLFormControlAccessible.cpp | 797 |
1 files changed, 797 insertions, 0 deletions
diff --git a/accessible/html/HTMLFormControlAccessible.cpp b/accessible/html/HTMLFormControlAccessible.cpp new file mode 100644 index 0000000000..ed0da75622 --- /dev/null +++ b/accessible/html/HTMLFormControlAccessible.cpp @@ -0,0 +1,797 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "HTMLFormControlAccessible.h" + +#include "Accessible-inl.h" +#include "nsAccUtils.h" +#include "nsEventShell.h" +#include "nsTextEquivUtils.h" +#include "Relation.h" +#include "Role.h" +#include "States.h" + +#include "nsContentList.h" +#include "mozilla/dom/HTMLInputElement.h" +#include "mozilla/dom/HTMLTextAreaElement.h" +#include "nsIFormControl.h" +#include "nsIPersistentProperties2.h" +#include "nsITextControlFrame.h" +#include "nsNameSpaceManager.h" +#include "mozilla/dom/ScriptSettings.h" + +#include "mozilla/EventStates.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/Preferences.h" +#include "mozilla/TextEditor.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::a11y; + +//////////////////////////////////////////////////////////////////////////////// +// HTMLFormAccessible +//////////////////////////////////////////////////////////////////////////////// + +role HTMLFormAccessible::NativeRole() const { + nsAutoString name; + const_cast<HTMLFormAccessible*>(this)->Name(name); + return name.IsEmpty() ? roles::FORM : roles::FORM_LANDMARK; +} + +nsAtom* HTMLFormAccessible::LandmarkRole() const { + if (!HasOwnContent()) { + return nullptr; + } + + // Only return xml-roles "form" if the form has an accessible name. + nsAutoString name; + const_cast<HTMLFormAccessible*>(this)->Name(name); + return name.IsEmpty() ? HyperTextAccessibleWrap::LandmarkRole() + : nsGkAtoms::form; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLRadioButtonAccessible +//////////////////////////////////////////////////////////////////////////////// + +uint64_t HTMLRadioButtonAccessible::NativeState() const { + uint64_t state = AccessibleWrap::NativeState(); + + state |= states::CHECKABLE; + + HTMLInputElement* input = HTMLInputElement::FromNode(mContent); + if (input && input->Checked()) state |= states::CHECKED; + + return state; +} + +void HTMLRadioButtonAccessible::GetPositionAndSizeInternal(int32_t* aPosInSet, + int32_t* aSetSize) { + Unused << ComputeGroupAttributes(aPosInSet, aSetSize); +} + +Relation HTMLRadioButtonAccessible::ComputeGroupAttributes( + int32_t* aPosInSet, int32_t* aSetSize) const { + Relation rel = Relation(); + int32_t namespaceId = mContent->NodeInfo()->NamespaceID(); + nsAutoString tagName; + mContent->NodeInfo()->GetName(tagName); + + nsAutoString type; + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::type, type); + nsAutoString name; + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name); + + RefPtr<nsContentList> inputElms; + + nsCOMPtr<nsIFormControl> formControlNode(do_QueryInterface(mContent)); + if (dom::Element* formElm = formControlNode->GetFormElement()) { + inputElms = NS_GetContentList(formElm, namespaceId, tagName); + } else { + inputElms = NS_GetContentList(mContent->OwnerDoc(), namespaceId, tagName); + } + NS_ENSURE_TRUE(inputElms, rel); + + uint32_t inputCount = inputElms->Length(false); + + // Compute posinset and setsize. + int32_t indexOf = 0; + int32_t count = 0; + + for (uint32_t index = 0; index < inputCount; index++) { + nsIContent* inputElm = inputElms->Item(index, false); + if (inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, + type, eCaseMatters) && + inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name, + name, eCaseMatters) && + mDoc->HasAccessible(inputElm)) { + count++; + rel.AppendTarget(mDoc->GetAccessible(inputElm)); + if (inputElm == mContent) indexOf = count; + } + } + + *aPosInSet = indexOf; + *aSetSize = count; + return rel; +} + +Relation HTMLRadioButtonAccessible::RelationByType(RelationType aType) const { + if (aType == RelationType::MEMBER_OF) { + int32_t unusedPos, unusedSetSize; + return ComputeGroupAttributes(&unusedPos, &unusedSetSize); + } + + return Accessible::RelationByType(aType); +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLButtonAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLButtonAccessible::HTMLButtonAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) { + mGenericTypes |= eButton; +} + +uint8_t HTMLButtonAccessible::ActionCount() const { return 1; } + +void HTMLButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) { + if (aIndex == eAction_Click) aName.AssignLiteral("press"); +} + +bool HTMLButtonAccessible::DoAction(uint8_t aIndex) const { + if (aIndex != eAction_Click) return false; + + DoCommand(); + return true; +} + +uint64_t HTMLButtonAccessible::State() { + uint64_t state = HyperTextAccessibleWrap::State(); + if (state == states::DEFUNCT) return state; + + // Inherit states from input@type="file" suitable for the button. Note, + // no special processing for unavailable state since inheritance is supplied + // other code paths. + if (mParent && mParent->IsHTMLFileInput()) { + uint64_t parentState = mParent->State(); + state |= parentState & (states::BUSY | states::REQUIRED | states::HASPOPUP | + states::INVALID); + } + + return state; +} + +uint64_t HTMLButtonAccessible::NativeState() const { + uint64_t state = HyperTextAccessibleWrap::NativeState(); + + EventStates elmState = mContent->AsElement()->State(); + if (elmState.HasState(NS_EVENT_STATE_DEFAULT)) state |= states::DEFAULT; + + return state; +} + +role HTMLButtonAccessible::NativeRole() const { return roles::PUSHBUTTON; } + +ENameValueFlag HTMLButtonAccessible::NativeName(nsString& aName) const { + // No need to check @value attribute for buttons since this attribute results + // in native anonymous text node and the name is calculated from subtree. + // The same magic works for @alt and @value attributes in case of type="image" + // element that has no valid @src (note if input@type="image" has an image + // then neither @alt nor @value attributes are used to generate a visual label + // and thus we need to obtain the accessible name directly from attribute + // value). Also the same algorithm works in case of default labels for + // type="submit"/"reset"/"image" elements. + + ENameValueFlag nameFlag = Accessible::NativeName(aName); + if (!aName.IsEmpty() || !mContent->IsHTMLElement(nsGkAtoms::input) || + !mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, + nsGkAtoms::image, eCaseMatters)) + return nameFlag; + + if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aName)) + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aName); + + aName.CompressWhitespace(); + return eNameOK; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLButtonAccessible: Widgets + +bool HTMLButtonAccessible::IsWidget() const { return true; } + +//////////////////////////////////////////////////////////////////////////////// +// HTMLTextFieldAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLTextFieldAccessible::HTMLTextFieldAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) { + mType = mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, + nsGkAtoms::password, eIgnoreCase) + ? eHTMLTextPasswordFieldType + : eHTMLTextFieldType; +} + +role HTMLTextFieldAccessible::NativeRole() const { + if (mType == eHTMLTextPasswordFieldType) { + return roles::PASSWORD_TEXT; + } + if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) { + return roles::EDITCOMBOBOX; + } + return roles::ENTRY; +} + +already_AddRefed<nsIPersistentProperties> +HTMLTextFieldAccessible::NativeAttributes() { + nsCOMPtr<nsIPersistentProperties> attributes = + HyperTextAccessibleWrap::NativeAttributes(); + + // Expose type for text input elements as it gives some useful context, + // especially for mobile. + nsAutoString type; + // In the case of this element being part of a binding, the binding's + // parent's type should have precedence. For example an input[type=number] + // has an embedded anonymous input[type=text] (along with spinner buttons). + // In that case, we would want to take the input type from the parent + // and not the anonymous content. + nsIContent* widgetElm = BindingOrWidgetParent(); + if ((widgetElm && widgetElm->AsElement()->GetAttr(kNameSpaceID_None, + nsGkAtoms::type, type)) || + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::type, + type)) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::textInputType, type); + if (!ARIARoleMap() && type.EqualsLiteral("search")) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::xmlroles, u"searchbox"_ns); + } + } + + // If this element has the placeholder attribute set, + // and if that is not identical to the name, expose it as an object attribute. + nsAutoString placeholderText; + if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, + placeholderText)) { + nsAutoString name; + const_cast<HTMLTextFieldAccessible*>(this)->Name(name); + if (!name.Equals(placeholderText)) { + nsAccUtils::SetAccAttr(attributes, nsGkAtoms::placeholder, + placeholderText); + } + } + + return attributes.forget(); +} + +ENameValueFlag HTMLTextFieldAccessible::NativeName(nsString& aName) const { + ENameValueFlag nameFlag = Accessible::NativeName(aName); + if (!aName.IsEmpty()) return nameFlag; + + // If part of compound of XUL widget then grab a name from XUL widget element. + nsIContent* widgetElm = BindingOrWidgetParent(); + if (widgetElm) XULElmName(mDoc, widgetElm, aName); + + if (!aName.IsEmpty()) return eNameOK; + + // text inputs and textareas might have useful placeholder text + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder, + aName); + return eNameOK; +} + +void HTMLTextFieldAccessible::Value(nsString& aValue) const { + aValue.Truncate(); + if (NativeState() & states::PROTECTED) // Don't return password text! + return; + + HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(mContent); + if (textArea) { + textArea->GetValue(aValue); + return; + } + + HTMLInputElement* input = HTMLInputElement::FromNode(mContent); + if (input) { + // Pass NonSystem as the caller type, to be safe. We don't expect to have a + // file input here. + input->GetValue(aValue, CallerType::NonSystem); + } +} + +void HTMLTextFieldAccessible::ApplyARIAState(uint64_t* aState) const { + HyperTextAccessibleWrap::ApplyARIAState(aState); + aria::MapToState(aria::eARIAAutoComplete, mContent->AsElement(), aState); + + // If part of compound of XUL widget then pick up ARIA stuff from XUL widget + // element. + nsIContent* widgetElm = BindingOrWidgetParent(); + if (widgetElm) + aria::MapToState(aria::eARIAAutoComplete, widgetElm->AsElement(), aState); +} + +uint64_t HTMLTextFieldAccessible::NativeState() const { + uint64_t state = HyperTextAccessibleWrap::NativeState(); + + // Text fields are always editable, even if they are also read only or + // disabled. + state |= states::EDITABLE; + + // can be focusable, focused, protected. readonly, unavailable, selected + if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, + nsGkAtoms::password, eIgnoreCase)) { + state |= states::PROTECTED; + } + + if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::readonly)) { + state |= states::READONLY; + } + + // Is it an <input> or a <textarea> ? + HTMLInputElement* input = HTMLInputElement::FromNode(mContent); + state |= input && input->IsSingleLineTextControl() ? states::SINGLE_LINE + : states::MULTI_LINE; + + if (state & (states::PROTECTED | states::MULTI_LINE | states::READONLY | + states::UNAVAILABLE)) + return state; + + // Expose autocomplete states if this input is part of autocomplete widget. + Accessible* widget = ContainerWidget(); + if (widget && widget - IsAutoComplete()) { + state |= states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION; + return state; + } + + // Expose autocomplete state if it has associated autocomplete list. + if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) + return state | states::SUPPORTS_AUTOCOMPLETION | states::HASPOPUP; + + // Ordinal XUL textboxes don't support autocomplete. + if (!BindingOrWidgetParent() && + Preferences::GetBool("browser.formfill.enable")) { + // Check to see if autocompletion is allowed on this input. We don't expose + // it for password fields even though the entire password can be remembered + // for a page if the user asks it to be. However, the kind of autocomplete + // we're talking here is based on what the user types, where a popup of + // possible choices comes up. + nsAutoString autocomplete; + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete, + autocomplete); + + if (!autocomplete.LowerCaseEqualsLiteral("off")) { + Element* formElement = input->GetFormElement(); + if (formElement) { + formElement->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete, + autocomplete); + } + + if (!formElement || !autocomplete.LowerCaseEqualsLiteral("off")) + state |= states::SUPPORTS_AUTOCOMPLETION; + } + } + + return state; +} + +uint8_t HTMLTextFieldAccessible::ActionCount() const { return 1; } + +void HTMLTextFieldAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) { + if (aIndex == eAction_Click) aName.AssignLiteral("activate"); +} + +bool HTMLTextFieldAccessible::DoAction(uint8_t aIndex) const { + if (aIndex != 0) return false; + + if (FocusMgr()->IsFocused(this)) { + // This already has focus, so TakeFocus()will do nothing. However, the user + // might be activating this element because they dismissed a touch keyboard + // and want to bring it back. + DoCommand(); + } else { + TakeFocus(); + } + return true; +} + +already_AddRefed<TextEditor> HTMLTextFieldAccessible::GetEditor() const { + RefPtr<TextControlElement> textControlElement = + TextControlElement::FromNodeOrNull(mContent); + if (!textControlElement) { + return nullptr; + } + RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor(); + return textEditor.forget(); +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLTextFieldAccessible: Widgets + +bool HTMLTextFieldAccessible::IsWidget() const { return true; } + +Accessible* HTMLTextFieldAccessible::ContainerWidget() const { + if (!mParent || mParent->Role() != roles::AUTOCOMPLETE) { + return nullptr; + } + return mParent; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLFileInputAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLFileInputAccessible::HTMLFileInputAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) { + mType = eHTMLFileInputType; +} + +role HTMLFileInputAccessible::NativeRole() const { + // No specific role in AT APIs. We use GROUPING so that the label will be + // reported by screen readers when focus enters this control . + return roles::GROUPING; +} + +nsresult HTMLFileInputAccessible::HandleAccEvent(AccEvent* aEvent) { + nsresult rv = HyperTextAccessibleWrap::HandleAccEvent(aEvent); + NS_ENSURE_SUCCESS(rv, rv); + + // Redirect state change events for inherited states to child controls. Note, + // unavailable state is not redirected. That's a standard for unavailable + // state handling. + AccStateChangeEvent* event = downcast_accEvent(aEvent); + if (event && (event->GetState() == states::BUSY || + event->GetState() == states::REQUIRED || + event->GetState() == states::HASPOPUP || + event->GetState() == states::INVALID)) { + Accessible* button = GetChildAt(0); + if (button && button->Role() == roles::PUSHBUTTON) { + RefPtr<AccStateChangeEvent> childEvent = new AccStateChangeEvent( + button, event->GetState(), event->IsStateEnabled(), + event->FromUserInput()); + nsEventShell::FireEvent(childEvent); + } + } + + return NS_OK; +} + +Accessible* HTMLFileInputAccessible::CurrentItem() const { + // Allow aria-activedescendant to override. + if (Accessible* item = HyperTextAccessibleWrap::CurrentItem()) { + return item; + } + + // The HTML file input itself gets DOM focus, not the button inside it. + // For a11y, we want the button to get focus. + Accessible* button = FirstChild(); + if (!button) { + MOZ_ASSERT_UNREACHABLE("File input doesn't contain a button"); + return nullptr; + } + MOZ_ASSERT(button->IsButton()); + return button; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLSpinnerAccessible +//////////////////////////////////////////////////////////////////////////////// + +role HTMLSpinnerAccessible::NativeRole() const { return roles::SPINBUTTON; } + +void HTMLSpinnerAccessible::Value(nsString& aValue) const { + HTMLTextFieldAccessible::Value(aValue); + if (!aValue.IsEmpty()) return; + + // Pass NonSystem as the caller type, to be safe. We don't expect to have a + // file input here. + HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem); +} + +double HTMLSpinnerAccessible::MaxValue() const { + double value = HTMLTextFieldAccessible::MaxValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble(); +} + +double HTMLSpinnerAccessible::MinValue() const { + double value = HTMLTextFieldAccessible::MinValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble(); +} + +double HTMLSpinnerAccessible::Step() const { + double value = HTMLTextFieldAccessible::Step(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetStep().toDouble(); +} + +double HTMLSpinnerAccessible::CurValue() const { + double value = HTMLTextFieldAccessible::CurValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble(); +} + +bool HTMLSpinnerAccessible::SetCurValue(double aValue) { + ErrorResult er; + HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er); + return !er.Failed(); +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLRangeAccessible +//////////////////////////////////////////////////////////////////////////////// + +role HTMLRangeAccessible::NativeRole() const { return roles::SLIDER; } + +bool HTMLRangeAccessible::IsWidget() const { return true; } + +void HTMLRangeAccessible::Value(nsString& aValue) const { + LeafAccessible::Value(aValue); + if (!aValue.IsEmpty()) return; + + // Pass NonSystem as the caller type, to be safe. We don't expect to have a + // file input here. + HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem); +} + +double HTMLRangeAccessible::MaxValue() const { + double value = LeafAccessible::MaxValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble(); +} + +double HTMLRangeAccessible::MinValue() const { + double value = LeafAccessible::MinValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble(); +} + +double HTMLRangeAccessible::Step() const { + double value = LeafAccessible::Step(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetStep().toDouble(); +} + +double HTMLRangeAccessible::CurValue() const { + double value = LeafAccessible::CurValue(); + if (!IsNaN(value)) return value; + + return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble(); +} + +bool HTMLRangeAccessible::SetCurValue(double aValue) { + ErrorResult er; + HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er); + return !er.Failed(); +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLGroupboxAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLGroupboxAccessible::HTMLGroupboxAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) {} + +role HTMLGroupboxAccessible::NativeRole() const { return roles::GROUPING; } + +nsIContent* HTMLGroupboxAccessible::GetLegend() const { + for (nsIContent* legendContent = mContent->GetFirstChild(); legendContent; + legendContent = legendContent->GetNextSibling()) { + if (legendContent->NodeInfo()->Equals(nsGkAtoms::legend, + mContent->GetNameSpaceID())) { + // Either XHTML namespace or no namespace + return legendContent; + } + } + + return nullptr; +} + +ENameValueFlag HTMLGroupboxAccessible::NativeName(nsString& aName) const { + ENameValueFlag nameFlag = Accessible::NativeName(aName); + if (!aName.IsEmpty()) return nameFlag; + + nsIContent* legendContent = GetLegend(); + if (legendContent) + nsTextEquivUtils::AppendTextEquivFromContent(this, legendContent, &aName); + + aName.CompressWhitespace(); + return eNameOK; +} + +Relation HTMLGroupboxAccessible::RelationByType(RelationType aType) const { + Relation rel = HyperTextAccessibleWrap::RelationByType(aType); + // No override for label, so use <legend> for this <fieldset> + if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, GetLegend()); + + return rel; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLLegendAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLLegendAccessible::HTMLLegendAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) {} + +Relation HTMLLegendAccessible::RelationByType(RelationType aType) const { + Relation rel = HyperTextAccessibleWrap::RelationByType(aType); + if (aType != RelationType::LABEL_FOR) return rel; + + Accessible* groupbox = Parent(); + if (groupbox && groupbox->Role() == roles::GROUPING) + rel.AppendTarget(groupbox); + + return rel; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLFigureAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLFigureAccessible::HTMLFigureAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) {} + +ENameValueFlag HTMLFigureAccessible::NativeName(nsString& aName) const { + ENameValueFlag nameFlag = HyperTextAccessibleWrap::NativeName(aName); + if (!aName.IsEmpty()) return nameFlag; + + nsIContent* captionContent = Caption(); + if (captionContent) + nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent, &aName); + + aName.CompressWhitespace(); + return eNameOK; +} + +Relation HTMLFigureAccessible::RelationByType(RelationType aType) const { + Relation rel = HyperTextAccessibleWrap::RelationByType(aType); + if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, Caption()); + + return rel; +} + +nsIContent* HTMLFigureAccessible::Caption() const { + for (nsIContent* childContent = mContent->GetFirstChild(); childContent; + childContent = childContent->GetNextSibling()) { + if (childContent->NodeInfo()->Equals(nsGkAtoms::figcaption, + mContent->GetNameSpaceID())) { + return childContent; + } + } + + return nullptr; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLFigcaptionAccessible +//////////////////////////////////////////////////////////////////////////////// + +HTMLFigcaptionAccessible::HTMLFigcaptionAccessible(nsIContent* aContent, + DocAccessible* aDoc) + : HyperTextAccessibleWrap(aContent, aDoc) {} + +Relation HTMLFigcaptionAccessible::RelationByType(RelationType aType) const { + Relation rel = HyperTextAccessibleWrap::RelationByType(aType); + if (aType != RelationType::LABEL_FOR) return rel; + + Accessible* figure = Parent(); + if (figure && figure->GetContent()->NodeInfo()->Equals( + nsGkAtoms::figure, mContent->GetNameSpaceID())) { + rel.AppendTarget(figure); + } + + return rel; +} + +//////////////////////////////////////////////////////////////////////////////// +// HTMLProgressAccessible +//////////////////////////////////////////////////////////////////////////////// + +role HTMLProgressAccessible::NativeRole() const { return roles::PROGRESSBAR; } + +uint64_t HTMLProgressAccessible::NativeState() const { + uint64_t state = LeafAccessible::NativeState(); + + // An undetermined progressbar (i.e. without a value) has a mixed state. + nsAutoString attrValue; + mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, + attrValue); + if (attrValue.IsEmpty()) { + state |= states::MIXED; + } + + return state; +} + +bool HTMLProgressAccessible::IsWidget() const { return true; } + +void HTMLProgressAccessible::Value(nsString& aValue) const { + LeafAccessible::Value(aValue); + if (!aValue.IsEmpty()) { + return; + } + + double maxValue = MaxValue(); + if (IsNaN(maxValue) || maxValue == 0) { + return; + } + + double curValue = CurValue(); + if (IsNaN(curValue)) { + return; + } + + // Treat the current value bigger than maximum as 100%. + double percentValue = + (curValue < maxValue) ? (curValue / maxValue) * 100 : 100; + + aValue.AppendFloat(percentValue); + aValue.Append('%'); +} + +double HTMLProgressAccessible::MaxValue() const { + double value = LeafAccessible::MaxValue(); + if (!IsNaN(value)) { + return value; + } + + nsAutoString strValue; + if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::max, + strValue)) { + nsresult result = NS_OK; + value = strValue.ToDouble(&result); + if (NS_SUCCEEDED(result)) { + return value; + } + } + + return 1; +} + +double HTMLProgressAccessible::MinValue() const { + double value = LeafAccessible::MinValue(); + return IsNaN(value) ? 0 : value; +} + +double HTMLProgressAccessible::Step() const { + double value = LeafAccessible::Step(); + return IsNaN(value) ? 0 : value; +} + +double HTMLProgressAccessible::CurValue() const { + double value = LeafAccessible::CurValue(); + if (!IsNaN(value)) { + return value; + } + + nsAutoString attrValue; + if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, + attrValue)) { + return UnspecifiedNaN<double>(); + } + + nsresult error = NS_OK; + value = attrValue.ToDouble(&error); + return NS_FAILED(error) ? UnspecifiedNaN<double>() : value; +} + +bool HTMLProgressAccessible::SetCurValue(double aValue) { + return false; // progress meters are readonly. +} |