accessible/html/HTMLFormControlAccessible.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "HTMLFormControlAccessible.h"
   7
   8 #include "DocAccessible-inl.h"
   9 #include "LocalAccessible-inl.h"
  10 #include "nsAccUtils.h"
  11 #include "nsEventShell.h"
  12 #include "nsTextEquivUtils.h"
  13 #include "Relation.h"
  14 #include "Role.h"
  15 #include "States.h"
  16
  17 #include "nsContentList.h"
  18 #include "mozilla/dom/HTMLInputElement.h"
  19 #include "mozilla/dom/HTMLTextAreaElement.h"
  20 #include "nsIFormControl.h"
  21 #include "nsITextControlFrame.h"
  22 #include "nsNameSpaceManager.h"
  23 #include "mozilla/dom/ScriptSettings.h"
  24
  25 #include "mozilla/EditorBase.h"
  26 #include "mozilla/EventStates.h"
  27 #include "mozilla/FloatingPoint.h"
  28 #include "mozilla/Preferences.h"
  29 #include "mozilla/TextEditor.h"
  30
  31 using namespace mozilla;
  32 using namespace mozilla::dom;
  33 using namespace mozilla::a11y;
  34
  35 ////////////////////////////////////////////////////////////////////////////////
  36 // HTMLFormAccessible
  37 ////////////////////////////////////////////////////////////////////////////////
  38
  39 role HTMLFormAccessible::NativeRole() const {
  40   nsAutoString name;
  41   const_cast<HTMLFormAccessible*>(this)->Name(name);
  42   return name.IsEmpty() ? roles::FORM : roles::FORM_LANDMARK;
  43 }
  44
  45 nsAtom* HTMLFormAccessible::LandmarkRole() const {
  46   if (!HasOwnContent()) {
  47     return nullptr;
  48   }
  49
  50   // Only return xml-roles "form" if the form has an accessible name.
  51   nsAutoString name;
  52   const_cast<HTMLFormAccessible*>(this)->Name(name);
  53   return name.IsEmpty() ? HyperTextAccessibleWrap::LandmarkRole()
  54                         : nsGkAtoms::form;
  55 }
  56
  57 ////////////////////////////////////////////////////////////////////////////////
  58 // HTMLRadioButtonAccessible
  59 ////////////////////////////////////////////////////////////////////////////////
  60
  61 uint64_t HTMLRadioButtonAccessible::NativeState() const {
  62   uint64_t state = AccessibleWrap::NativeState();
  63
  64   state |= states::CHECKABLE;
  65
  66   HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
  67   if (input && input->Checked()) state |= states::CHECKED;
  68
  69   return state;
  70 }
  71
  72 void HTMLRadioButtonAccessible::GetPositionAndSizeInternal(int32_t* aPosInSet,
  73                                                            int32_t* aSetSize) {
  74   Unused << ComputeGroupAttributes(aPosInSet, aSetSize);
  75 }
  76
  77 Relation HTMLRadioButtonAccessible::ComputeGroupAttributes(
  78     int32_t* aPosInSet, int32_t* aSetSize) const {
  79   Relation rel = Relation();
  80   int32_t namespaceId = mContent->NodeInfo()->NamespaceID();
  81   nsAutoString tagName;
  82   mContent->NodeInfo()->GetName(tagName);
  83
  84   nsAutoString type;
  85   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::type, type);
  86   nsAutoString name;
  87   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::name, name);
  88
  89   RefPtr<nsContentList> inputElms;
  90
  91   nsCOMPtr<nsIFormControl> formControlNode(do_QueryInterface(mContent));
  92   if (dom::Element* formElm = formControlNode->GetForm()) {
  93     inputElms = NS_GetContentList(formElm, namespaceId, tagName);
  94   } else {
  95     inputElms = NS_GetContentList(mContent->OwnerDoc(), namespaceId, tagName);
  96   }
  97   NS_ENSURE_TRUE(inputElms, rel);
  98
  99   uint32_t inputCount = inputElms->Length(false);
 100
 101   // Compute posinset and setsize.
 102   int32_t indexOf = 0;
 103   int32_t count = 0;
 104
 105   for (uint32_t index = 0; index < inputCount; index++) {
 106     nsIContent* inputElm = inputElms->Item(index, false);
 107     if (inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 108                                            type, eCaseMatters) &&
 109         inputElm->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::name,
 110                                            name, eCaseMatters) &&
 111         mDoc->HasAccessible(inputElm)) {
 112       count++;
 113       rel.AppendTarget(mDoc->GetAccessible(inputElm));
 114       if (inputElm == mContent) indexOf = count;
 115     }
 116   }
 117
 118   *aPosInSet = indexOf;
 119   *aSetSize = count;
 120   return rel;
 121 }
 122
 123 Relation HTMLRadioButtonAccessible::RelationByType(RelationType aType) const {
 124   if (aType == RelationType::MEMBER_OF) {
 125     int32_t unusedPos, unusedSetSize;
 126     return ComputeGroupAttributes(&unusedPos, &unusedSetSize);
 127   }
 128
 129   return LocalAccessible::RelationByType(aType);
 130 }
 131
 132 ////////////////////////////////////////////////////////////////////////////////
 133 // HTMLButtonAccessible
 134 ////////////////////////////////////////////////////////////////////////////////
 135
 136 HTMLButtonAccessible::HTMLButtonAccessible(nsIContent* aContent,
 137                                            DocAccessible* aDoc)
 138     : HyperTextAccessibleWrap(aContent, aDoc) {
 139   mGenericTypes |= eButton;
 140 }
 141
 142 uint8_t HTMLButtonAccessible::ActionCount() const { return 1; }
 143
 144 void HTMLButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
 145   if (aIndex == eAction_Click) aName.AssignLiteral("press");
 146 }
 147
 148 bool HTMLButtonAccessible::DoAction(uint8_t aIndex) const {
 149   if (aIndex != eAction_Click) return false;
 150
 151   DoCommand();
 152   return true;
 153 }
 154
 155 uint64_t HTMLButtonAccessible::State() {
 156   uint64_t state = HyperTextAccessibleWrap::State();
 157   if (state == states::DEFUNCT) return state;
 158
 159   // Inherit states from input@type="file" suitable for the button. Note,
 160   // no special processing for unavailable state since inheritance is supplied
 161   // other code paths.
 162   if (mParent && mParent->IsHTMLFileInput()) {
 163     uint64_t parentState = mParent->State();
 164     state |= parentState & (states::BUSY | states::REQUIRED | states::HASPOPUP |
 165                             states::INVALID);
 166   }
 167
 168   return state;
 169 }
 170
 171 uint64_t HTMLButtonAccessible::NativeState() const {
 172   uint64_t state = HyperTextAccessibleWrap::NativeState();
 173
 174   EventStates elmState = mContent->AsElement()->State();
 175   if (elmState.HasState(NS_EVENT_STATE_DEFAULT)) state |= states::DEFAULT;
 176
 177   return state;
 178 }
 179
 180 role HTMLButtonAccessible::NativeRole() const { return roles::PUSHBUTTON; }
 181
 182 ENameValueFlag HTMLButtonAccessible::NativeName(nsString& aName) const {
 183   // No need to check @value attribute for buttons since this attribute results
 184   // in native anonymous text node and the name is calculated from subtree.
 185   // The same magic works for @alt and @value attributes in case of type="image"
 186   // element that has no valid @src (note if input@type="image" has an image
 187   // then neither @alt nor @value attributes are used to generate a visual label
 188   // and thus we need to obtain the accessible name directly from attribute
 189   // value). Also the same algorithm works in case of default labels for
 190   // type="submit"/"reset"/"image" elements.
 191
 192   ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
 193   if (!aName.IsEmpty() || !mContent->IsHTMLElement(nsGkAtoms::input) ||
 194       !mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 195                                           nsGkAtoms::image, eCaseMatters)) {
 196     return nameFlag;
 197   }
 198
 199   if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::alt,
 200                                       aName)) {
 201     mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value, aName);
 202   }
 203
 204   aName.CompressWhitespace();
 205   return eNameOK;
 206 }
 207
 208 void HTMLButtonAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
 209                                                nsAtom* aAttribute,
 210                                                int32_t aModType,
 211                                                const nsAttrValue* aOldValue,
 212                                                uint64_t aOldState) {
 213   HyperTextAccessibleWrap::DOMAttributeChanged(aNameSpaceID, aAttribute,
 214                                                aModType, aOldValue, aOldState);
 215
 216   if (aAttribute == nsGkAtoms::value) {
 217     dom::Element* elm = Elm();
 218     if (elm->IsHTMLElement(nsGkAtoms::input) ||
 219         (elm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type, nsGkAtoms::image,
 220                           eCaseMatters) &&
 221          !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::alt))) {
 222       if (!elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_labelledby) &&
 223           !elm->HasAttr(kNameSpaceID_None, nsGkAtoms::aria_label)) {
 224         mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
 225       }
 226     }
 227   }
 228 }
 229
 230 ////////////////////////////////////////////////////////////////////////////////
 231 // HTMLButtonAccessible: Widgets
 232
 233 bool HTMLButtonAccessible::IsWidget() const { return true; }
 234
 235 ////////////////////////////////////////////////////////////////////////////////
 236 // HTMLTextFieldAccessible
 237 ////////////////////////////////////////////////////////////////////////////////
 238
 239 HTMLTextFieldAccessible::HTMLTextFieldAccessible(nsIContent* aContent,
 240                                                  DocAccessible* aDoc)
 241     : HyperTextAccessibleWrap(aContent, aDoc) {
 242   mType = mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 243                                              nsGkAtoms::password, eIgnoreCase)
 244               ? eHTMLTextPasswordFieldType
 245               : eHTMLTextFieldType;
 246 }
 247
 248 role HTMLTextFieldAccessible::NativeRole() const {
 249   if (mType == eHTMLTextPasswordFieldType) {
 250     return roles::PASSWORD_TEXT;
 251   }
 252   if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) {
 253     return roles::EDITCOMBOBOX;
 254   }
 255   return roles::ENTRY;
 256 }
 257
 258 already_AddRefed<AccAttributes> HTMLTextFieldAccessible::NativeAttributes() {
 259   RefPtr<AccAttributes> attributes =
 260       HyperTextAccessibleWrap::NativeAttributes();
 261
 262   // Expose type for text input elements as it gives some useful context,
 263   // especially for mobile.
 264   nsAutoString type;
 265   // In the case of this element being part of a binding, the binding's
 266   // parent's type should have precedence. For example an input[type=number]
 267   // has an embedded anonymous input[type=text] (along with spinner buttons).
 268   // In that case, we would want to take the input type from the parent
 269   // and not the anonymous content.
 270   nsIContent* widgetElm = BindingOrWidgetParent();
 271   if ((widgetElm && widgetElm->AsElement()->GetAttr(kNameSpaceID_None,
 272                                                     nsGkAtoms::type, type)) ||
 273       mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::type,
 274                                      type)) {
 275     attributes->SetAttribute(nsGkAtoms::textInputType, type);
 276     if (!ARIARoleMap() && type.EqualsLiteral("search")) {
 277       attributes->SetAttribute(nsGkAtoms::xmlroles, u"searchbox"_ns);
 278     }
 279   }
 280
 281   // If this element  has the placeholder attribute set,
 282   // and if that is not identical to the name, expose it as an object attribute.
 283   nsAutoString placeholderText;
 284   if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
 285                                      placeholderText)) {
 286     nsAutoString name;
 287     const_cast<HTMLTextFieldAccessible*>(this)->Name(name);
 288     if (!name.Equals(placeholderText)) {
 289       attributes->SetAttribute(nsGkAtoms::placeholder, placeholderText);
 290     }
 291   }
 292
 293   return attributes.forget();
 294 }
 295
 296 ENameValueFlag HTMLTextFieldAccessible::NativeName(nsString& aName) const {
 297   ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
 298   if (!aName.IsEmpty()) return nameFlag;
 299
 300   // If part of compound of XUL widget then grab a name from XUL widget element.
 301   nsIContent* widgetElm = BindingOrWidgetParent();
 302   if (widgetElm) XULElmName(mDoc, widgetElm, aName);
 303
 304   if (!aName.IsEmpty()) return eNameOK;
 305
 306   // text inputs and textareas might have useful placeholder text
 307   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::placeholder,
 308                                  aName);
 309   return eNameOK;
 310 }
 311
 312 void HTMLTextFieldAccessible::Value(nsString& aValue) const {
 313   aValue.Truncate();
 314   if (NativeState() & states::PROTECTED) {  // Don't return password text!
 315     return;
 316   }
 317
 318   HTMLTextAreaElement* textArea = HTMLTextAreaElement::FromNode(mContent);
 319   if (textArea) {
 320     textArea->GetValue(aValue);
 321     return;
 322   }
 323
 324   HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
 325   if (input) {
 326     // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
 327     // file input here.
 328     input->GetValue(aValue, CallerType::NonSystem);
 329   }
 330 }
 331
 332 void HTMLTextFieldAccessible::ApplyARIAState(uint64_t* aState) const {
 333   HyperTextAccessibleWrap::ApplyARIAState(aState);
 334   aria::MapToState(aria::eARIAAutoComplete, mContent->AsElement(), aState);
 335
 336   // If part of compound of XUL widget then pick up ARIA stuff from XUL widget
 337   // element.
 338   nsIContent* widgetElm = BindingOrWidgetParent();
 339   if (widgetElm) {
 340     aria::MapToState(aria::eARIAAutoComplete, widgetElm->AsElement(), aState);
 341   }
 342 }
 343
 344 uint64_t HTMLTextFieldAccessible::NativeState() const {
 345   uint64_t state = HyperTextAccessibleWrap::NativeState();
 346
 347   // Text fields are always editable, even if they are also read only or
 348   // disabled.
 349   state |= states::EDITABLE;
 350
 351   // can be focusable, focused, protected. readonly, unavailable, selected
 352   if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 353                                          nsGkAtoms::password, eIgnoreCase)) {
 354     state |= states::PROTECTED;
 355   }
 356
 357   if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::readonly)) {
 358     state |= states::READONLY;
 359   }
 360
 361   // Is it an <input> or a <textarea> ?
 362   HTMLInputElement* input = HTMLInputElement::FromNode(mContent);
 363   state |= input && input->IsSingleLineTextControl() ? states::SINGLE_LINE
 364                                                      : states::MULTI_LINE;
 365
 366   if (state & (states::PROTECTED | states::MULTI_LINE | states::READONLY |
 367                states::UNAVAILABLE)) {
 368     return state;
 369   }
 370
 371   // Expose autocomplete states if this input is part of autocomplete widget.
 372   LocalAccessible* widget = ContainerWidget();
 373   if (widget && widget - IsAutoComplete()) {
 374     state |= states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION;
 375     return state;
 376   }
 377
 378   // Expose autocomplete state if it has associated autocomplete list.
 379   if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::list_)) {
 380     return state | states::SUPPORTS_AUTOCOMPLETION | states::HASPOPUP;
 381   }
 382
 383   // Ordinal XUL textboxes don't support autocomplete.
 384   if (!BindingOrWidgetParent() &&
 385       Preferences::GetBool("browser.formfill.enable")) {
 386     // Check to see if autocompletion is allowed on this input. We don't expose
 387     // it for password fields even though the entire password can be remembered
 388     // for a page if the user asks it to be. However, the kind of autocomplete
 389     // we're talking here is based on what the user types, where a popup of
 390     // possible choices comes up.
 391     nsAutoString autocomplete;
 392     mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete,
 393                                    autocomplete);
 394
 395     if (!autocomplete.LowerCaseEqualsLiteral("off")) {
 396       Element* formElement = input->GetForm();
 397       if (formElement) {
 398         formElement->GetAttr(kNameSpaceID_None, nsGkAtoms::autocomplete,
 399                              autocomplete);
 400       }
 401
 402       if (!formElement || !autocomplete.LowerCaseEqualsLiteral("off")) {
 403         state |= states::SUPPORTS_AUTOCOMPLETION;
 404       }
 405     }
 406   }
 407
 408   return state;
 409 }
 410
 411 uint8_t HTMLTextFieldAccessible::ActionCount() const { return 1; }
 412
 413 void HTMLTextFieldAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
 414   if (aIndex == eAction_Click) aName.AssignLiteral("activate");
 415 }
 416
 417 bool HTMLTextFieldAccessible::DoAction(uint8_t aIndex) const {
 418   if (aIndex != 0) return false;
 419
 420   if (FocusMgr()->IsFocused(this)) {
 421     // This already has focus, so TakeFocus()will do nothing. However, the user
 422     // might be activating this element because they dismissed a touch keyboard
 423     // and want to bring it back.
 424     DoCommand();
 425   } else {
 426     TakeFocus();
 427   }
 428   return true;
 429 }
 430
 431 already_AddRefed<EditorBase> HTMLTextFieldAccessible::GetEditor() const {
 432   RefPtr<TextControlElement> textControlElement =
 433       TextControlElement::FromNodeOrNull(mContent);
 434   if (!textControlElement) {
 435     return nullptr;
 436   }
 437   RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor();
 438   return textEditor.forget();
 439 }
 440
 441 ////////////////////////////////////////////////////////////////////////////////
 442 // HTMLTextFieldAccessible: Widgets
 443
 444 bool HTMLTextFieldAccessible::IsWidget() const { return true; }
 445
 446 LocalAccessible* HTMLTextFieldAccessible::ContainerWidget() const {
 447   if (!mParent || mParent->Role() != roles::AUTOCOMPLETE) {
 448     return nullptr;
 449   }
 450   return mParent;
 451 }
 452
 453 ////////////////////////////////////////////////////////////////////////////////
 454 // HTMLFileInputAccessible
 455 ////////////////////////////////////////////////////////////////////////////////
 456
 457 HTMLFileInputAccessible::HTMLFileInputAccessible(nsIContent* aContent,
 458                                                  DocAccessible* aDoc)
 459     : HyperTextAccessibleWrap(aContent, aDoc) {
 460   mType = eHTMLFileInputType;
 461 }
 462
 463 role HTMLFileInputAccessible::NativeRole() const {
 464   // No specific role in AT APIs. We use GROUPING so that the label will be
 465   // reported by screen readers when focus enters this control .
 466   return roles::GROUPING;
 467 }
 468
 469 nsresult HTMLFileInputAccessible::HandleAccEvent(AccEvent* aEvent) {
 470   nsresult rv = HyperTextAccessibleWrap::HandleAccEvent(aEvent);
 471   NS_ENSURE_SUCCESS(rv, rv);
 472
 473   // Redirect state change events for inherited states to child controls. Note,
 474   // unavailable state is not redirected. That's a standard for unavailable
 475   // state handling.
 476   AccStateChangeEvent* event = downcast_accEvent(aEvent);
 477   if (event && (event->GetState() == states::BUSY ||
 478                 event->GetState() == states::REQUIRED ||
 479                 event->GetState() == states::HASPOPUP ||
 480                 event->GetState() == states::INVALID)) {
 481     LocalAccessible* button = LocalChildAt(0);
 482     if (button && button->Role() == roles::PUSHBUTTON) {
 483       RefPtr<AccStateChangeEvent> childEvent = new AccStateChangeEvent(
 484           button, event->GetState(), event->IsStateEnabled(),
 485           event->FromUserInput());
 486       nsEventShell::FireEvent(childEvent);
 487     }
 488   }
 489
 490   return NS_OK;
 491 }
 492
 493 LocalAccessible* HTMLFileInputAccessible::CurrentItem() const {
 494   // Allow aria-activedescendant to override.
 495   if (LocalAccessible* item = HyperTextAccessibleWrap::CurrentItem()) {
 496     return item;
 497   }
 498
 499   // The HTML file input itself gets DOM focus, not the button inside it.
 500   // For a11y, we want the button to get focus.
 501   LocalAccessible* button = LocalFirstChild();
 502   if (!button) {
 503     MOZ_ASSERT_UNREACHABLE("File input doesn't contain a button");
 504     return nullptr;
 505   }
 506   MOZ_ASSERT(button->IsButton());
 507   return button;
 508 }
 509
 510 ////////////////////////////////////////////////////////////////////////////////
 511 // HTMLSpinnerAccessible
 512 ////////////////////////////////////////////////////////////////////////////////
 513
 514 role HTMLSpinnerAccessible::NativeRole() const { return roles::SPINBUTTON; }
 515
 516 void HTMLSpinnerAccessible::Value(nsString& aValue) const {
 517   HTMLTextFieldAccessible::Value(aValue);
 518   if (!aValue.IsEmpty()) return;
 519
 520   // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
 521   // file input here.
 522   HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
 523 }
 524
 525 double HTMLSpinnerAccessible::MaxValue() const {
 526   double value = HTMLTextFieldAccessible::MaxValue();
 527   if (!IsNaN(value)) return value;
 528
 529   return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
 530 }
 531
 532 double HTMLSpinnerAccessible::MinValue() const {
 533   double value = HTMLTextFieldAccessible::MinValue();
 534   if (!IsNaN(value)) return value;
 535
 536   return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
 537 }
 538
 539 double HTMLSpinnerAccessible::Step() const {
 540   double value = HTMLTextFieldAccessible::Step();
 541   if (!IsNaN(value)) return value;
 542
 543   return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
 544 }
 545
 546 double HTMLSpinnerAccessible::CurValue() const {
 547   double value = HTMLTextFieldAccessible::CurValue();
 548   if (!IsNaN(value)) return value;
 549
 550   return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
 551 }
 552
 553 bool HTMLSpinnerAccessible::SetCurValue(double aValue) {
 554   ErrorResult er;
 555   HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er);
 556   return !er.Failed();
 557 }
 558
 559 ////////////////////////////////////////////////////////////////////////////////
 560 // HTMLRangeAccessible
 561 ////////////////////////////////////////////////////////////////////////////////
 562
 563 role HTMLRangeAccessible::NativeRole() const { return roles::SLIDER; }
 564
 565 bool HTMLRangeAccessible::IsWidget() const { return true; }
 566
 567 void HTMLRangeAccessible::Value(nsString& aValue) const {
 568   LeafAccessible::Value(aValue);
 569   if (!aValue.IsEmpty()) return;
 570
 571   // Pass NonSystem as the caller type, to be safe.  We don't expect to have a
 572   // file input here.
 573   HTMLInputElement::FromNode(mContent)->GetValue(aValue, CallerType::NonSystem);
 574 }
 575
 576 double HTMLRangeAccessible::MaxValue() const {
 577   double value = LeafAccessible::MaxValue();
 578   if (!IsNaN(value)) return value;
 579
 580   return HTMLInputElement::FromNode(mContent)->GetMaximum().toDouble();
 581 }
 582
 583 double HTMLRangeAccessible::MinValue() const {
 584   double value = LeafAccessible::MinValue();
 585   if (!IsNaN(value)) return value;
 586
 587   return HTMLInputElement::FromNode(mContent)->GetMinimum().toDouble();
 588 }
 589
 590 double HTMLRangeAccessible::Step() const {
 591   double value = LeafAccessible::Step();
 592   if (!IsNaN(value)) return value;
 593
 594   return HTMLInputElement::FromNode(mContent)->GetStep().toDouble();
 595 }
 596
 597 double HTMLRangeAccessible::CurValue() const {
 598   double value = LeafAccessible::CurValue();
 599   if (!IsNaN(value)) return value;
 600
 601   return HTMLInputElement::FromNode(mContent)->GetValueAsDecimal().toDouble();
 602 }
 603
 604 bool HTMLRangeAccessible::SetCurValue(double aValue) {
 605   ErrorResult er;
 606   HTMLInputElement::FromNode(mContent)->SetValueAsNumber(aValue, er);
 607   return !er.Failed();
 608 }
 609
 610 ////////////////////////////////////////////////////////////////////////////////
 611 // HTMLGroupboxAccessible
 612 ////////////////////////////////////////////////////////////////////////////////
 613
 614 HTMLGroupboxAccessible::HTMLGroupboxAccessible(nsIContent* aContent,
 615                                                DocAccessible* aDoc)
 616     : HyperTextAccessibleWrap(aContent, aDoc) {}
 617
 618 role HTMLGroupboxAccessible::NativeRole() const { return roles::GROUPING; }
 619
 620 nsIContent* HTMLGroupboxAccessible::GetLegend() const {
 621   for (nsIContent* legendContent = mContent->GetFirstChild(); legendContent;
 622        legendContent = legendContent->GetNextSibling()) {
 623     if (legendContent->NodeInfo()->Equals(nsGkAtoms::legend,
 624                                           mContent->GetNameSpaceID())) {
 625       // Either XHTML namespace or no namespace
 626       return legendContent;
 627     }
 628   }
 629
 630   return nullptr;
 631 }
 632
 633 ENameValueFlag HTMLGroupboxAccessible::NativeName(nsString& aName) const {
 634   ENameValueFlag nameFlag = LocalAccessible::NativeName(aName);
 635   if (!aName.IsEmpty()) return nameFlag;
 636
 637   nsIContent* legendContent = GetLegend();
 638   if (legendContent) {
 639     nsTextEquivUtils::AppendTextEquivFromContent(this, legendContent, &aName);
 640   }
 641
 642   aName.CompressWhitespace();
 643   return eNameOK;
 644 }
 645
 646 Relation HTMLGroupboxAccessible::RelationByType(RelationType aType) const {
 647   Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
 648   // No override for label, so use <legend> for this <fieldset>
 649   if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, GetLegend());
 650
 651   return rel;
 652 }
 653
 654 ////////////////////////////////////////////////////////////////////////////////
 655 // HTMLLegendAccessible
 656 ////////////////////////////////////////////////////////////////////////////////
 657
 658 HTMLLegendAccessible::HTMLLegendAccessible(nsIContent* aContent,
 659                                            DocAccessible* aDoc)
 660     : HyperTextAccessibleWrap(aContent, aDoc) {}
 661
 662 Relation HTMLLegendAccessible::RelationByType(RelationType aType) const {
 663   Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
 664   if (aType != RelationType::LABEL_FOR) return rel;
 665
 666   LocalAccessible* groupbox = LocalParent();
 667   if (groupbox && groupbox->Role() == roles::GROUPING) {
 668     rel.AppendTarget(groupbox);
 669   }
 670
 671   return rel;
 672 }
 673
 674 ////////////////////////////////////////////////////////////////////////////////
 675 // HTMLFigureAccessible
 676 ////////////////////////////////////////////////////////////////////////////////
 677
 678 HTMLFigureAccessible::HTMLFigureAccessible(nsIContent* aContent,
 679                                            DocAccessible* aDoc)
 680     : HyperTextAccessibleWrap(aContent, aDoc) {}
 681
 682 ENameValueFlag HTMLFigureAccessible::NativeName(nsString& aName) const {
 683   ENameValueFlag nameFlag = HyperTextAccessibleWrap::NativeName(aName);
 684   if (!aName.IsEmpty()) return nameFlag;
 685
 686   nsIContent* captionContent = Caption();
 687   if (captionContent) {
 688     nsTextEquivUtils::AppendTextEquivFromContent(this, captionContent, &aName);
 689   }
 690
 691   aName.CompressWhitespace();
 692   return eNameOK;
 693 }
 694
 695 Relation HTMLFigureAccessible::RelationByType(RelationType aType) const {
 696   Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
 697   if (aType == RelationType::LABELLED_BY) rel.AppendTarget(mDoc, Caption());
 698
 699   return rel;
 700 }
 701
 702 nsIContent* HTMLFigureAccessible::Caption() const {
 703   for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
 704        childContent = childContent->GetNextSibling()) {
 705     if (childContent->NodeInfo()->Equals(nsGkAtoms::figcaption,
 706                                          mContent->GetNameSpaceID())) {
 707       return childContent;
 708     }
 709   }
 710
 711   return nullptr;
 712 }
 713
 714 ////////////////////////////////////////////////////////////////////////////////
 715 // HTMLFigcaptionAccessible
 716 ////////////////////////////////////////////////////////////////////////////////
 717
 718 HTMLFigcaptionAccessible::HTMLFigcaptionAccessible(nsIContent* aContent,
 719                                                    DocAccessible* aDoc)
 720     : HyperTextAccessibleWrap(aContent, aDoc) {}
 721
 722 Relation HTMLFigcaptionAccessible::RelationByType(RelationType aType) const {
 723   Relation rel = HyperTextAccessibleWrap::RelationByType(aType);
 724   if (aType != RelationType::LABEL_FOR) return rel;
 725
 726   LocalAccessible* figure = LocalParent();
 727   if (figure && figure->GetContent()->NodeInfo()->Equals(
 728                     nsGkAtoms::figure, mContent->GetNameSpaceID())) {
 729     rel.AppendTarget(figure);
 730   }
 731
 732   return rel;
 733 }
 734
 735 ////////////////////////////////////////////////////////////////////////////////
 736 // HTMLProgressAccessible
 737 ////////////////////////////////////////////////////////////////////////////////
 738
 739 role HTMLProgressAccessible::NativeRole() const { return roles::PROGRESSBAR; }
 740
 741 uint64_t HTMLProgressAccessible::NativeState() const {
 742   uint64_t state = LeafAccessible::NativeState();
 743
 744   // An undetermined progressbar (i.e. without a value) has a mixed state.
 745   nsAutoString attrValue;
 746   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
 747                                  attrValue);
 748   if (attrValue.IsEmpty()) {
 749     state |= states::MIXED;
 750   }
 751
 752   return state;
 753 }
 754
 755 bool HTMLProgressAccessible::IsWidget() const { return true; }
 756
 757 void HTMLProgressAccessible::Value(nsString& aValue) const {
 758   LeafAccessible::Value(aValue);
 759   if (!aValue.IsEmpty()) {
 760     return;
 761   }
 762
 763   double maxValue = MaxValue();
 764   if (IsNaN(maxValue) || maxValue == 0) {
 765     return;
 766   }
 767
 768   double curValue = CurValue();
 769   if (IsNaN(curValue)) {
 770     return;
 771   }
 772
 773   // Treat the current value bigger than maximum as 100%.
 774   double percentValue =
 775       (curValue < maxValue) ? (curValue / maxValue) * 100 : 100;
 776
 777   aValue.AppendFloat(percentValue);
 778   aValue.Append('%');
 779 }
 780
 781 double HTMLProgressAccessible::MaxValue() const {
 782   double value = LeafAccessible::MaxValue();
 783   if (!IsNaN(value)) {
 784     return value;
 785   }
 786
 787   nsAutoString strValue;
 788   if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::max,
 789                                      strValue)) {
 790     nsresult result = NS_OK;
 791     value = strValue.ToDouble(&result);
 792     if (NS_SUCCEEDED(result)) {
 793       return value;
 794     }
 795   }
 796
 797   return 1;
 798 }
 799
 800 double HTMLProgressAccessible::MinValue() const {
 801   double value = LeafAccessible::MinValue();
 802   return IsNaN(value) ? 0 : value;
 803 }
 804
 805 double HTMLProgressAccessible::Step() const {
 806   double value = LeafAccessible::Step();
 807   return IsNaN(value) ? 0 : value;
 808 }
 809
 810 double HTMLProgressAccessible::CurValue() const {
 811   double value = LeafAccessible::CurValue();
 812   if (!IsNaN(value)) {
 813     return value;
 814   }
 815
 816   nsAutoString attrValue;
 817   if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
 818                                       attrValue)) {
 819     return UnspecifiedNaN<double>();
 820   }
 821
 822   nsresult error = NS_OK;
 823   value = attrValue.ToDouble(&error);
 824   return NS_FAILED(error) ? UnspecifiedNaN<double>() : value;
 825 }
 826
 827 bool HTMLProgressAccessible::SetCurValue(double aValue) {
 828   return false;  // progress meters are readonly.
 829 }
 830
 831 void HTMLProgressAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
 832                                                  nsAtom* aAttribute,
 833                                                  int32_t aModType,
 834                                                  const nsAttrValue* aOldValue,
 835                                                  uint64_t aOldState) {
 836   LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
 837                                       aOldValue, aOldState);
 838
 839   if (aAttribute == nsGkAtoms::value) {
 840     mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);
 841
 842     uint64_t currState = NativeState();
 843     if ((aOldState ^ currState) & states::MIXED) {
 844       RefPtr<AccEvent> stateChangeEvent = new AccStateChangeEvent(
 845           this, states::MIXED, (currState & states::MIXED));
 846       mDoc->FireDelayedEvent(stateChangeEvent);
 847     }
 848   }
 849 }
 850
 851 ////////////////////////////////////////////////////////////////////////////////
 852 // HTMLMeterAccessible
 853 ////////////////////////////////////////////////////////////////////////////////
 854
 855 role HTMLMeterAccessible::NativeRole() const { return roles::METER; }
 856
 857 bool HTMLMeterAccessible::IsWidget() const { return true; }
 858
 859 void HTMLMeterAccessible::Value(nsString& aValue) const {
 860   LeafAccessible::Value(aValue);
 861   if (!aValue.IsEmpty()) {
 862     return;
 863   }
 864
 865   // If we did not get a value from the above LeafAccessible call,
 866   // we should check to see if the meter has inner text.
 867   // If it does, we'll use that as our value.
 868   nsTextEquivUtils::AppendFromDOMChildren(mContent, &aValue);
 869   aValue.CompressWhitespace();
 870   if (!aValue.IsEmpty()) {
 871     return;
 872   }
 873
 874   // If no inner text is found, use curValue
 875   double curValue = CurValue();
 876   if (IsNaN(curValue)) {
 877     return;
 878   }
 879
 880   aValue.AppendFloat(curValue);
 881 }
 882
 883 double HTMLMeterAccessible::MaxValue() const {
 884   double max = LeafAccessible::MaxValue();
 885   double min = MinValue();
 886
 887   if (!IsNaN(max)) {
 888     return max > min ? max : min;
 889   }
 890
 891   // If we didn't find a max value, check for the max attribute
 892   nsAutoString strValue;
 893   if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::max,
 894                                      strValue)) {
 895     nsresult result = NS_OK;
 896     max = strValue.ToDouble(&result);
 897     if (NS_SUCCEEDED(result)) {
 898       return max > min ? max : min;
 899     }
 900   }
 901
 902   return 1 > min ? 1 : min;
 903 }
 904
 905 double HTMLMeterAccessible::MinValue() const {
 906   double min = LeafAccessible::MinValue();
 907   if (!IsNaN(min)) {
 908     return min;
 909   }
 910
 911   nsAutoString strValue;
 912   if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::min,
 913                                      strValue)) {
 914     nsresult result = NS_OK;
 915     min = strValue.ToDouble(&result);
 916     if (NS_SUCCEEDED(result)) {
 917       return min;
 918     }
 919   }
 920
 921   return 0;
 922 }
 923
 924 double HTMLMeterAccessible::CurValue() const {
 925   double value = LeafAccessible::CurValue();
 926   double minValue = MinValue();
 927
 928   if (IsNaN(value)) {
 929     /* If we didn't find a value from the LeafAccessible call above, check
 930      * for a value attribute */
 931     nsAutoString attrValue;
 932     if (!mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::value,
 933                                         attrValue)) {
 934       return minValue;
 935     }
 936
 937     // If we find a value attribute, attempt to convert it to a double
 938     nsresult error = NS_OK;
 939     value = attrValue.ToDouble(&error);
 940     if (NS_FAILED(error)) {
 941       return minValue;
 942     }
 943   }
 944
 945   /* If we end up with a defined value, verify it falls between
 946    * our established min/max. Otherwise, snap it to the nearest boundary. */
 947   double maxValue = MaxValue();
 948   if (value > maxValue) {
 949     value = maxValue;
 950   } else if (value < minValue) {
 951     value = minValue;
 952   }
 953
 954   return value;
 955 }
 956
 957 bool HTMLMeterAccessible::SetCurValue(double aValue) {
 958   return false;  // meters are readonly.
 959 }
 960
 961 void HTMLMeterAccessible::DOMAttributeChanged(int32_t aNameSpaceID,
 962                                               nsAtom* aAttribute,
 963                                               int32_t aModType,
 964                                               const nsAttrValue* aOldValue,
 965                                               uint64_t aOldState) {
 966   LeafAccessible::DOMAttributeChanged(aNameSpaceID, aAttribute, aModType,
 967                                       aOldValue, aOldState);
 968
 969   if (aAttribute == nsGkAtoms::value) {
 970     mDoc->FireDelayedEvent(nsIAccessibleEvent::EVENT_VALUE_CHANGE, this);
 971   }
 972 }