accessible/xul/XULListboxAccessible.cpp

   1 /* -*- Mode: C++; tab-width: 4; 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 "XULListboxAccessible.h"
   7
   8 #include "Accessible-inl.h"
   9 #include "nsAccessibilityService.h"
  10 #include "nsAccUtils.h"
  11 #include "DocAccessible.h"
  12 #include "Role.h"
  13 #include "States.h"
  14
  15 #include "nsComponentManagerUtils.h"
  16 #include "nsIAutoCompleteInput.h"
  17 #include "nsIAutoCompletePopup.h"
  18 #include "nsIDOMXULMenuListElement.h"
  19 #include "nsIDOMXULMultSelectCntrlEl.h"
  20 #include "nsIDOMNodeList.h"
  21 #include "nsIDOMXULPopupElement.h"
  22 #include "nsIDOMXULSelectCntrlItemEl.h"
  23 #include "nsIMutableArray.h"
  24 #include "nsIPersistentProperties2.h"
  25
  26 using namespace mozilla::a11y;
  27
  28 ////////////////////////////////////////////////////////////////////////////////
  29 // XULColumAccessible
  30 ////////////////////////////////////////////////////////////////////////////////
  31
  32 XULColumAccessible::
  33   XULColumAccessible(nsIContent* aContent, DocAccessible* aDoc) :
  34   AccessibleWrap(aContent, aDoc)
  35 {
  36 }
  37
  38 role
  39 XULColumAccessible::NativeRole()
  40 {
  41   return roles::LIST;
  42 }
  43
  44 uint64_t
  45 XULColumAccessible::NativeState()
  46 {
  47   return states::READONLY;
  48 }
  49
  50
  51 ////////////////////////////////////////////////////////////////////////////////
  52 // XULColumnItemAccessible
  53 ////////////////////////////////////////////////////////////////////////////////
  54
  55 XULColumnItemAccessible::
  56   XULColumnItemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
  57   LeafAccessible(aContent, aDoc)
  58 {
  59 }
  60
  61 role
  62 XULColumnItemAccessible::NativeRole()
  63 {
  64   return roles::COLUMNHEADER;
  65 }
  66
  67 uint64_t
  68 XULColumnItemAccessible::NativeState()
  69 {
  70   return states::READONLY;
  71 }
  72
  73 uint8_t
  74 XULColumnItemAccessible::ActionCount()
  75 {
  76   return 1;
  77 }
  78
  79 NS_IMETHODIMP
  80 XULColumnItemAccessible::GetActionName(uint8_t aIndex, nsAString& aName)
  81 {
  82   if (aIndex != eAction_Click)
  83     return NS_ERROR_INVALID_ARG;
  84
  85   aName.AssignLiteral("click");
  86   return NS_OK;
  87 }
  88
  89 NS_IMETHODIMP
  90 XULColumnItemAccessible::DoAction(uint8_t aIndex)
  91 {
  92   if (aIndex != eAction_Click)
  93     return NS_ERROR_INVALID_ARG;
  94
  95   DoCommand();
  96   return NS_OK;
  97 }
  98
  99 ////////////////////////////////////////////////////////////////////////////////
 100 // XULListboxAccessible
 101 ////////////////////////////////////////////////////////////////////////////////
 102
 103 XULListboxAccessible::
 104   XULListboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
 105   XULSelectControlAccessible(aContent, aDoc), xpcAccessibleTable(this)
 106 {
 107   nsIContent* parentContent = mContent->GetFlattenedTreeParent();
 108   if (parentContent) {
 109     nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
 110       do_QueryInterface(parentContent);
 111     if (autoCompletePopupElm)
 112       mGenericTypes |= eAutoCompletePopup;
 113   }
 114 }
 115
 116 NS_IMPL_ADDREF_INHERITED(XULListboxAccessible, XULSelectControlAccessible)
 117 NS_IMPL_RELEASE_INHERITED(XULListboxAccessible, XULSelectControlAccessible)
 118
 119 nsresult
 120 XULListboxAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
 121 {
 122   nsresult rv = XULSelectControlAccessible::QueryInterface(aIID, aInstancePtr);
 123   if (*aInstancePtr)
 124     return rv;
 125
 126   if (aIID.Equals(NS_GET_IID(nsIAccessibleTable)) && IsMulticolumn()) {
 127     *aInstancePtr = static_cast<nsIAccessibleTable*>(this);
 128     NS_ADDREF_THIS();
 129     return NS_OK;
 130   }
 131
 132   return NS_ERROR_NO_INTERFACE;
 133 }
 134
 135 ////////////////////////////////////////////////////////////////////////////////
 136 // Accessible
 137
 138 void
 139 XULListboxAccessible::Shutdown()
 140 {
 141   mTable = nullptr;
 142   XULSelectControlAccessible::Shutdown();
 143 }
 144
 145 bool
 146 XULListboxAccessible::IsMulticolumn()
 147 {
 148   int32_t numColumns = 0;
 149   nsresult rv = GetColumnCount(&numColumns);
 150   if (NS_FAILED(rv))
 151     return false;
 152
 153   return numColumns > 1;
 154 }
 155
 156 ////////////////////////////////////////////////////////////////////////////////
 157 // XULListboxAccessible. nsIAccessible
 158
 159 uint64_t
 160 XULListboxAccessible::NativeState()
 161 {
 162   // As a XULListboxAccessible we can have the following states:
 163   //   FOCUSED, READONLY, FOCUSABLE
 164
 165   // Get focus status from base class
 166   uint64_t states = Accessible::NativeState();
 167
 168   // see if we are multiple select if so set ourselves as such
 169
 170   if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::seltype,
 171                             nsGkAtoms::multiple, eCaseMatters)) {
 172       states |= states::MULTISELECTABLE | states::EXTSELECTABLE;
 173   }
 174
 175   return states;
 176 }
 177
 178 /**
 179   * Our value is the label of our ( first ) selected child.
 180   */
 181 void
 182 XULListboxAccessible::Value(nsString& aValue)
 183 {
 184   aValue.Truncate();
 185
 186   nsCOMPtr<nsIDOMXULSelectControlElement> select(do_QueryInterface(mContent));
 187   if (select) {
 188     nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;
 189     select->GetSelectedItem(getter_AddRefs(selectedItem));
 190     if (selectedItem)
 191       selectedItem->GetLabel(aValue);
 192   }
 193 }
 194
 195 role
 196 XULListboxAccessible::NativeRole()
 197 {
 198   // A richlistbox is used with the new autocomplete URL bar, and has a parent
 199   // popup <panel>.
 200   nsCOMPtr<nsIDOMXULPopupElement> xulPopup =
 201     do_QueryInterface(mContent->GetParent());
 202   if (xulPopup)
 203     return roles::COMBOBOX_LIST;
 204
 205   return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
 206 }
 207
 208 ////////////////////////////////////////////////////////////////////////////////
 209 // XULListboxAccessible. nsIAccessibleTable
 210
 211 uint32_t
 212 XULListboxAccessible::ColCount()
 213 {
 214   nsIContent* headContent = nullptr;
 215   for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
 216        childContent = childContent->GetNextSibling()) {
 217     if (childContent->NodeInfo()->Equals(nsGkAtoms::listcols,
 218                                          kNameSpaceID_XUL)) {
 219       headContent = childContent;
 220     }
 221   }
 222   if (!headContent)
 223     return 0;
 224
 225   uint32_t columnCount = 0;
 226   for (nsIContent* childContent = headContent->GetFirstChild(); childContent;
 227        childContent = childContent->GetNextSibling()) {
 228     if (childContent->NodeInfo()->Equals(nsGkAtoms::listcol,
 229                                          kNameSpaceID_XUL)) {
 230       columnCount++;
 231     }
 232   }
 233
 234   return columnCount;
 235 }
 236
 237 uint32_t
 238 XULListboxAccessible::RowCount()
 239 {
 240   nsCOMPtr<nsIDOMXULSelectControlElement> element(do_QueryInterface(mContent));
 241
 242   uint32_t itemCount = 0;
 243   if(element)
 244     element->GetItemCount(&itemCount);
 245
 246   return itemCount;
 247 }
 248
 249 Accessible*
 250 XULListboxAccessible::CellAt(uint32_t aRowIndex, uint32_t aColumnIndex)
 251 {
 252   nsCOMPtr<nsIDOMXULSelectControlElement> control =
 253     do_QueryInterface(mContent);
 254   NS_ENSURE_TRUE(control, nullptr);
 255
 256   nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
 257   control->GetItemAtIndex(aRowIndex, getter_AddRefs(item));
 258   if (!item)
 259     return nullptr;
 260
 261   nsCOMPtr<nsIContent> itemContent(do_QueryInterface(item));
 262   if (!itemContent)
 263     return nullptr;
 264
 265   Accessible* row = mDoc->GetAccessible(itemContent);
 266   NS_ENSURE_TRUE(row, nullptr);
 267
 268   return row->GetChildAt(aColumnIndex);
 269 }
 270
 271 bool
 272 XULListboxAccessible::IsColSelected(uint32_t aColIdx)
 273 {
 274   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 275     do_QueryInterface(mContent);
 276   NS_ASSERTION(control,
 277                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 278
 279   int32_t selectedrowCount = 0;
 280   nsresult rv = control->GetSelectedCount(&selectedrowCount);
 281   NS_ENSURE_SUCCESS(rv, false);
 282
 283   return selectedrowCount == static_cast<int32_t>(RowCount());
 284 }
 285
 286 bool
 287 XULListboxAccessible::IsRowSelected(uint32_t aRowIdx)
 288 {
 289   nsCOMPtr<nsIDOMXULSelectControlElement> control =
 290     do_QueryInterface(mContent);
 291   NS_ASSERTION(control,
 292                "Doesn't implement nsIDOMXULSelectControlElement.");
 293
 294   nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
 295   nsresult rv = control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
 296   NS_ENSURE_SUCCESS(rv, false);
 297
 298   bool isSelected = false;
 299   item->GetSelected(&isSelected);
 300   return isSelected;
 301 }
 302
 303 bool
 304 XULListboxAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx)
 305 {
 306   return IsRowSelected(aRowIdx);
 307 }
 308
 309 uint32_t
 310 XULListboxAccessible::SelectedCellCount()
 311 {
 312   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 313     do_QueryInterface(mContent);
 314   NS_ASSERTION(control,
 315                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 316
 317   nsCOMPtr<nsIDOMNodeList> selectedItems;
 318   control->GetSelectedItems(getter_AddRefs(selectedItems));
 319   if (!selectedItems)
 320     return 0;
 321
 322   uint32_t selectedItemsCount = 0;
 323   nsresult rv = selectedItems->GetLength(&selectedItemsCount);
 324   NS_ENSURE_SUCCESS(rv, 0);
 325
 326   return selectedItemsCount * ColCount();
 327 }
 328
 329 uint32_t
 330 XULListboxAccessible::SelectedColCount()
 331 {
 332   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 333     do_QueryInterface(mContent);
 334   NS_ASSERTION(control,
 335                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 336
 337   int32_t selectedRowCount = 0;
 338   nsresult rv = control->GetSelectedCount(&selectedRowCount);
 339   NS_ENSURE_SUCCESS(rv, 0);
 340
 341   return selectedRowCount > 0 &&
 342    selectedRowCount == static_cast<int32_t>(RowCount()) ? ColCount() : 0;
 343 }
 344
 345 uint32_t
 346 XULListboxAccessible::SelectedRowCount()
 347 {
 348   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 349     do_QueryInterface(mContent);
 350   NS_ASSERTION(control,
 351                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 352
 353   int32_t selectedRowCount = 0;
 354   nsresult rv = control->GetSelectedCount(&selectedRowCount);
 355   NS_ENSURE_SUCCESS(rv, 0);
 356
 357   return selectedRowCount >= 0 ? selectedRowCount : 0;
 358 }
 359
 360 void
 361 XULListboxAccessible::SelectedCells(nsTArray<Accessible*>* aCells)
 362 {
 363   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 364     do_QueryInterface(mContent);
 365   NS_ASSERTION(control,
 366                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 367
 368   nsCOMPtr<nsIDOMNodeList> selectedItems;
 369   control->GetSelectedItems(getter_AddRefs(selectedItems));
 370   if (!selectedItems)
 371     return;
 372
 373   uint32_t selectedItemsCount = 0;
 374   DebugOnly<nsresult> rv = selectedItems->GetLength(&selectedItemsCount);
 375   NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
 376
 377   for (uint32_t index = 0; index < selectedItemsCount; index++) {
 378     nsCOMPtr<nsIDOMNode> itemNode;
 379     selectedItems->Item(index, getter_AddRefs(itemNode));
 380     nsCOMPtr<nsIContent> itemContent(do_QueryInterface(itemNode));
 381     Accessible* item = mDoc->GetAccessible(itemContent);
 382
 383     if (item) {
 384       uint32_t cellCount = item->ChildCount();
 385       for (uint32_t cellIdx = 0; cellIdx < cellCount; cellIdx++) {
 386         Accessible* cell = mChildren[cellIdx];
 387         if (cell->Role() == roles::CELL)
 388           aCells->AppendElement(cell);
 389       }
 390     }
 391   }
 392 }
 393
 394 void
 395 XULListboxAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells)
 396 {
 397   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 398     do_QueryInterface(mContent);
 399   NS_ASSERTION(control,
 400                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 401
 402   nsCOMPtr<nsIDOMNodeList> selectedItems;
 403   control->GetSelectedItems(getter_AddRefs(selectedItems));
 404   if (!selectedItems)
 405     return;
 406
 407   uint32_t selectedItemsCount = 0;
 408   DebugOnly<nsresult> rv = selectedItems->GetLength(&selectedItemsCount);
 409   NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
 410
 411   uint32_t colCount = ColCount();
 412   aCells->SetCapacity(selectedItemsCount * colCount);
 413   aCells->AppendElements(selectedItemsCount * colCount);
 414
 415   for (uint32_t selItemsIdx = 0, cellsIdx = 0;
 416        selItemsIdx < selectedItemsCount; selItemsIdx++) {
 417
 418     nsCOMPtr<nsIDOMNode> itemNode;
 419     selectedItems->Item(selItemsIdx, getter_AddRefs(itemNode));
 420     nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
 421       do_QueryInterface(itemNode);
 422
 423     if (item) {
 424       int32_t itemIdx = -1;
 425       control->GetIndexOfItem(item, &itemIdx);
 426       if (itemIdx >= 0)
 427         for (uint32_t colIdx = 0; colIdx < colCount; colIdx++, cellsIdx++)
 428           aCells->ElementAt(cellsIdx) = itemIdx * colCount + colIdx;
 429     }
 430   }
 431 }
 432
 433 void
 434 XULListboxAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols)
 435 {
 436   uint32_t selColCount = SelectedColCount();
 437   aCols->SetCapacity(selColCount);
 438
 439   for (uint32_t colIdx = 0; colIdx < selColCount; colIdx++)
 440     aCols->AppendElement(colIdx);
 441 }
 442
 443 void
 444 XULListboxAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows)
 445 {
 446   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 447     do_QueryInterface(mContent);
 448   NS_ASSERTION(control,
 449                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 450
 451   nsCOMPtr<nsIDOMNodeList> selectedItems;
 452   control->GetSelectedItems(getter_AddRefs(selectedItems));
 453   if (!selectedItems)
 454     return;
 455
 456   uint32_t rowCount = 0;
 457   DebugOnly<nsresult> rv = selectedItems->GetLength(&rowCount);
 458   NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
 459
 460   if (!rowCount)
 461     return;
 462
 463   aRows->SetCapacity(rowCount);
 464   aRows->AppendElements(rowCount);
 465
 466   for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
 467     nsCOMPtr<nsIDOMNode> itemNode;
 468     selectedItems->Item(rowIdx, getter_AddRefs(itemNode));
 469     nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
 470       do_QueryInterface(itemNode);
 471
 472     if (item) {
 473       int32_t itemIdx = -1;
 474       control->GetIndexOfItem(item, &itemIdx);
 475       if (itemIdx >= 0)
 476         aRows->ElementAt(rowIdx) = itemIdx;
 477     }
 478   }
 479 }
 480
 481 void
 482 XULListboxAccessible::SelectRow(uint32_t aRowIdx)
 483 {
 484   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 485     do_QueryInterface(mContent);
 486   NS_ASSERTION(control,
 487                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 488
 489   nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
 490   control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
 491   control->SelectItem(item);
 492 }
 493
 494 void
 495 XULListboxAccessible::UnselectRow(uint32_t aRowIdx)
 496 {
 497   nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
 498     do_QueryInterface(mContent);
 499   NS_ASSERTION(control,
 500                "Doesn't implement nsIDOMXULMultiSelectControlElement.");
 501
 502   nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
 503   control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
 504   control->RemoveItemFromSelection(item);
 505 }
 506
 507 ////////////////////////////////////////////////////////////////////////////////
 508 // XULListboxAccessible: Widgets
 509
 510 bool
 511 XULListboxAccessible::IsWidget() const
 512 {
 513   return true;
 514 }
 515
 516 bool
 517 XULListboxAccessible::IsActiveWidget() const
 518 {
 519   if (IsAutoCompletePopup()) {
 520     nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
 521       do_QueryInterface(mContent->GetParent());
 522
 523     if (autoCompletePopupElm) {
 524       bool isOpen = false;
 525       autoCompletePopupElm->GetPopupOpen(&isOpen);
 526       return isOpen;
 527     }
 528   }
 529   return FocusMgr()->HasDOMFocus(mContent);
 530 }
 531
 532 bool
 533 XULListboxAccessible::AreItemsOperable() const
 534 {
 535   if (IsAutoCompletePopup()) {
 536     nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
 537       do_QueryInterface(mContent->GetParent());
 538
 539     if (autoCompletePopupElm) {
 540       bool isOpen = false;
 541       autoCompletePopupElm->GetPopupOpen(&isOpen);
 542       return isOpen;
 543     }
 544   }
 545   return true;
 546 }
 547
 548 Accessible*
 549 XULListboxAccessible::ContainerWidget() const
 550 {
 551   if (IsAutoCompletePopup()) {
 552     // This works for XUL autocompletes. It doesn't work for HTML forms
 553     // autocomplete because of potential crossprocess calls (when autocomplete
 554     // lives in content process while popup lives in chrome process). If that's
 555     // a problem then rethink Widgets interface.
 556     nsCOMPtr<nsIDOMXULMenuListElement> menuListElm =
 557       do_QueryInterface(mContent->GetParent());
 558     if (menuListElm) {
 559       nsCOMPtr<nsIDOMNode> inputElm;
 560       menuListElm->GetInputField(getter_AddRefs(inputElm));
 561       if (inputElm) {
 562         nsCOMPtr<nsINode> inputNode = do_QueryInterface(inputElm);
 563         if (inputNode) {
 564           Accessible* input =
 565             mDoc->GetAccessible(inputNode);
 566           return input ? input->ContainerWidget() : nullptr;
 567         }
 568       }
 569     }
 570   }
 571   return nullptr;
 572 }
 573
 574 ////////////////////////////////////////////////////////////////////////////////
 575 // XULListitemAccessible
 576 ////////////////////////////////////////////////////////////////////////////////
 577
 578 XULListitemAccessible::
 579   XULListitemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
 580   XULMenuitemAccessible(aContent, aDoc)
 581 {
 582   mIsCheckbox = mContent->AttrValueIs(kNameSpaceID_None,
 583                                       nsGkAtoms::type,
 584                                       nsGkAtoms::checkbox,
 585                                       eCaseMatters);
 586   mType = eXULListItemType;
 587 }
 588
 589 XULListitemAccessible::~XULListitemAccessible()
 590 {
 591 }
 592
 593 NS_IMPL_ISUPPORTS_INHERITED0(XULListitemAccessible, Accessible)
 594
 595 Accessible*
 596 XULListitemAccessible::GetListAccessible()
 597 {
 598   if (IsDefunct())
 599     return nullptr;
 600
 601   nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
 602     do_QueryInterface(mContent);
 603   if (!listItem)
 604     return nullptr;
 605
 606   nsCOMPtr<nsIDOMXULSelectControlElement> list;
 607   listItem->GetControl(getter_AddRefs(list));
 608
 609   nsCOMPtr<nsIContent> listContent(do_QueryInterface(list));
 610   if (!listContent)
 611     return nullptr;
 612
 613   return mDoc->GetAccessible(listContent);
 614 }
 615
 616 ////////////////////////////////////////////////////////////////////////////////
 617 // XULListitemAccessible Accessible
 618
 619 void
 620 XULListitemAccessible::Description(nsString& aDesc)
 621 {
 622   AccessibleWrap::Description(aDesc);
 623 }
 624
 625 ////////////////////////////////////////////////////////////////////////////////
 626 // XULListitemAccessible. nsIAccessible
 627
 628 /**
 629   * If there is a Listcell as a child ( not anonymous ) use it, otherwise
 630   *   default to getting the name from GetXULName
 631   */
 632 ENameValueFlag
 633 XULListitemAccessible::NativeName(nsString& aName)
 634 {
 635   nsIContent* childContent = mContent->GetFirstChild();
 636   if (childContent) {
 637     if (childContent->NodeInfo()->Equals(nsGkAtoms::listcell,
 638                                          kNameSpaceID_XUL)) {
 639       childContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, aName);
 640       return eNameOK;
 641     }
 642   }
 643
 644   return Accessible::NativeName(aName);
 645 }
 646
 647 role
 648 XULListitemAccessible::NativeRole()
 649 {
 650   Accessible* list = GetListAccessible();
 651   if (!list) {
 652     NS_ERROR("No list accessible for listitem accessible!");
 653     return roles::NOTHING;
 654   }
 655
 656   if (list->Role() == roles::TABLE)
 657     return roles::ROW;
 658
 659   if (mIsCheckbox)
 660     return roles::CHECK_RICH_OPTION;
 661
 662   if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
 663     return roles::COMBOBOX_OPTION;
 664
 665   return roles::RICH_OPTION;
 666 }
 667
 668 uint64_t
 669 XULListitemAccessible::NativeState()
 670 {
 671   if (mIsCheckbox)
 672     return XULMenuitemAccessible::NativeState();
 673
 674   uint64_t states = NativeInteractiveState();
 675
 676   nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
 677     do_QueryInterface(mContent);
 678
 679   if (listItem) {
 680     bool isSelected;
 681     listItem->GetSelected(&isSelected);
 682     if (isSelected)
 683       states |= states::SELECTED;
 684
 685     if (FocusMgr()->IsFocused(this))
 686       states |= states::FOCUSED;
 687   }
 688
 689   return states;
 690 }
 691
 692 uint64_t
 693 XULListitemAccessible::NativeInteractiveState() const
 694 {
 695   return NativelyUnavailable() || (mParent && mParent->NativelyUnavailable()) ?
 696     states::UNAVAILABLE : states::FOCUSABLE | states::SELECTABLE;
 697 }
 698
 699 NS_IMETHODIMP
 700 XULListitemAccessible::GetActionName(uint8_t aIndex, nsAString& aName)
 701 {
 702   if (aIndex == eAction_Click && mIsCheckbox) {
 703     // check or uncheck
 704     uint64_t states = NativeState();
 705
 706     if (states & states::CHECKED)
 707       aName.AssignLiteral("uncheck");
 708     else
 709       aName.AssignLiteral("check");
 710
 711     return NS_OK;
 712   }
 713   return NS_ERROR_INVALID_ARG;
 714 }
 715
 716 bool
 717 XULListitemAccessible::CanHaveAnonChildren()
 718 {
 719   // That indicates we should walk anonymous children for listitems
 720   return true;
 721 }
 722
 723 ////////////////////////////////////////////////////////////////////////////////
 724 // XULListitemAccessible: Widgets
 725
 726 Accessible*
 727 XULListitemAccessible::ContainerWidget() const
 728 {
 729   return Parent();
 730 }
 731
 732
 733 ////////////////////////////////////////////////////////////////////////////////
 734 // XULListCellAccessible
 735 ////////////////////////////////////////////////////////////////////////////////
 736
 737 XULListCellAccessible::
 738   XULListCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
 739   HyperTextAccessibleWrap(aContent, aDoc), xpcAccessibleTableCell(this)
 740 {
 741   mGenericTypes |= eTableCell;
 742 }
 743
 744 ////////////////////////////////////////////////////////////////////////////////
 745 // nsISupports
 746
 747 NS_IMPL_ISUPPORTS_INHERITED(XULListCellAccessible,
 748                             HyperTextAccessible,
 749                             nsIAccessibleTableCell)
 750
 751 ////////////////////////////////////////////////////////////////////////////////
 752 // XULListCellAccessible: nsIAccessibleTableCell implementation
 753
 754 TableAccessible*
 755 XULListCellAccessible::Table() const
 756 {
 757   Accessible* thisRow = Parent();
 758   if (!thisRow || thisRow->Role() != roles::ROW)
 759     return nullptr;
 760
 761   Accessible* table = thisRow->Parent();
 762   if (!table || table->Role() != roles::TABLE)
 763     return nullptr;
 764
 765   return table->AsTable();
 766 }
 767
 768 uint32_t
 769 XULListCellAccessible::ColIdx() const
 770 {
 771   Accessible* row = Parent();
 772   if (!row)
 773     return 0;
 774
 775   int32_t indexInRow = IndexInParent();
 776   uint32_t colIdx = 0;
 777   for (int32_t idx = 0; idx < indexInRow; idx++) {
 778     Accessible* cell = row->GetChildAt(idx);
 779     roles::Role role = cell->Role();
 780     if (role == roles::CELL || role == roles::GRID_CELL ||
 781         role == roles::ROWHEADER || role == roles::COLUMNHEADER)
 782       colIdx++;
 783   }
 784
 785   return colIdx;
 786 }
 787
 788 uint32_t
 789 XULListCellAccessible::RowIdx() const
 790 {
 791   Accessible* row = Parent();
 792   if (!row)
 793     return 0;
 794
 795   Accessible* table = row->Parent();
 796   if (!table)
 797     return 0;
 798
 799   int32_t indexInTable = row->IndexInParent();
 800   uint32_t rowIdx = 0;
 801   for (int32_t idx = 0; idx < indexInTable; idx++) {
 802     row = table->GetChildAt(idx);
 803     if (row->Role() == roles::ROW)
 804       rowIdx++;
 805   }
 806
 807   return rowIdx;
 808 }
 809
 810 void
 811 XULListCellAccessible::ColHeaderCells(nsTArray<Accessible*>* aCells)
 812 {
 813   TableAccessible* table = Table();
 814   NS_ASSERTION(table, "cell not in a table!");
 815   if (!table)
 816     return;
 817
 818   // Get column header cell from XUL listhead.
 819   Accessible* list = nullptr;
 820
 821   Accessible* tableAcc = table->AsAccessible();
 822   uint32_t tableChildCount = tableAcc->ChildCount();
 823   for (uint32_t childIdx = 0; childIdx < tableChildCount; childIdx++) {
 824     Accessible* child = tableAcc->GetChildAt(childIdx);
 825     if (child->Role() == roles::LIST) {
 826       list = child;
 827       break;
 828     }
 829   }
 830
 831   if (list) {
 832     Accessible* headerCell = list->GetChildAt(ColIdx());
 833     if (headerCell) {
 834       aCells->AppendElement(headerCell);
 835       return;
 836     }
 837   }
 838
 839   // No column header cell from XUL markup, try to get it from ARIA markup.
 840   TableCellAccessible::ColHeaderCells(aCells);
 841 }
 842
 843 bool
 844 XULListCellAccessible::Selected()
 845 {
 846   TableAccessible* table = Table();
 847   NS_ENSURE_TRUE(table, false); // we expect to be in a listbox (table)
 848
 849   return table->IsRowSelected(RowIdx());
 850 }
 851
 852 ////////////////////////////////////////////////////////////////////////////////
 853 // XULListCellAccessible. Accessible implementation
 854
 855 void
 856 XULListCellAccessible::Shutdown()
 857 {
 858   mTableCell = nullptr;
 859   HyperTextAccessibleWrap::Shutdown();
 860 }
 861
 862 role
 863 XULListCellAccessible::NativeRole()
 864 {
 865   return roles::CELL;
 866 }
 867
 868 already_AddRefed<nsIPersistentProperties>
 869 XULListCellAccessible::NativeAttributes()
 870 {
 871   nsCOMPtr<nsIPersistentProperties> attributes =
 872     HyperTextAccessibleWrap::NativeAttributes();
 873
 874   // "table-cell-index" attribute
 875   TableAccessible* table = Table();
 876   if (!table) // we expect to be in a listbox (table)
 877     return attributes.forget();
 878
 879   nsAutoString stringIdx;
 880   stringIdx.AppendInt(table->CellIndexAt(RowIdx(), ColIdx()));
 881   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tableCellIndex, stringIdx);
 882
 883   return attributes.forget();
 884 }