Mirror of roytam1's UXP fork just in case Moonchild and Tobin decide to go after him
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

828 lines
22 KiB

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "XULListboxAccessible.h"
#include "Accessible-inl.h"
#include "nsAccessibilityService.h"
#include "nsAccUtils.h"
#include "DocAccessible.h"
#include "Role.h"
#include "States.h"
#include "nsComponentManagerUtils.h"
#include "nsIAutoCompleteInput.h"
#include "nsIAutoCompletePopup.h"
#include "nsIDOMXULMenuListElement.h"
#include "nsIDOMXULMultSelectCntrlEl.h"
#include "nsIDOMNodeList.h"
#include "nsIDOMXULPopupElement.h"
#include "nsIDOMXULSelectCntrlItemEl.h"
#include "nsIMutableArray.h"
#include "nsIPersistentProperties2.h"
using namespace mozilla::a11y;
////////////////////////////////////////////////////////////////////////////////
// XULColumAccessible
////////////////////////////////////////////////////////////////////////////////
XULColumAccessible::
XULColumAccessible(nsIContent* aContent, DocAccessible* aDoc) :
AccessibleWrap(aContent, aDoc)
{
}
role
XULColumAccessible::NativeRole()
{
return roles::LIST;
}
uint64_t
XULColumAccessible::NativeState()
{
return states::READONLY;
}
////////////////////////////////////////////////////////////////////////////////
// XULColumnItemAccessible
////////////////////////////////////////////////////////////////////////////////
XULColumnItemAccessible::
XULColumnItemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
LeafAccessible(aContent, aDoc)
{
}
role
XULColumnItemAccessible::NativeRole()
{
return roles::COLUMNHEADER;
}
uint64_t
XULColumnItemAccessible::NativeState()
{
return states::READONLY;
}
uint8_t
XULColumnItemAccessible::ActionCount()
{
return 1;
}
void
XULColumnItemAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName)
{
if (aIndex == eAction_Click)
aName.AssignLiteral("click");
}
bool
XULColumnItemAccessible::DoAction(uint8_t aIndex)
{
if (aIndex != eAction_Click)
return false;
DoCommand();
return true;
}
////////////////////////////////////////////////////////////////////////////////
// XULListboxAccessible
////////////////////////////////////////////////////////////////////////////////
XULListboxAccessible::
XULListboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
XULSelectControlAccessible(aContent, aDoc)
{
nsIContent* parentContent = mContent->GetFlattenedTreeParent();
if (parentContent) {
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
do_QueryInterface(parentContent);
if (autoCompletePopupElm)
mGenericTypes |= eAutoCompletePopup;
}
if (IsMulticolumn())
mGenericTypes |= eTable;
}
////////////////////////////////////////////////////////////////////////////////
// XULListboxAccessible: Accessible
uint64_t
XULListboxAccessible::NativeState()
{
// As a XULListboxAccessible we can have the following states:
// FOCUSED, READONLY, FOCUSABLE
// Get focus status from base class
uint64_t states = Accessible::NativeState();
// see if we are multiple select if so set ourselves as such
if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::seltype,
nsGkAtoms::multiple, eCaseMatters)) {
states |= states::MULTISELECTABLE | states::EXTSELECTABLE;
}
return states;
}
/**
* Our value is the label of our ( first ) selected child.
*/
void
XULListboxAccessible::Value(nsString& aValue)
{
aValue.Truncate();
nsCOMPtr<nsIDOMXULSelectControlElement> select(do_QueryInterface(mContent));
if (select) {
nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;
select->GetSelectedItem(getter_AddRefs(selectedItem));
if (selectedItem)
selectedItem->GetLabel(aValue);
}
}
role
XULListboxAccessible::NativeRole()
{
// A richlistbox is used with the new autocomplete URL bar, and has a parent
// popup <panel>.
nsCOMPtr<nsIDOMXULPopupElement> xulPopup =
do_QueryInterface(mContent->GetParent());
if (xulPopup)
return roles::COMBOBOX_LIST;
return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
}
////////////////////////////////////////////////////////////////////////////////
// XULListboxAccessible: Table
uint32_t
XULListboxAccessible::ColCount()
{
nsIContent* headContent = nullptr;
for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
childContent = childContent->GetNextSibling()) {
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcols,
kNameSpaceID_XUL)) {
headContent = childContent;
}
}
if (!headContent)
return 0;
uint32_t columnCount = 0;
for (nsIContent* childContent = headContent->GetFirstChild(); childContent;
childContent = childContent->GetNextSibling()) {
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcol,
kNameSpaceID_XUL)) {
columnCount++;
}
}
return columnCount;
}
uint32_t
XULListboxAccessible::RowCount()
{
nsCOMPtr<nsIDOMXULSelectControlElement> element(do_QueryInterface(mContent));
uint32_t itemCount = 0;
if(element)
element->GetItemCount(&itemCount);
return itemCount;
}
Accessible*
XULListboxAccessible::CellAt(uint32_t aRowIndex, uint32_t aColumnIndex)
{
nsCOMPtr<nsIDOMXULSelectControlElement> control =
do_QueryInterface(mContent);
NS_ENSURE_TRUE(control, nullptr);
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
control->GetItemAtIndex(aRowIndex, getter_AddRefs(item));
if (!item)
return nullptr;
nsCOMPtr<nsIContent> itemContent(do_QueryInterface(item));
if (!itemContent)
return nullptr;
Accessible* row = mDoc->GetAccessible(itemContent);
NS_ENSURE_TRUE(row, nullptr);
return row->GetChildAt(aColumnIndex);
}
bool
XULListboxAccessible::IsColSelected(uint32_t aColIdx)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
int32_t selectedrowCount = 0;
nsresult rv = control->GetSelectedCount(&selectedrowCount);
NS_ENSURE_SUCCESS(rv, false);
return selectedrowCount == static_cast<int32_t>(RowCount());
}
bool
XULListboxAccessible::IsRowSelected(uint32_t aRowIdx)
{
nsCOMPtr<nsIDOMXULSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULSelectControlElement.");
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
nsresult rv = control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
NS_ENSURE_SUCCESS(rv, false);
bool isSelected = false;
item->GetSelected(&isSelected);
return isSelected;
}
bool
XULListboxAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx)
{
return IsRowSelected(aRowIdx);
}
uint32_t
XULListboxAccessible::SelectedCellCount()
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return 0;
uint32_t selectedItemsCount = 0;
nsresult rv = selectedItems->GetLength(&selectedItemsCount);
NS_ENSURE_SUCCESS(rv, 0);
return selectedItemsCount * ColCount();
}
uint32_t
XULListboxAccessible::SelectedColCount()
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
int32_t selectedRowCount = 0;
nsresult rv = control->GetSelectedCount(&selectedRowCount);
NS_ENSURE_SUCCESS(rv, 0);
return selectedRowCount > 0 &&
selectedRowCount == static_cast<int32_t>(RowCount()) ? ColCount() : 0;
}
uint32_t
XULListboxAccessible::SelectedRowCount()
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
int32_t selectedRowCount = 0;
nsresult rv = control->GetSelectedCount(&selectedRowCount);
NS_ENSURE_SUCCESS(rv, 0);
return selectedRowCount >= 0 ? selectedRowCount : 0;
}
void
XULListboxAccessible::SelectedCells(nsTArray<Accessible*>* aCells)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return;
uint32_t selectedItemsCount = 0;
DebugOnly<nsresult> rv = selectedItems->GetLength(&selectedItemsCount);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
for (uint32_t index = 0; index < selectedItemsCount; index++) {
nsCOMPtr<nsIDOMNode> itemNode;
selectedItems->Item(index, getter_AddRefs(itemNode));
nsCOMPtr<nsIContent> itemContent(do_QueryInterface(itemNode));
Accessible* item = mDoc->GetAccessible(itemContent);
if (item) {
uint32_t cellCount = item->ChildCount();
for (uint32_t cellIdx = 0; cellIdx < cellCount; cellIdx++) {
Accessible* cell = mChildren[cellIdx];
if (cell->Role() == roles::CELL)
aCells->AppendElement(cell);
}
}
}
}
void
XULListboxAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return;
uint32_t selectedItemsCount = 0;
DebugOnly<nsresult> rv = selectedItems->GetLength(&selectedItemsCount);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
uint32_t colCount = ColCount();
aCells->SetCapacity(selectedItemsCount * colCount);
aCells->AppendElements(selectedItemsCount * colCount);
for (uint32_t selItemsIdx = 0, cellsIdx = 0;
selItemsIdx < selectedItemsCount; selItemsIdx++) {
nsCOMPtr<nsIDOMNode> itemNode;
selectedItems->Item(selItemsIdx, getter_AddRefs(itemNode));
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
do_QueryInterface(itemNode);
if (item) {
int32_t itemIdx = -1;
control->GetIndexOfItem(item, &itemIdx);
if (itemIdx >= 0)
for (uint32_t colIdx = 0; colIdx < colCount; colIdx++, cellsIdx++)
aCells->ElementAt(cellsIdx) = itemIdx * colCount + colIdx;
}
}
}
void
XULListboxAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols)
{
uint32_t selColCount = SelectedColCount();
aCols->SetCapacity(selColCount);
for (uint32_t colIdx = 0; colIdx < selColCount; colIdx++)
aCols->AppendElement(colIdx);
}
void
XULListboxAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMNodeList> selectedItems;
control->GetSelectedItems(getter_AddRefs(selectedItems));
if (!selectedItems)
return;
uint32_t rowCount = 0;
DebugOnly<nsresult> rv = selectedItems->GetLength(&rowCount);
NS_ASSERTION(NS_SUCCEEDED(rv), "GetLength() Shouldn't fail!");
if (!rowCount)
return;
aRows->SetCapacity(rowCount);
aRows->AppendElements(rowCount);
for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
nsCOMPtr<nsIDOMNode> itemNode;
selectedItems->Item(rowIdx, getter_AddRefs(itemNode));
nsCOMPtr<nsIDOMXULSelectControlItemElement> item =
do_QueryInterface(itemNode);
if (item) {
int32_t itemIdx = -1;
control->GetIndexOfItem(item, &itemIdx);
if (itemIdx >= 0)
aRows->ElementAt(rowIdx) = itemIdx;
}
}
}
void
XULListboxAccessible::SelectRow(uint32_t aRowIdx)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
control->SelectItem(item);
}
void
XULListboxAccessible::UnselectRow(uint32_t aRowIdx)
{
nsCOMPtr<nsIDOMXULMultiSelectControlElement> control =
do_QueryInterface(mContent);
NS_ASSERTION(control,
"Doesn't implement nsIDOMXULMultiSelectControlElement.");
nsCOMPtr<nsIDOMXULSelectControlItemElement> item;
control->GetItemAtIndex(aRowIdx, getter_AddRefs(item));
control->RemoveItemFromSelection(item);
}
////////////////////////////////////////////////////////////////////////////////
// XULListboxAccessible: Widgets
bool
XULListboxAccessible::IsWidget() const
{
return true;
}
bool
XULListboxAccessible::IsActiveWidget() const
{
if (IsAutoCompletePopup()) {
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
do_QueryInterface(mContent->GetParent());
if (autoCompletePopupElm) {
bool isOpen = false;
autoCompletePopupElm->GetPopupOpen(&isOpen);
return isOpen;
}
}
return FocusMgr()->HasDOMFocus(mContent);
}
bool
XULListboxAccessible::AreItemsOperable() const
{
if (IsAutoCompletePopup()) {
nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
do_QueryInterface(mContent->GetParent());
if (autoCompletePopupElm) {
bool isOpen = false;
autoCompletePopupElm->GetPopupOpen(&isOpen);
return isOpen;
}
}
return true;
}
Accessible*
XULListboxAccessible::ContainerWidget() const
{
if (IsAutoCompletePopup()) {
// This works for XUL autocompletes. It doesn't work for HTML forms
// autocomplete because of potential crossprocess calls (when autocomplete
// lives in content process while popup lives in chrome process). If that's
// a problem then rethink Widgets interface.
nsCOMPtr<nsIDOMXULMenuListElement> menuListElm =
do_QueryInterface(mContent->GetParent());
if (menuListElm) {
nsCOMPtr<nsIDOMNode> inputElm;
menuListElm->GetInputField(getter_AddRefs(inputElm));
if (inputElm) {
nsCOMPtr<nsINode> inputNode = do_QueryInterface(inputElm);
if (inputNode) {
Accessible* input =
mDoc->GetAccessible(inputNode);
return input ? input->ContainerWidget() : nullptr;
}
}
}
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
// XULListitemAccessible
////////////////////////////////////////////////////////////////////////////////
XULListitemAccessible::
XULListitemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
XULMenuitemAccessible(aContent, aDoc)
{
mIsCheckbox = mContent->AttrValueIs(kNameSpaceID_None,
nsGkAtoms::type,
nsGkAtoms::checkbox,
eCaseMatters);
mType = eXULListItemType;
// Walk XBL anonymous children for list items. Overrides the flag value from
// base XULMenuitemAccessible class.
mStateFlags &= ~eNoXBLKids;
}
XULListitemAccessible::~XULListitemAccessible()
{
}
NS_IMPL_ISUPPORTS_INHERITED0(XULListitemAccessible, Accessible)
Accessible*
XULListitemAccessible::GetListAccessible() const
{
if (IsDefunct())
return nullptr;
nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
do_QueryInterface(mContent);
if (!listItem)
return nullptr;
nsCOMPtr<nsIDOMXULSelectControlElement> list;
listItem->GetControl(getter_AddRefs(list));
nsCOMPtr<nsIContent> listContent(do_QueryInterface(list));
if (!listContent)
return nullptr;
return mDoc->GetAccessible(listContent);
}
////////////////////////////////////////////////////////////////////////////////
// XULListitemAccessible Accessible
void
XULListitemAccessible::Description(nsString& aDesc)
{
AccessibleWrap::Description(aDesc);
}
////////////////////////////////////////////////////////////////////////////////
// XULListitemAccessible: Accessible
/**
* If there is a Listcell as a child ( not anonymous ) use it, otherwise
* default to getting the name from GetXULName
*/
ENameValueFlag
XULListitemAccessible::NativeName(nsString& aName)
{
nsIContent* childContent = mContent->GetFirstChild();
if (childContent) {
if (childContent->NodeInfo()->Equals(nsGkAtoms::listcell,
kNameSpaceID_XUL)) {
childContent->GetAttr(kNameSpaceID_None, nsGkAtoms::label, aName);
return eNameOK;
}
}
return Accessible::NativeName(aName);
}
role
XULListitemAccessible::NativeRole()
{
Accessible* list = GetListAccessible();
if (!list) {
NS_ERROR("No list accessible for listitem accessible!");
return roles::NOTHING;
}
if (list->Role() == roles::TABLE)
return roles::ROW;
if (mIsCheckbox)
return roles::CHECK_RICH_OPTION;
if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
return roles::COMBOBOX_OPTION;
return roles::RICH_OPTION;
}
uint64_t
XULListitemAccessible::NativeState()
{
if (mIsCheckbox)
return XULMenuitemAccessible::NativeState();
uint64_t states = NativeInteractiveState();
nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
do_QueryInterface(mContent);
if (listItem) {
bool isSelected;
listItem->GetSelected(&isSelected);
if (isSelected)
states |= states::SELECTED;
if (FocusMgr()->IsFocused(this))
states |= states::FOCUSED;
}
return states;
}
uint64_t
XULListitemAccessible::NativeInteractiveState() const
{
return NativelyUnavailable() || (mParent && mParent->NativelyUnavailable()) ?
states::UNAVAILABLE : states::FOCUSABLE | states::SELECTABLE;
}
void
XULListitemAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName)
{
if (aIndex == eAction_Click && mIsCheckbox) {
uint64_t states = NativeState();
if (states & states::CHECKED)
aName.AssignLiteral("uncheck");
else
aName.AssignLiteral("check");
}
}
////////////////////////////////////////////////////////////////////////////////
// XULListitemAccessible: Widgets
Accessible*
XULListitemAccessible::ContainerWidget() const
{
return Parent();
}
////////////////////////////////////////////////////////////////////////////////
// XULListCellAccessible
////////////////////////////////////////////////////////////////////////////////
XULListCellAccessible::
XULListCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
HyperTextAccessibleWrap(aContent, aDoc)
{
mGenericTypes |= eTableCell;
}
////////////////////////////////////////////////////////////////////////////////
// nsISupports
NS_IMPL_ISUPPORTS_INHERITED0(XULListCellAccessible,
HyperTextAccessible)
////////////////////////////////////////////////////////////////////////////////
// XULListCellAccessible: TableCell
TableAccessible*
XULListCellAccessible::Table() const
{
Accessible* thisRow = Parent();
if (!thisRow || thisRow->Role() != roles::ROW)
return nullptr;
Accessible* table = thisRow->Parent();
if (!table || table->Role() != roles::TABLE)
return nullptr;
return table->AsTable();
}
uint32_t
XULListCellAccessible::ColIdx() const
{
Accessible* row = Parent();
if (!row)
return 0;
int32_t indexInRow = IndexInParent();
uint32_t colIdx = 0;
for (int32_t idx = 0; idx < indexInRow; idx++) {
Accessible* cell = row->GetChildAt(idx);
roles::Role role = cell->Role();
if (role == roles::CELL || role == roles::GRID_CELL ||
role == roles::ROWHEADER || role == roles::COLUMNHEADER)
colIdx++;
}
return colIdx;
}
uint32_t
XULListCellAccessible::RowIdx() const
{
Accessible* row = Parent();
if (!row)
return 0;
Accessible* table = row->Parent();
if (!table)
return 0;
int32_t indexInTable = row->IndexInParent();
uint32_t rowIdx = 0;
for (int32_t idx = 0; idx < indexInTable; idx++) {
row = table->GetChildAt(idx);
if (row->Role() == roles::ROW)
rowIdx++;
}
return rowIdx;
}
void
XULListCellAccessible::ColHeaderCells(nsTArray<Accessible*>* aCells)
{
TableAccessible* table = Table();
NS_ASSERTION(table, "cell not in a table!");
if (!table)
return;
// Get column header cell from XUL listhead.
Accessible* list = nullptr;
Accessible* tableAcc = table->AsAccessible();
uint32_t tableChildCount = tableAcc->ChildCount();
for (uint32_t childIdx = 0; childIdx < tableChildCount; childIdx++) {
Accessible* child = tableAcc->GetChildAt(childIdx);
if (child->Role() == roles::LIST) {
list = child;
break;
}
}
if (list) {
Accessible* headerCell = list->GetChildAt(ColIdx());
if (headerCell) {
aCells->AppendElement(headerCell);
return;
}
}
// No column header cell from XUL markup, try to get it from ARIA markup.
TableCellAccessible::ColHeaderCells(aCells);
}
bool
XULListCellAccessible::Selected()
{
TableAccessible* table = Table();
NS_ENSURE_TRUE(table, false); // we expect to be in a listbox (table)
return table->IsRowSelected(RowIdx());
}
////////////////////////////////////////////////////////////////////////////////
// XULListCellAccessible. Accessible implementation
role
XULListCellAccessible::NativeRole()
{
return roles::CELL;
}
already_AddRefed<nsIPersistentProperties>
XULListCellAccessible::NativeAttributes()
{
nsCOMPtr<nsIPersistentProperties> attributes =
HyperTextAccessibleWrap::NativeAttributes();
// "table-cell-index" attribute
TableAccessible* table = Table();
if (!table) // we expect to be in a listbox (table)
return attributes.forget();
nsAutoString stringIdx;
stringIdx.AppendInt(table->CellIndexAt(RowIdx(), ColIdx()));
nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tableCellIndex, stringIdx);
return attributes.forget();
}