accessible/xul/XULFormControlAccessible.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 "XULFormControlAccessible.h"
   7
   8 #include "LocalAccessible-inl.h"
   9 #include "HTMLFormControlAccessible.h"
  10 #include "nsAccUtils.h"
  11 #include "DocAccessible.h"
  12 #include "Relation.h"
  13 #include "mozilla/a11y/Role.h"
  14 #include "States.h"
  15 #include "TreeWalker.h"
  16 #include "XULMenuAccessible.h"
  17
  18 #include "nsIDOMXULButtonElement.h"
  19 #include "nsIDOMXULMenuListElement.h"
  20 #include "nsIDOMXULRadioGroupElement.h"
  21 #include "nsIDOMXULSelectCntrlItemEl.h"
  22 #include "nsIFrame.h"
  23 #include "nsITextControlFrame.h"
  24 #include "nsMenuPopupFrame.h"
  25 #include "nsNameSpaceManager.h"
  26 #include "mozilla/dom/Element.h"
  27
  28 using namespace mozilla::a11y;
  29
  30 ////////////////////////////////////////////////////////////////////////////////
  31 // XULButtonAccessible
  32 ////////////////////////////////////////////////////////////////////////////////
  33
  34 XULButtonAccessible::XULButtonAccessible(nsIContent* aContent,
  35                                          DocAccessible* aDoc)
  36     : AccessibleWrap(aContent, aDoc) {
  37   if (ContainsMenu()) {
  38     mGenericTypes |= eMenuButton;
  39   } else {
  40     mGenericTypes |= eButton;
  41   }
  42 }
  43
  44 XULButtonAccessible::~XULButtonAccessible() {}
  45
  46 ////////////////////////////////////////////////////////////////////////////////
  47 // XULButtonAccessible: nsISupports
  48
  49 ////////////////////////////////////////////////////////////////////////////////
  50 // XULButtonAccessible: nsIAccessible
  51
  52 bool XULButtonAccessible::HasPrimaryAction() const { return true; }
  53
  54 void XULButtonAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
  55   if (aIndex == eAction_Click) aName.AssignLiteral("press");
  56 }
  57
  58 ////////////////////////////////////////////////////////////////////////////////
  59 // XULButtonAccessible: LocalAccessible
  60
  61 role XULButtonAccessible::NativeRole() const {
  62   // Buttons can be checked; they simply appear pressed in rather than checked.
  63   // In this case, we must expose them as toggle buttons.
  64   nsCOMPtr<nsIDOMXULButtonElement> xulButtonElement = Elm()->AsXULButton();
  65   if (xulButtonElement) {
  66     nsAutoString type;
  67     xulButtonElement->GetType(type);
  68     if (type.EqualsLiteral("checkbox") || type.EqualsLiteral("radio")) {
  69       return roles::TOGGLE_BUTTON;
  70     }
  71   }
  72   return roles::PUSHBUTTON;
  73 }
  74
  75 uint64_t XULButtonAccessible::NativeState() const {
  76   // Possible states: focused, focusable, unavailable(disabled).
  77
  78   // get focus and disable status from base class
  79   uint64_t state = LocalAccessible::NativeState();
  80
  81   nsCOMPtr<nsIDOMXULButtonElement> xulButtonElement = Elm()->AsXULButton();
  82   if (xulButtonElement) {
  83     // Some buttons can have their checked state set without being of type
  84     // checkbox or radio. Expose the pressed state unconditionally.
  85     bool checked = false;
  86     xulButtonElement->GetChecked(&checked);
  87     if (checked) {
  88       state |= states::PRESSED;
  89     }
  90   }
  91
  92   if (ContainsMenu()) state |= states::HASPOPUP;
  93
  94   if (mContent->AsElement()->HasAttr(nsGkAtoms::_default)) {
  95     state |= states::DEFAULT;
  96   }
  97
  98   return state;
  99 }
 100
 101 bool XULButtonAccessible::AttributeChangesState(nsAtom* aAttribute) {
 102   if (aAttribute == nsGkAtoms::checked) {
 103     return true;
 104   }
 105   return AccessibleWrap::AttributeChangesState(aAttribute);
 106 }
 107
 108 ////////////////////////////////////////////////////////////////////////////////
 109 // XULButtonAccessible: Widgets
 110
 111 bool XULButtonAccessible::IsWidget() const { return true; }
 112
 113 bool XULButtonAccessible::IsActiveWidget() const {
 114   return FocusMgr()->HasDOMFocus(mContent);
 115 }
 116
 117 bool XULButtonAccessible::AreItemsOperable() const {
 118   if (IsMenuButton()) {
 119     LocalAccessible* menuPopup = mChildren.SafeElementAt(0, nullptr);
 120     if (menuPopup) {
 121       nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(menuPopup->GetFrame());
 122       return menuPopupFrame->IsOpen();
 123     }
 124   }
 125   return false;  // no items
 126 }
 127
 128 bool XULButtonAccessible::IsAcceptableChild(nsIContent* aEl) const {
 129   // In general XUL buttons should not have accessible children. However:
 130   return
 131       //   menu buttons can have popup accessibles (@type="menu" or
 132       //   columnpicker).
 133       aEl->IsXULElement(nsGkAtoms::menupopup) ||
 134       // A XUL button can be labelled by a direct child text node, so we need to
 135       // allow that as a child so it will be picked up when computing name from
 136       // subtree.
 137       (aEl->IsText() && aEl->GetParent() == mContent);
 138 }
 139
 140 ////////////////////////////////////////////////////////////////////////////////
 141 // XULButtonAccessible protected
 142
 143 bool XULButtonAccessible::ContainsMenu() const {
 144   return mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 145                                             nsGkAtoms::menu, eCaseMatters);
 146 }
 147
 148 ////////////////////////////////////////////////////////////////////////////////
 149 // XULDropmarkerAccessible
 150 ////////////////////////////////////////////////////////////////////////////////
 151
 152 XULDropmarkerAccessible::XULDropmarkerAccessible(nsIContent* aContent,
 153                                                  DocAccessible* aDoc)
 154     : LeafAccessible(aContent, aDoc) {}
 155
 156 bool XULDropmarkerAccessible::HasPrimaryAction() const { return true; }
 157
 158 bool XULDropmarkerAccessible::DropmarkerOpen(bool aToggleOpen) const {
 159   bool isOpen = false;
 160
 161   nsIContent* parent = mContent->GetFlattenedTreeParent();
 162
 163   while (parent) {
 164     nsCOMPtr<nsIDOMXULButtonElement> parentButtonElement =
 165         parent->AsElement()->AsXULButton();
 166     if (parentButtonElement) {
 167       parentButtonElement->GetOpen(&isOpen);
 168       if (aToggleOpen) parentButtonElement->SetOpen(!isOpen);
 169       return isOpen;
 170     }
 171
 172     nsCOMPtr<nsIDOMXULMenuListElement> parentMenuListElement =
 173         parent->AsElement()->AsXULMenuList();
 174     if (parentMenuListElement) {
 175       parentMenuListElement->GetOpen(&isOpen);
 176       if (aToggleOpen) parentMenuListElement->SetOpen(!isOpen);
 177       return isOpen;
 178     }
 179     parent = parent->GetFlattenedTreeParent();
 180   }
 181
 182   return isOpen;
 183 }
 184
 185 void XULDropmarkerAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
 186   aName.Truncate();
 187   if (aIndex == eAction_Click) {
 188     if (DropmarkerOpen(false)) {
 189       aName.AssignLiteral("close");
 190     } else {
 191       aName.AssignLiteral("open");
 192     }
 193   }
 194 }
 195
 196 bool XULDropmarkerAccessible::DoAction(uint8_t index) const {
 197   if (index == eAction_Click) {
 198     DropmarkerOpen(true);  // Reverse the open attribute
 199     return true;
 200   }
 201   return false;
 202 }
 203
 204 role XULDropmarkerAccessible::NativeRole() const { return roles::PUSHBUTTON; }
 205
 206 uint64_t XULDropmarkerAccessible::NativeState() const {
 207   return DropmarkerOpen(false) ? states::PRESSED : 0;
 208 }
 209
 210 ////////////////////////////////////////////////////////////////////////////////
 211 // XULGroupboxAccessible
 212 ////////////////////////////////////////////////////////////////////////////////
 213
 214 XULGroupboxAccessible::XULGroupboxAccessible(nsIContent* aContent,
 215                                              DocAccessible* aDoc)
 216     : AccessibleWrap(aContent, aDoc) {}
 217
 218 role XULGroupboxAccessible::NativeRole() const { return roles::GROUPING; }
 219
 220 ENameValueFlag XULGroupboxAccessible::NativeName(nsString& aName) const {
 221   // XXX: we use the first related accessible only.
 222   LocalAccessible* label =
 223       RelationByType(RelationType::LABELLED_BY).LocalNext();
 224   if (label) return label->Name(aName);
 225
 226   return eNameOK;
 227 }
 228
 229 Relation XULGroupboxAccessible::RelationByType(RelationType aType) const {
 230   Relation rel = AccessibleWrap::RelationByType(aType);
 231
 232   // The label for xul:groupbox is generated from the first xul:label
 233   if (aType == RelationType::LABELLED_BY && ChildCount() > 0) {
 234     LocalAccessible* childAcc = LocalChildAt(0);
 235     if (childAcc->Role() == roles::LABEL &&
 236         childAcc->GetContent()->IsXULElement(nsGkAtoms::label)) {
 237       rel.AppendTarget(childAcc);
 238     }
 239   }
 240
 241   return rel;
 242 }
 243
 244 ////////////////////////////////////////////////////////////////////////////////
 245 // XULRadioButtonAccessible
 246 ////////////////////////////////////////////////////////////////////////////////
 247
 248 XULRadioButtonAccessible::XULRadioButtonAccessible(nsIContent* aContent,
 249                                                    DocAccessible* aDoc)
 250     : RadioButtonAccessible(aContent, aDoc) {}
 251
 252 uint64_t XULRadioButtonAccessible::NativeState() const {
 253   uint64_t state = LeafAccessible::NativeState();
 254   state |= states::CHECKABLE;
 255
 256   nsCOMPtr<nsIDOMXULSelectControlItemElement> radioButton =
 257       Elm()->AsXULSelectControlItem();
 258   if (radioButton) {
 259     bool selected = false;  // Radio buttons can be selected
 260     radioButton->GetSelected(&selected);
 261     if (selected) {
 262       state |= states::CHECKED;
 263     }
 264   }
 265
 266   return state;
 267 }
 268
 269 uint64_t XULRadioButtonAccessible::NativeInteractiveState() const {
 270   return NativelyUnavailable() ? states::UNAVAILABLE : states::FOCUSABLE;
 271 }
 272
 273 ////////////////////////////////////////////////////////////////////////////////
 274 // XULRadioButtonAccessible: Widgets
 275
 276 LocalAccessible* XULRadioButtonAccessible::ContainerWidget() const {
 277   return mParent;
 278 }
 279
 280 ////////////////////////////////////////////////////////////////////////////////
 281 // XULRadioGroupAccessible
 282 ////////////////////////////////////////////////////////////////////////////////
 283
 284 /**
 285  * XUL Radio Group
 286  *   The Radio Group proxies for the Radio Buttons themselves. The Group gets
 287  *   focus whereas the Buttons do not. So we only have an accessible object for
 288  *   this for the purpose of getting the proper RadioButton. Need this here to
 289  *   avoid circular reference problems when navigating the accessible tree and
 290  *   for getting to the radiobuttons.
 291  */
 292
 293 XULRadioGroupAccessible::XULRadioGroupAccessible(nsIContent* aContent,
 294                                                  DocAccessible* aDoc)
 295     : XULSelectControlAccessible(aContent, aDoc) {}
 296
 297 role XULRadioGroupAccessible::NativeRole() const { return roles::RADIO_GROUP; }
 298
 299 uint64_t XULRadioGroupAccessible::NativeInteractiveState() const {
 300   // The radio group is not focusable. Sometimes the focus controller will
 301   // report that it is focused. That means that the actual selected radio button
 302   // should be considered focused.
 303   return NativelyUnavailable() ? states::UNAVAILABLE : 0;
 304 }
 305
 306 ////////////////////////////////////////////////////////////////////////////////
 307 // XULRadioGroupAccessible: Widgets
 308
 309 bool XULRadioGroupAccessible::IsWidget() const { return true; }
 310
 311 bool XULRadioGroupAccessible::IsActiveWidget() const {
 312   return FocusMgr()->HasDOMFocus(mContent);
 313 }
 314
 315 bool XULRadioGroupAccessible::AreItemsOperable() const { return true; }
 316
 317 LocalAccessible* XULRadioGroupAccessible::CurrentItem() const {
 318   if (!mSelectControl) {
 319     return nullptr;
 320   }
 321
 322   RefPtr<dom::Element> currentItemElm;
 323   nsCOMPtr<nsIDOMXULRadioGroupElement> group =
 324       mSelectControl->AsXULRadioGroup();
 325   if (group) {
 326     group->GetFocusedItem(getter_AddRefs(currentItemElm));
 327   }
 328
 329   if (currentItemElm) {
 330     DocAccessible* document = Document();
 331     if (document) {
 332       return document->GetAccessible(currentItemElm);
 333     }
 334   }
 335
 336   return nullptr;
 337 }
 338
 339 void XULRadioGroupAccessible::SetCurrentItem(const LocalAccessible* aItem) {
 340   if (!mSelectControl) {
 341     return;
 342   }
 343
 344   nsCOMPtr<dom::Element> itemElm = aItem->Elm();
 345   nsCOMPtr<nsIDOMXULRadioGroupElement> group =
 346       mSelectControl->AsXULRadioGroup();
 347   if (group) {
 348     group->SetFocusedItem(itemElm);
 349   }
 350 }
 351
 352 ////////////////////////////////////////////////////////////////////////////////
 353 // XULStatusBarAccessible
 354 ////////////////////////////////////////////////////////////////////////////////
 355
 356 XULStatusBarAccessible::XULStatusBarAccessible(nsIContent* aContent,
 357                                                DocAccessible* aDoc)
 358     : AccessibleWrap(aContent, aDoc) {}
 359
 360 role XULStatusBarAccessible::NativeRole() const { return roles::STATUSBAR; }
 361
 362 ////////////////////////////////////////////////////////////////////////////////
 363 // XULToolbarButtonAccessible
 364 ////////////////////////////////////////////////////////////////////////////////
 365
 366 XULToolbarButtonAccessible::XULToolbarButtonAccessible(nsIContent* aContent,
 367                                                        DocAccessible* aDoc)
 368     : XULButtonAccessible(aContent, aDoc) {}
 369
 370 void XULToolbarButtonAccessible::GetPositionAndSetSize(int32_t* aPosInSet,
 371                                                        int32_t* aSetSize) {
 372   int32_t setSize = 0;
 373   int32_t posInSet = 0;
 374
 375   LocalAccessible* parent = LocalParent();
 376   if (!parent) return;
 377
 378   uint32_t childCount = parent->ChildCount();
 379   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
 380     LocalAccessible* child = parent->LocalChildAt(childIdx);
 381     if (IsSeparator(child)) {  // end of a group of buttons
 382       if (posInSet) break;     // we've found our group, so we're done
 383
 384       setSize = 0;  // not our group, so start a new group
 385
 386     } else {
 387       setSize++;  // another button in the group
 388
 389       if (child == this) posInSet = setSize;  // we've found our button
 390     }
 391   }
 392
 393   *aPosInSet = posInSet;
 394   *aSetSize = setSize;
 395 }
 396
 397 bool XULToolbarButtonAccessible::IsSeparator(LocalAccessible* aAccessible) {
 398   nsIContent* content = aAccessible->GetContent();
 399   return content && content->IsAnyOfXULElements(nsGkAtoms::toolbarseparator,
 400                                                 nsGkAtoms::toolbarspacer,
 401                                                 nsGkAtoms::toolbarspring);
 402 }
 403
 404 ////////////////////////////////////////////////////////////////////////////////
 405 // XULToolbarButtonAccessible: Widgets
 406
 407 bool XULToolbarButtonAccessible::IsAcceptableChild(nsIContent* aEl) const {
 408   return XULButtonAccessible::IsAcceptableChild(aEl) ||
 409          // In addition to the children allowed by buttons, toolbarbuttons can
 410          // have labels as children, but only if the label attribute is not
 411          // present.
 412          (aEl->IsXULElement(nsGkAtoms::label) &&
 413           !mContent->AsElement()->HasAttr(nsGkAtoms::label));
 414 }
 415
 416 ////////////////////////////////////////////////////////////////////////////////
 417 // XULToolbarAccessible
 418 ////////////////////////////////////////////////////////////////////////////////
 419
 420 XULToolbarAccessible::XULToolbarAccessible(nsIContent* aContent,
 421                                            DocAccessible* aDoc)
 422     : AccessibleWrap(aContent, aDoc) {}
 423
 424 role XULToolbarAccessible::NativeRole() const { return roles::TOOLBAR; }
 425
 426 ENameValueFlag XULToolbarAccessible::NativeName(nsString& aName) const {
 427   if (mContent->AsElement()->GetAttr(nsGkAtoms::toolbarname, aName)) {
 428     aName.CompressWhitespace();
 429   }
 430
 431   return eNameOK;
 432 }
 433
 434 ////////////////////////////////////////////////////////////////////////////////
 435 // XULToolbarAccessible
 436 ////////////////////////////////////////////////////////////////////////////////
 437
 438 XULToolbarSeparatorAccessible::XULToolbarSeparatorAccessible(
 439     nsIContent* aContent, DocAccessible* aDoc)
 440     : LeafAccessible(aContent, aDoc) {}
 441
 442 role XULToolbarSeparatorAccessible::NativeRole() const {
 443   return roles::SEPARATOR;
 444 }
 445
 446 uint64_t XULToolbarSeparatorAccessible::NativeState() const { return 0; }