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       aEl->IsXULElement(nsGkAtoms::popup) ||
 135       // A XUL button can be labelled by a direct child text node, so we need to
 136       // allow that as a child so it will be picked up when computing name from
 137       // subtree.
 138       (aEl->IsText() && aEl->GetParent() == mContent);
 139 }
 140
 141 ////////////////////////////////////////////////////////////////////////////////
 142 // XULButtonAccessible protected
 143
 144 bool XULButtonAccessible::ContainsMenu() const {
 145   return mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
 146                                             nsGkAtoms::menu, eCaseMatters);
 147 }
 148
 149 ////////////////////////////////////////////////////////////////////////////////
 150 // XULDropmarkerAccessible
 151 ////////////////////////////////////////////////////////////////////////////////
 152
 153 XULDropmarkerAccessible::XULDropmarkerAccessible(nsIContent* aContent,
 154                                                  DocAccessible* aDoc)
 155     : LeafAccessible(aContent, aDoc) {}
 156
 157 bool XULDropmarkerAccessible::HasPrimaryAction() const { return true; }
 158
 159 bool XULDropmarkerAccessible::DropmarkerOpen(bool aToggleOpen) const {
 160   bool isOpen = false;
 161
 162   nsIContent* parent = mContent->GetFlattenedTreeParent();
 163
 164   while (parent) {
 165     nsCOMPtr<nsIDOMXULButtonElement> parentButtonElement =
 166         parent->AsElement()->AsXULButton();
 167     if (parentButtonElement) {
 168       parentButtonElement->GetOpen(&isOpen);
 169       if (aToggleOpen) parentButtonElement->SetOpen(!isOpen);
 170       return isOpen;
 171     }
 172
 173     nsCOMPtr<nsIDOMXULMenuListElement> parentMenuListElement =
 174         parent->AsElement()->AsXULMenuList();
 175     if (parentMenuListElement) {
 176       parentMenuListElement->GetOpen(&isOpen);
 177       if (aToggleOpen) parentMenuListElement->SetOpen(!isOpen);
 178       return isOpen;
 179     }
 180     parent = parent->GetFlattenedTreeParent();
 181   }
 182
 183   return isOpen;
 184 }
 185
 186 void XULDropmarkerAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
 187   aName.Truncate();
 188   if (aIndex == eAction_Click) {
 189     if (DropmarkerOpen(false)) {
 190       aName.AssignLiteral("close");
 191     } else {
 192       aName.AssignLiteral("open");
 193     }
 194   }
 195 }
 196
 197 bool XULDropmarkerAccessible::DoAction(uint8_t index) const {
 198   if (index == eAction_Click) {
 199     DropmarkerOpen(true);  // Reverse the open attribute
 200     return true;
 201   }
 202   return false;
 203 }
 204
 205 role XULDropmarkerAccessible::NativeRole() const { return roles::PUSHBUTTON; }
 206
 207 uint64_t XULDropmarkerAccessible::NativeState() const {
 208   return DropmarkerOpen(false) ? states::PRESSED : 0;
 209 }
 210
 211 ////////////////////////////////////////////////////////////////////////////////
 212 // XULGroupboxAccessible
 213 ////////////////////////////////////////////////////////////////////////////////
 214
 215 XULGroupboxAccessible::XULGroupboxAccessible(nsIContent* aContent,
 216                                              DocAccessible* aDoc)
 217     : AccessibleWrap(aContent, aDoc) {}
 218
 219 role XULGroupboxAccessible::NativeRole() const { return roles::GROUPING; }
 220
 221 ENameValueFlag XULGroupboxAccessible::NativeName(nsString& aName) const {
 222   // XXX: we use the first related accessible only.
 223   LocalAccessible* label =
 224       RelationByType(RelationType::LABELLED_BY).LocalNext();
 225   if (label) return label->Name(aName);
 226
 227   return eNameOK;
 228 }
 229
 230 Relation XULGroupboxAccessible::RelationByType(RelationType aType) const {
 231   Relation rel = AccessibleWrap::RelationByType(aType);
 232
 233   // The label for xul:groupbox is generated from the first xul:label
 234   if (aType == RelationType::LABELLED_BY && ChildCount() > 0) {
 235     LocalAccessible* childAcc = LocalChildAt(0);
 236     if (childAcc->Role() == roles::LABEL &&
 237         childAcc->GetContent()->IsXULElement(nsGkAtoms::label)) {
 238       rel.AppendTarget(childAcc);
 239     }
 240   }
 241
 242   return rel;
 243 }
 244
 245 ////////////////////////////////////////////////////////////////////////////////
 246 // XULRadioButtonAccessible
 247 ////////////////////////////////////////////////////////////////////////////////
 248
 249 XULRadioButtonAccessible::XULRadioButtonAccessible(nsIContent* aContent,
 250                                                    DocAccessible* aDoc)
 251     : RadioButtonAccessible(aContent, aDoc) {}
 252
 253 uint64_t XULRadioButtonAccessible::NativeState() const {
 254   uint64_t state = LeafAccessible::NativeState();
 255   state |= states::CHECKABLE;
 256
 257   nsCOMPtr<nsIDOMXULSelectControlItemElement> radioButton =
 258       Elm()->AsXULSelectControlItem();
 259   if (radioButton) {
 260     bool selected = false;  // Radio buttons can be selected
 261     radioButton->GetSelected(&selected);
 262     if (selected) {
 263       state |= states::CHECKED;
 264     }
 265   }
 266
 267   return state;
 268 }
 269
 270 uint64_t XULRadioButtonAccessible::NativeInteractiveState() const {
 271   return NativelyUnavailable() ? states::UNAVAILABLE : states::FOCUSABLE;
 272 }
 273
 274 ////////////////////////////////////////////////////////////////////////////////
 275 // XULRadioButtonAccessible: Widgets
 276
 277 LocalAccessible* XULRadioButtonAccessible::ContainerWidget() const {
 278   return mParent;
 279 }
 280
 281 ////////////////////////////////////////////////////////////////////////////////
 282 // XULRadioGroupAccessible
 283 ////////////////////////////////////////////////////////////////////////////////
 284
 285 /**
 286  * XUL Radio Group
 287  *   The Radio Group proxies for the Radio Buttons themselves. The Group gets
 288  *   focus whereas the Buttons do not. So we only have an accessible object for
 289  *   this for the purpose of getting the proper RadioButton. Need this here to
 290  *   avoid circular reference problems when navigating the accessible tree and
 291  *   for getting to the radiobuttons.
 292  */
 293
 294 XULRadioGroupAccessible::XULRadioGroupAccessible(nsIContent* aContent,
 295                                                  DocAccessible* aDoc)
 296     : XULSelectControlAccessible(aContent, aDoc) {}
 297
 298 role XULRadioGroupAccessible::NativeRole() const { return roles::RADIO_GROUP; }
 299
 300 uint64_t XULRadioGroupAccessible::NativeInteractiveState() const {
 301   // The radio group is not focusable. Sometimes the focus controller will
 302   // report that it is focused. That means that the actual selected radio button
 303   // should be considered focused.
 304   return NativelyUnavailable() ? states::UNAVAILABLE : 0;
 305 }
 306
 307 ////////////////////////////////////////////////////////////////////////////////
 308 // XULRadioGroupAccessible: Widgets
 309
 310 bool XULRadioGroupAccessible::IsWidget() const { return true; }
 311
 312 bool XULRadioGroupAccessible::IsActiveWidget() const {
 313   return FocusMgr()->HasDOMFocus(mContent);
 314 }
 315
 316 bool XULRadioGroupAccessible::AreItemsOperable() const { return true; }
 317
 318 LocalAccessible* XULRadioGroupAccessible::CurrentItem() const {
 319   if (!mSelectControl) {
 320     return nullptr;
 321   }
 322
 323   RefPtr<dom::Element> currentItemElm;
 324   nsCOMPtr<nsIDOMXULRadioGroupElement> group =
 325       mSelectControl->AsXULRadioGroup();
 326   if (group) {
 327     group->GetFocusedItem(getter_AddRefs(currentItemElm));
 328   }
 329
 330   if (currentItemElm) {
 331     DocAccessible* document = Document();
 332     if (document) {
 333       return document->GetAccessible(currentItemElm);
 334     }
 335   }
 336
 337   return nullptr;
 338 }
 339
 340 void XULRadioGroupAccessible::SetCurrentItem(const LocalAccessible* aItem) {
 341   if (!mSelectControl) {
 342     return;
 343   }
 344
 345   nsCOMPtr<dom::Element> itemElm = aItem->Elm();
 346   nsCOMPtr<nsIDOMXULRadioGroupElement> group =
 347       mSelectControl->AsXULRadioGroup();
 348   if (group) {
 349     group->SetFocusedItem(itemElm);
 350   }
 351 }
 352
 353 ////////////////////////////////////////////////////////////////////////////////
 354 // XULStatusBarAccessible
 355 ////////////////////////////////////////////////////////////////////////////////
 356
 357 XULStatusBarAccessible::XULStatusBarAccessible(nsIContent* aContent,
 358                                                DocAccessible* aDoc)
 359     : AccessibleWrap(aContent, aDoc) {}
 360
 361 role XULStatusBarAccessible::NativeRole() const { return roles::STATUSBAR; }
 362
 363 ////////////////////////////////////////////////////////////////////////////////
 364 // XULToolbarButtonAccessible
 365 ////////////////////////////////////////////////////////////////////////////////
 366
 367 XULToolbarButtonAccessible::XULToolbarButtonAccessible(nsIContent* aContent,
 368                                                        DocAccessible* aDoc)
 369     : XULButtonAccessible(aContent, aDoc) {}
 370
 371 void XULToolbarButtonAccessible::GetPositionAndSetSize(int32_t* aPosInSet,
 372                                                        int32_t* aSetSize) {
 373   int32_t setSize = 0;
 374   int32_t posInSet = 0;
 375
 376   LocalAccessible* parent = LocalParent();
 377   if (!parent) return;
 378
 379   uint32_t childCount = parent->ChildCount();
 380   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
 381     LocalAccessible* child = parent->LocalChildAt(childIdx);
 382     if (IsSeparator(child)) {  // end of a group of buttons
 383       if (posInSet) break;     // we've found our group, so we're done
 384
 385       setSize = 0;  // not our group, so start a new group
 386
 387     } else {
 388       setSize++;  // another button in the group
 389
 390       if (child == this) posInSet = setSize;  // we've found our button
 391     }
 392   }
 393
 394   *aPosInSet = posInSet;
 395   *aSetSize = setSize;
 396 }
 397
 398 bool XULToolbarButtonAccessible::IsSeparator(LocalAccessible* aAccessible) {
 399   nsIContent* content = aAccessible->GetContent();
 400   return content && content->IsAnyOfXULElements(nsGkAtoms::toolbarseparator,
 401                                                 nsGkAtoms::toolbarspacer,
 402                                                 nsGkAtoms::toolbarspring);
 403 }
 404
 405 ////////////////////////////////////////////////////////////////////////////////
 406 // XULToolbarButtonAccessible: Widgets
 407
 408 bool XULToolbarButtonAccessible::IsAcceptableChild(nsIContent* aEl) const {
 409   return XULButtonAccessible::IsAcceptableChild(aEl) ||
 410          // In addition to the children allowed by buttons, toolbarbuttons can
 411          // have labels as children, but only if the label attribute is not
 412          // present.
 413          (aEl->IsXULElement(nsGkAtoms::label) &&
 414           !mContent->AsElement()->HasAttr(nsGkAtoms::label));
 415 }
 416
 417 ////////////////////////////////////////////////////////////////////////////////
 418 // XULToolbarAccessible
 419 ////////////////////////////////////////////////////////////////////////////////
 420
 421 XULToolbarAccessible::XULToolbarAccessible(nsIContent* aContent,
 422                                            DocAccessible* aDoc)
 423     : AccessibleWrap(aContent, aDoc) {}
 424
 425 role XULToolbarAccessible::NativeRole() const { return roles::TOOLBAR; }
 426
 427 ENameValueFlag XULToolbarAccessible::NativeName(nsString& aName) const {
 428   if (mContent->AsElement()->GetAttr(nsGkAtoms::toolbarname, aName)) {
 429     aName.CompressWhitespace();
 430   }
 431
 432   return eNameOK;
 433 }
 434
 435 ////////////////////////////////////////////////////////////////////////////////
 436 // XULToolbarAccessible
 437 ////////////////////////////////////////////////////////////////////////////////
 438
 439 XULToolbarSeparatorAccessible::XULToolbarSeparatorAccessible(
 440     nsIContent* aContent, DocAccessible* aDoc)
 441     : LeafAccessible(aContent, aDoc) {}
 442
 443 role XULToolbarSeparatorAccessible::NativeRole() const {
 444   return roles::SEPARATOR;
 445 }
 446
 447 uint64_t XULToolbarSeparatorAccessible::NativeState() const { return 0; }