mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-27 06:43:32 +00:00
c68c3ca8b3
Role.h will soon be generated, but it is generated within the obj dir, so local includes won't work. Our C++ style guide says we should prefer exported includes wherever possible anyway. This was done with this shell command inside the accessible/ directory: ``` sed -i 's,#include "Role.h",#include "mozilla/a11y/Role.h",' `git grep -l '#include "Role.h"'` ``` Differential Revision: https://phabricator.services.mozilla.com/D183940
667 lines
21 KiB
C++
667 lines
21 KiB
C++
/* -*- Mode: C++; tab-width: 2; 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 "XULTreeGridAccessible.h"
|
|
|
|
#include <stdint.h>
|
|
#include "AccAttributes.h"
|
|
#include "LocalAccessible-inl.h"
|
|
#include "nsAccCache.h"
|
|
#include "nsAccessibilityService.h"
|
|
#include "nsAccUtils.h"
|
|
#include "DocAccessible.h"
|
|
#include "nsEventShell.h"
|
|
#include "Relation.h"
|
|
#include "mozilla/a11y/Role.h"
|
|
#include "States.h"
|
|
#include "nsQueryObject.h"
|
|
#include "nsTreeColumns.h"
|
|
|
|
#include "nsITreeSelection.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/a11y/TableAccessible.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/dom/TreeColumnBinding.h"
|
|
#include "mozilla/dom/XULTreeElementBinding.h"
|
|
|
|
using namespace mozilla::a11y;
|
|
using namespace mozilla;
|
|
|
|
XULTreeGridAccessible::~XULTreeGridAccessible() {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridAccessible: Table
|
|
|
|
uint32_t XULTreeGridAccessible::ColCount() const {
|
|
return nsCoreUtils::GetSensibleColumnCount(mTree);
|
|
}
|
|
|
|
uint32_t XULTreeGridAccessible::RowCount() {
|
|
if (!mTreeView) return 0;
|
|
|
|
int32_t rowCount = 0;
|
|
mTreeView->GetRowCount(&rowCount);
|
|
return rowCount >= 0 ? rowCount : 0;
|
|
}
|
|
|
|
uint32_t XULTreeGridAccessible::SelectedCellCount() {
|
|
return SelectedRowCount() * ColCount();
|
|
}
|
|
|
|
uint32_t XULTreeGridAccessible::SelectedColCount() {
|
|
// If all the row has been selected, then all the columns are selected,
|
|
// because we can't select a column alone.
|
|
|
|
uint32_t selectedRowCount = SelectedItemCount();
|
|
return selectedRowCount > 0 && selectedRowCount == RowCount() ? ColCount()
|
|
: 0;
|
|
}
|
|
|
|
uint32_t XULTreeGridAccessible::SelectedRowCount() {
|
|
return SelectedItemCount();
|
|
}
|
|
|
|
void XULTreeGridAccessible::SelectedCells(nsTArray<Accessible*>* aCells) {
|
|
uint32_t colCount = ColCount(), rowCount = RowCount();
|
|
|
|
for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
|
|
if (IsRowSelected(rowIdx)) {
|
|
for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
|
|
LocalAccessible* cell = CellAt(rowIdx, colIdx);
|
|
aCells->AppendElement(cell);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void XULTreeGridAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells) {
|
|
uint32_t colCount = ColCount(), rowCount = RowCount();
|
|
|
|
for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
|
|
if (IsRowSelected(rowIdx)) {
|
|
for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
|
|
aCells->AppendElement(rowIdx * colCount + colIdx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void XULTreeGridAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols) {
|
|
if (RowCount() != SelectedRowCount()) return;
|
|
|
|
uint32_t colCount = ColCount();
|
|
aCols->SetCapacity(colCount);
|
|
for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
|
|
aCols->AppendElement(colIdx);
|
|
}
|
|
}
|
|
|
|
void XULTreeGridAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows) {
|
|
uint32_t rowCount = RowCount();
|
|
for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
|
|
if (IsRowSelected(rowIdx)) aRows->AppendElement(rowIdx);
|
|
}
|
|
}
|
|
|
|
LocalAccessible* XULTreeGridAccessible::CellAt(uint32_t aRowIndex,
|
|
uint32_t aColumnIndex) {
|
|
XULTreeItemAccessibleBase* rowAcc = GetTreeItemAccessible(aRowIndex);
|
|
if (!rowAcc) return nullptr;
|
|
|
|
RefPtr<nsTreeColumn> column =
|
|
nsCoreUtils::GetSensibleColumnAt(mTree, aColumnIndex);
|
|
if (!column) return nullptr;
|
|
|
|
return rowAcc->GetCellAccessible(column);
|
|
}
|
|
|
|
void XULTreeGridAccessible::ColDescription(uint32_t aColIdx,
|
|
nsString& aDescription) {
|
|
aDescription.Truncate();
|
|
|
|
LocalAccessible* treeColumns = LocalAccessible::LocalChildAt(0);
|
|
if (treeColumns) {
|
|
LocalAccessible* treeColumnItem = treeColumns->LocalChildAt(aColIdx);
|
|
if (treeColumnItem) treeColumnItem->Name(aDescription);
|
|
}
|
|
}
|
|
|
|
bool XULTreeGridAccessible::IsColSelected(uint32_t aColIdx) {
|
|
// If all the row has been selected, then all the columns are selected.
|
|
// Because we can't select a column alone.
|
|
return SelectedItemCount() == RowCount();
|
|
}
|
|
|
|
bool XULTreeGridAccessible::IsRowSelected(uint32_t aRowIdx) {
|
|
if (!mTreeView) return false;
|
|
|
|
nsCOMPtr<nsITreeSelection> selection;
|
|
nsresult rv = mTreeView->GetSelection(getter_AddRefs(selection));
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
bool isSelected = false;
|
|
selection->IsSelected(aRowIdx, &isSelected);
|
|
return isSelected;
|
|
}
|
|
|
|
bool XULTreeGridAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) {
|
|
return IsRowSelected(aRowIdx);
|
|
}
|
|
|
|
int32_t XULTreeGridAccessible::ColIndexAt(uint32_t aCellIdx) {
|
|
uint32_t colCount = ColCount();
|
|
if (colCount < 1 || aCellIdx >= colCount * RowCount()) {
|
|
return -1; // Error: column count is 0 or index out of bounds.
|
|
}
|
|
|
|
return static_cast<int32_t>(aCellIdx % colCount);
|
|
}
|
|
|
|
int32_t XULTreeGridAccessible::RowIndexAt(uint32_t aCellIdx) {
|
|
uint32_t colCount = ColCount();
|
|
if (colCount < 1 || aCellIdx >= colCount * RowCount()) {
|
|
return -1; // Error: column count is 0 or index out of bounds.
|
|
}
|
|
|
|
return static_cast<int32_t>(aCellIdx / colCount);
|
|
}
|
|
|
|
void XULTreeGridAccessible::RowAndColIndicesAt(uint32_t aCellIdx,
|
|
int32_t* aRowIdx,
|
|
int32_t* aColIdx) {
|
|
uint32_t colCount = ColCount();
|
|
if (colCount < 1 || aCellIdx >= colCount * RowCount()) {
|
|
*aRowIdx = -1;
|
|
*aColIdx = -1;
|
|
return; // Error: column count is 0 or index out of bounds.
|
|
}
|
|
|
|
*aRowIdx = static_cast<int32_t>(aCellIdx / colCount);
|
|
*aColIdx = static_cast<int32_t>(aCellIdx % colCount);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridAccessible: LocalAccessible implementation
|
|
|
|
role XULTreeGridAccessible::NativeRole() const {
|
|
RefPtr<nsTreeColumns> treeColumns = mTree->GetColumns(FlushType::None);
|
|
if (!treeColumns) {
|
|
NS_ERROR("No treecolumns object for tree!");
|
|
return roles::NOTHING;
|
|
}
|
|
|
|
nsTreeColumn* primaryColumn = treeColumns->GetPrimaryColumn();
|
|
|
|
return primaryColumn ? roles::TREE_TABLE : roles::TABLE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridAccessible: XULTreeAccessible implementation
|
|
|
|
already_AddRefed<XULTreeItemAccessibleBase>
|
|
XULTreeGridAccessible::CreateTreeItemAccessible(int32_t aRow) const {
|
|
RefPtr<XULTreeItemAccessibleBase> accessible = new XULTreeGridRowAccessible(
|
|
mContent, mDoc, const_cast<XULTreeGridAccessible*>(this), mTree,
|
|
mTreeView, aRow);
|
|
|
|
return accessible.forget();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridRowAccessible
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
XULTreeGridRowAccessible::XULTreeGridRowAccessible(
|
|
nsIContent* aContent, DocAccessible* aDoc, LocalAccessible* aTreeAcc,
|
|
dom::XULTreeElement* aTree, nsITreeView* aTreeView, int32_t aRow)
|
|
: XULTreeItemAccessibleBase(aContent, aDoc, aTreeAcc, aTree, aTreeView,
|
|
aRow),
|
|
mAccessibleCache(kDefaultTreeCacheLength) {
|
|
mGenericTypes |= eTableRow;
|
|
mStateFlags |= eNoKidsFromDOM;
|
|
}
|
|
|
|
XULTreeGridRowAccessible::~XULTreeGridRowAccessible() {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridRowAccessible: nsISupports and cycle collection implementation
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeGridRowAccessible,
|
|
XULTreeItemAccessibleBase, mAccessibleCache)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeGridRowAccessible)
|
|
NS_INTERFACE_MAP_END_INHERITING(XULTreeItemAccessibleBase)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(XULTreeGridRowAccessible, XULTreeItemAccessibleBase)
|
|
NS_IMPL_RELEASE_INHERITED(XULTreeGridRowAccessible, XULTreeItemAccessibleBase)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridRowAccessible: LocalAccessible implementation
|
|
|
|
void XULTreeGridRowAccessible::Shutdown() {
|
|
if (mDoc && !mDoc->IsDefunct()) {
|
|
UnbindCacheEntriesFromDocument(mAccessibleCache);
|
|
}
|
|
|
|
XULTreeItemAccessibleBase::Shutdown();
|
|
}
|
|
|
|
role XULTreeGridRowAccessible::NativeRole() const { return roles::ROW; }
|
|
|
|
ENameValueFlag XULTreeGridRowAccessible::Name(nsString& aName) const {
|
|
aName.Truncate();
|
|
|
|
// XXX: the row name sholdn't be a concatenation of cell names (bug 664384).
|
|
RefPtr<nsTreeColumn> column = nsCoreUtils::GetFirstSensibleColumn(mTree);
|
|
while (column) {
|
|
if (!aName.IsEmpty()) aName.Append(' ');
|
|
|
|
nsAutoString cellName;
|
|
GetCellName(column, cellName);
|
|
aName.Append(cellName);
|
|
|
|
column = nsCoreUtils::GetNextSensibleColumn(column);
|
|
}
|
|
|
|
return eNameOK;
|
|
}
|
|
|
|
LocalAccessible* XULTreeGridRowAccessible::LocalChildAtPoint(
|
|
int32_t aX, int32_t aY, EWhichChildAtPoint aWhichChild) {
|
|
nsIFrame* frame = GetFrame();
|
|
if (!frame) return nullptr;
|
|
|
|
nsPresContext* presContext = frame->PresContext();
|
|
PresShell* presShell = presContext->PresShell();
|
|
|
|
nsIFrame* rootFrame = presShell->GetRootFrame();
|
|
NS_ENSURE_TRUE(rootFrame, nullptr);
|
|
|
|
CSSIntRect rootRect = rootFrame->GetScreenRect();
|
|
|
|
int32_t clientX = presContext->DevPixelsToIntCSSPixels(aX) - rootRect.X();
|
|
int32_t clientY = presContext->DevPixelsToIntCSSPixels(aY) - rootRect.Y();
|
|
|
|
ErrorResult rv;
|
|
dom::TreeCellInfo cellInfo;
|
|
mTree->GetCellAt(clientX, clientY, cellInfo, rv);
|
|
|
|
// Return if we failed to find tree cell in the row for the given point.
|
|
if (cellInfo.mRow != mRow || !cellInfo.mCol) return nullptr;
|
|
|
|
return GetCellAccessible(cellInfo.mCol);
|
|
}
|
|
|
|
LocalAccessible* XULTreeGridRowAccessible::LocalChildAt(uint32_t aIndex) const {
|
|
if (IsDefunct()) return nullptr;
|
|
|
|
RefPtr<nsTreeColumn> column = nsCoreUtils::GetSensibleColumnAt(mTree, aIndex);
|
|
if (!column) return nullptr;
|
|
|
|
return GetCellAccessible(column);
|
|
}
|
|
|
|
uint32_t XULTreeGridRowAccessible::ChildCount() const {
|
|
return nsCoreUtils::GetSensibleColumnCount(mTree);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridRowAccessible: XULTreeItemAccessibleBase implementation
|
|
|
|
XULTreeGridCellAccessible* XULTreeGridRowAccessible::GetCellAccessible(
|
|
nsTreeColumn* aColumn) const {
|
|
MOZ_ASSERT(aColumn, "No tree column!");
|
|
|
|
void* key = static_cast<void*>(aColumn);
|
|
XULTreeGridCellAccessible* cachedCell = mAccessibleCache.GetWeak(key);
|
|
if (cachedCell) return cachedCell;
|
|
|
|
RefPtr<XULTreeGridCellAccessible> cell = new XULTreeGridCellAccessible(
|
|
mContent, mDoc, const_cast<XULTreeGridRowAccessible*>(this), mTree,
|
|
mTreeView, mRow, aColumn);
|
|
mAccessibleCache.InsertOrUpdate(key, RefPtr{cell});
|
|
Document()->BindToDocument(cell, nullptr);
|
|
return cell;
|
|
}
|
|
|
|
void XULTreeGridRowAccessible::RowInvalidated(int32_t aStartColIdx,
|
|
int32_t aEndColIdx) {
|
|
RefPtr<nsTreeColumns> treeColumns = mTree->GetColumns(FlushType::None);
|
|
if (!treeColumns) return;
|
|
|
|
bool nameChanged = false;
|
|
for (int32_t colIdx = aStartColIdx; colIdx <= aEndColIdx; ++colIdx) {
|
|
nsTreeColumn* column = treeColumns->GetColumnAt(colIdx);
|
|
if (column && !nsCoreUtils::IsColumnHidden(column)) {
|
|
XULTreeGridCellAccessible* cell = GetCellAccessible(column);
|
|
if (cell) nameChanged |= cell->CellInvalidated();
|
|
}
|
|
}
|
|
|
|
if (nameChanged) {
|
|
nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
XULTreeGridCellAccessible::XULTreeGridCellAccessible(
|
|
nsIContent* aContent, DocAccessible* aDoc,
|
|
XULTreeGridRowAccessible* aRowAcc, dom::XULTreeElement* aTree,
|
|
nsITreeView* aTreeView, int32_t aRow, nsTreeColumn* aColumn)
|
|
: LeafAccessible(aContent, aDoc),
|
|
mTree(aTree),
|
|
mTreeView(aTreeView),
|
|
mRow(aRow),
|
|
mColumn(aColumn) {
|
|
mParent = aRowAcc;
|
|
mStateFlags |= eSharedNode;
|
|
mGenericTypes |= eTableCell;
|
|
|
|
NS_ASSERTION(mTreeView, "mTreeView is null");
|
|
|
|
if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
|
|
mTreeView->GetCellValue(mRow, mColumn, mCachedTextEquiv);
|
|
} else {
|
|
mTreeView->GetCellText(mRow, mColumn, mCachedTextEquiv);
|
|
}
|
|
}
|
|
|
|
XULTreeGridCellAccessible::~XULTreeGridCellAccessible() {}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: nsISupports implementation
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeGridCellAccessible, LeafAccessible,
|
|
mTree, mColumn)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeGridCellAccessible)
|
|
NS_INTERFACE_MAP_END_INHERITING(LeafAccessible)
|
|
NS_IMPL_ADDREF_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
|
|
NS_IMPL_RELEASE_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: LocalAccessible
|
|
|
|
void XULTreeGridCellAccessible::Shutdown() {
|
|
mTree = nullptr;
|
|
mTreeView = nullptr;
|
|
mRow = -1;
|
|
mColumn = nullptr;
|
|
mParent = nullptr; // null-out to prevent base class's shutdown ops
|
|
|
|
LeafAccessible::Shutdown();
|
|
}
|
|
|
|
Accessible* XULTreeGridCellAccessible::FocusedChild() { return nullptr; }
|
|
|
|
ENameValueFlag XULTreeGridCellAccessible::Name(nsString& aName) const {
|
|
aName.Truncate();
|
|
|
|
if (!mTreeView) return eNameOK;
|
|
|
|
mTreeView->GetCellText(mRow, mColumn, aName);
|
|
|
|
// If there is still no name try the cell value:
|
|
// This is for graphical cells. We need tree/table view implementors to
|
|
// implement FooView::GetCellValue to return a meaningful string for cases
|
|
// where there is something shown in the cell (non-text) such as a star icon;
|
|
// in which case GetCellValue for that cell would return "starred" or
|
|
// "flagged" for example.
|
|
if (aName.IsEmpty()) mTreeView->GetCellValue(mRow, mColumn, aName);
|
|
|
|
return eNameOK;
|
|
}
|
|
|
|
nsIntRect XULTreeGridCellAccessible::BoundsInCSSPixels() const {
|
|
// Get bounds for tree cell and add x and y of treechildren element to
|
|
// x and y of the cell.
|
|
nsresult rv;
|
|
nsIntRect rect = mTree->GetCoordsForCellItem(mRow, mColumn, u"cell"_ns, rv);
|
|
if (NS_FAILED(rv)) {
|
|
return nsIntRect();
|
|
}
|
|
|
|
RefPtr<dom::Element> bodyElement = mTree->GetTreeBody();
|
|
if (!bodyElement || !bodyElement->IsXULElement()) {
|
|
return nsIntRect();
|
|
}
|
|
|
|
nsIFrame* bodyFrame = bodyElement->GetPrimaryFrame();
|
|
if (!bodyFrame) {
|
|
return nsIntRect();
|
|
}
|
|
|
|
CSSIntRect screenRect = bodyFrame->GetScreenRect();
|
|
rect.x += screenRect.x;
|
|
rect.y += screenRect.y;
|
|
return rect;
|
|
}
|
|
|
|
nsRect XULTreeGridCellAccessible::BoundsInAppUnits() const {
|
|
nsIntRect bounds = BoundsInCSSPixels();
|
|
nsPresContext* presContext = mDoc->PresContext();
|
|
return nsRect(presContext->CSSPixelsToAppUnits(bounds.X()),
|
|
presContext->CSSPixelsToAppUnits(bounds.Y()),
|
|
presContext->CSSPixelsToAppUnits(bounds.Width()),
|
|
presContext->CSSPixelsToAppUnits(bounds.Height()));
|
|
}
|
|
|
|
bool XULTreeGridCellAccessible::HasPrimaryAction() const {
|
|
return mColumn->Cycler() ||
|
|
(mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX &&
|
|
IsEditable());
|
|
}
|
|
|
|
void XULTreeGridCellAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
|
|
aName.Truncate();
|
|
|
|
if (aIndex != eAction_Click || !mTreeView) return;
|
|
|
|
if (mColumn->Cycler()) {
|
|
aName.AssignLiteral("cycle");
|
|
return;
|
|
}
|
|
|
|
if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX &&
|
|
IsEditable()) {
|
|
nsAutoString value;
|
|
mTreeView->GetCellValue(mRow, mColumn, value);
|
|
if (value.EqualsLiteral("true")) {
|
|
aName.AssignLiteral("uncheck");
|
|
} else {
|
|
aName.AssignLiteral("check");
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: TableCell
|
|
|
|
TableAccessible* XULTreeGridCellAccessible::Table() const {
|
|
LocalAccessible* grandParent = mParent->LocalParent();
|
|
if (grandParent) return grandParent->AsTable();
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
uint32_t XULTreeGridCellAccessible::ColIdx() const {
|
|
uint32_t colIdx = 0;
|
|
RefPtr<nsTreeColumn> column = mColumn;
|
|
while ((column = nsCoreUtils::GetPreviousSensibleColumn(column))) colIdx++;
|
|
|
|
return colIdx;
|
|
}
|
|
|
|
uint32_t XULTreeGridCellAccessible::RowIdx() const { return mRow; }
|
|
|
|
void XULTreeGridCellAccessible::ColHeaderCells(
|
|
nsTArray<Accessible*>* aHeaderCells) {
|
|
dom::Element* columnElm = mColumn->Element();
|
|
|
|
LocalAccessible* headerCell = mDoc->GetAccessible(columnElm);
|
|
if (headerCell) aHeaderCells->AppendElement(headerCell);
|
|
}
|
|
|
|
bool XULTreeGridCellAccessible::Selected() {
|
|
nsCOMPtr<nsITreeSelection> selection;
|
|
nsresult rv = mTreeView->GetSelection(getter_AddRefs(selection));
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
|
|
bool selected = false;
|
|
selection->IsSelected(mRow, &selected);
|
|
return selected;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: LocalAccessible public implementation
|
|
|
|
already_AddRefed<AccAttributes> XULTreeGridCellAccessible::NativeAttributes() {
|
|
RefPtr<AccAttributes> attributes = new AccAttributes();
|
|
|
|
// "table-cell-index" attribute
|
|
TableAccessible* table = Table();
|
|
if (!table) return attributes.forget();
|
|
|
|
attributes->SetAttribute(nsGkAtoms::tableCellIndex,
|
|
table->CellIndexAt(mRow, ColIdx()));
|
|
|
|
// "cycles" attribute
|
|
if (mColumn->Cycler()) {
|
|
attributes->SetAttribute(nsGkAtoms::cycles, true);
|
|
}
|
|
|
|
return attributes.forget();
|
|
}
|
|
|
|
role XULTreeGridCellAccessible::NativeRole() const { return roles::GRID_CELL; }
|
|
|
|
uint64_t XULTreeGridCellAccessible::NativeState() const {
|
|
if (!mTreeView) return states::DEFUNCT;
|
|
|
|
// selectable/selected state
|
|
uint64_t states =
|
|
states::SELECTABLE; // keep in sync with NativeInteractiveState
|
|
|
|
nsCOMPtr<nsITreeSelection> selection;
|
|
mTreeView->GetSelection(getter_AddRefs(selection));
|
|
if (selection) {
|
|
bool isSelected = false;
|
|
selection->IsSelected(mRow, &isSelected);
|
|
if (isSelected) states |= states::SELECTED;
|
|
}
|
|
|
|
// checked state
|
|
if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
|
|
states |= states::CHECKABLE;
|
|
nsAutoString checked;
|
|
mTreeView->GetCellValue(mRow, mColumn, checked);
|
|
if (checked.EqualsIgnoreCase("true")) states |= states::CHECKED;
|
|
}
|
|
|
|
return states;
|
|
}
|
|
|
|
uint64_t XULTreeGridCellAccessible::NativeInteractiveState() const {
|
|
return states::SELECTABLE;
|
|
}
|
|
|
|
int32_t XULTreeGridCellAccessible::IndexInParent() const { return ColIdx(); }
|
|
|
|
Relation XULTreeGridCellAccessible::RelationByType(RelationType aType) const {
|
|
return Relation();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: public implementation
|
|
|
|
bool XULTreeGridCellAccessible::CellInvalidated() {
|
|
nsAutoString textEquiv;
|
|
|
|
if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
|
|
mTreeView->GetCellValue(mRow, mColumn, textEquiv);
|
|
if (mCachedTextEquiv != textEquiv) {
|
|
bool isEnabled = textEquiv.EqualsLiteral("true");
|
|
RefPtr<AccEvent> accEvent =
|
|
new AccStateChangeEvent(this, states::CHECKED, isEnabled);
|
|
nsEventShell::FireEvent(accEvent);
|
|
|
|
mCachedTextEquiv = textEquiv;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
mTreeView->GetCellText(mRow, mColumn, textEquiv);
|
|
if (mCachedTextEquiv != textEquiv) {
|
|
nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
|
|
mCachedTextEquiv = textEquiv;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: LocalAccessible protected implementation
|
|
|
|
LocalAccessible* XULTreeGridCellAccessible::GetSiblingAtOffset(
|
|
int32_t aOffset, nsresult* aError) const {
|
|
if (aError) *aError = NS_OK; // fail peacefully
|
|
|
|
RefPtr<nsTreeColumn> columnAtOffset(mColumn), column;
|
|
if (aOffset < 0) {
|
|
for (int32_t index = aOffset; index < 0 && columnAtOffset; index++) {
|
|
column = nsCoreUtils::GetPreviousSensibleColumn(columnAtOffset);
|
|
column.swap(columnAtOffset);
|
|
}
|
|
} else {
|
|
for (int32_t index = aOffset; index > 0 && columnAtOffset; index--) {
|
|
column = nsCoreUtils::GetNextSensibleColumn(columnAtOffset);
|
|
column.swap(columnAtOffset);
|
|
}
|
|
}
|
|
|
|
if (!columnAtOffset) return nullptr;
|
|
|
|
XULTreeItemAccessibleBase* rowAcc =
|
|
static_cast<XULTreeItemAccessibleBase*>(LocalParent());
|
|
return rowAcc->GetCellAccessible(columnAtOffset);
|
|
}
|
|
|
|
void XULTreeGridCellAccessible::DispatchClickEvent(
|
|
nsIContent* aContent, uint32_t aActionIndex) const {
|
|
if (IsDefunct()) return;
|
|
|
|
RefPtr<dom::XULTreeElement> tree = mTree;
|
|
RefPtr<nsTreeColumn> column = mColumn;
|
|
nsCoreUtils::DispatchClickEvent(tree, mRow, column);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// XULTreeGridCellAccessible: protected implementation
|
|
|
|
bool XULTreeGridCellAccessible::IsEditable() const {
|
|
// XXX: logic corresponds to tree.xml, it's preferable to have interface
|
|
// method to check it.
|
|
bool isEditable = false;
|
|
nsresult rv = mTreeView->IsEditable(mRow, mColumn, &isEditable);
|
|
if (NS_FAILED(rv) || !isEditable) return false;
|
|
|
|
dom::Element* columnElm = mColumn->Element();
|
|
|
|
if (!columnElm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::editable,
|
|
nsGkAtoms::_true, eCaseMatters)) {
|
|
return false;
|
|
}
|
|
|
|
return mContent->AsElement()->AttrValueIs(
|
|
kNameSpaceID_None, nsGkAtoms::editable, nsGkAtoms::_true, eCaseMatters);
|
|
}
|