accessible/xul/XULTreeGridAccessible.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 "XULTreeGridAccessible.h"
   7
   8 #include "AccAttributes.h"
   9 #include "LocalAccessible-inl.h"
  10 #include "nsAccCache.h"
  11 #include "nsAccessibilityService.h"
  12 #include "nsAccUtils.h"
  13 #include "DocAccessible.h"
  14 #include "nsEventShell.h"
  15 #include "Relation.h"
  16 #include "Role.h"
  17 #include "States.h"
  18 #include "nsQueryObject.h"
  19 #include "nsTreeColumns.h"
  20
  21 #include "nsITreeSelection.h"
  22 #include "nsComponentManagerUtils.h"
  23 #include "mozilla/PresShell.h"
  24 #include "mozilla/dom/Element.h"
  25 #include "mozilla/dom/TreeColumnBinding.h"
  26 #include "mozilla/dom/XULTreeElementBinding.h"
  27
  28 using namespace mozilla::a11y;
  29 using namespace mozilla;
  30
  31 XULTreeGridAccessible::~XULTreeGridAccessible() {}
  32
  33 ////////////////////////////////////////////////////////////////////////////////
  34 // XULTreeGridAccessible: Table
  35
  36 uint32_t XULTreeGridAccessible::ColCount() const {
  37   return nsCoreUtils::GetSensibleColumnCount(mTree);
  38 }
  39
  40 uint32_t XULTreeGridAccessible::RowCount() {
  41   if (!mTreeView) return 0;
  42
  43   int32_t rowCount = 0;
  44   mTreeView->GetRowCount(&rowCount);
  45   return rowCount >= 0 ? rowCount : 0;
  46 }
  47
  48 uint32_t XULTreeGridAccessible::SelectedCellCount() {
  49   return SelectedRowCount() * ColCount();
  50 }
  51
  52 uint32_t XULTreeGridAccessible::SelectedColCount() {
  53   // If all the row has been selected, then all the columns are selected,
  54   // because we can't select a column alone.
  55
  56   uint32_t selectedRowCount = SelectedItemCount();
  57   return selectedRowCount > 0 && selectedRowCount == RowCount() ? ColCount()
  58                                                                 : 0;
  59 }
  60
  61 uint32_t XULTreeGridAccessible::SelectedRowCount() {
  62   return SelectedItemCount();
  63 }
  64
  65 void XULTreeGridAccessible::SelectedCells(nsTArray<Accessible*>* aCells) {
  66   uint32_t colCount = ColCount(), rowCount = RowCount();
  67
  68   for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
  69     if (IsRowSelected(rowIdx)) {
  70       for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
  71         LocalAccessible* cell = CellAt(rowIdx, colIdx);
  72         aCells->AppendElement(cell);
  73       }
  74     }
  75   }
  76 }
  77
  78 void XULTreeGridAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells) {
  79   uint32_t colCount = ColCount(), rowCount = RowCount();
  80
  81   for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
  82     if (IsRowSelected(rowIdx)) {
  83       for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
  84         aCells->AppendElement(rowIdx * colCount + colIdx);
  85       }
  86     }
  87   }
  88 }
  89
  90 void XULTreeGridAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols) {
  91   if (RowCount() != SelectedRowCount()) return;
  92
  93   uint32_t colCount = ColCount();
  94   aCols->SetCapacity(colCount);
  95   for (uint32_t colIdx = 0; colIdx < colCount; colIdx++) {
  96     aCols->AppendElement(colIdx);
  97   }
  98 }
  99
 100 void XULTreeGridAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows) {
 101   uint32_t rowCount = RowCount();
 102   for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++) {
 103     if (IsRowSelected(rowIdx)) aRows->AppendElement(rowIdx);
 104   }
 105 }
 106
 107 LocalAccessible* XULTreeGridAccessible::CellAt(uint32_t aRowIndex,
 108                                                uint32_t aColumnIndex) {
 109   LocalAccessible* row = GetTreeItemAccessible(aRowIndex);
 110   if (!row) return nullptr;
 111
 112   RefPtr<nsTreeColumn> column =
 113       nsCoreUtils::GetSensibleColumnAt(mTree, aColumnIndex);
 114   if (!column) return nullptr;
 115
 116   RefPtr<XULTreeItemAccessibleBase> rowAcc = do_QueryObject(row);
 117   if (!rowAcc) return nullptr;
 118
 119   return rowAcc->GetCellAccessible(column);
 120 }
 121
 122 void XULTreeGridAccessible::ColDescription(uint32_t aColIdx,
 123                                            nsString& aDescription) {
 124   aDescription.Truncate();
 125
 126   LocalAccessible* treeColumns = LocalAccessible::LocalChildAt(0);
 127   if (treeColumns) {
 128     LocalAccessible* treeColumnItem = treeColumns->LocalChildAt(aColIdx);
 129     if (treeColumnItem) treeColumnItem->Name(aDescription);
 130   }
 131 }
 132
 133 bool XULTreeGridAccessible::IsColSelected(uint32_t aColIdx) {
 134   // If all the row has been selected, then all the columns are selected.
 135   // Because we can't select a column alone.
 136   return SelectedItemCount() == RowCount();
 137 }
 138
 139 bool XULTreeGridAccessible::IsRowSelected(uint32_t aRowIdx) {
 140   if (!mTreeView) return false;
 141
 142   nsCOMPtr<nsITreeSelection> selection;
 143   nsresult rv = mTreeView->GetSelection(getter_AddRefs(selection));
 144   NS_ENSURE_SUCCESS(rv, false);
 145
 146   bool isSelected = false;
 147   selection->IsSelected(aRowIdx, &isSelected);
 148   return isSelected;
 149 }
 150
 151 bool XULTreeGridAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx) {
 152   return IsRowSelected(aRowIdx);
 153 }
 154
 155 void XULTreeGridAccessible::SelectRow(uint32_t aRowIdx) {
 156   if (!mTreeView) return;
 157
 158   nsCOMPtr<nsITreeSelection> selection;
 159   mTreeView->GetSelection(getter_AddRefs(selection));
 160   NS_ASSERTION(selection, "GetSelection() Shouldn't fail!");
 161
 162   selection->Select(aRowIdx);
 163 }
 164
 165 void XULTreeGridAccessible::UnselectRow(uint32_t aRowIdx) {
 166   if (!mTreeView) return;
 167
 168   nsCOMPtr<nsITreeSelection> selection;
 169   mTreeView->GetSelection(getter_AddRefs(selection));
 170
 171   if (selection) selection->ClearRange(aRowIdx, aRowIdx);
 172 }
 173
 174 ////////////////////////////////////////////////////////////////////////////////
 175 // XULTreeGridAccessible: LocalAccessible implementation
 176
 177 role XULTreeGridAccessible::NativeRole() const {
 178   RefPtr<nsTreeColumns> treeColumns = mTree->GetColumns(FlushType::None);
 179   if (!treeColumns) {
 180     NS_ERROR("No treecolumns object for tree!");
 181     return roles::NOTHING;
 182   }
 183
 184   nsTreeColumn* primaryColumn = treeColumns->GetPrimaryColumn();
 185
 186   return primaryColumn ? roles::TREE_TABLE : roles::TABLE;
 187 }
 188
 189 ////////////////////////////////////////////////////////////////////////////////
 190 // XULTreeGridAccessible: XULTreeAccessible implementation
 191
 192 already_AddRefed<LocalAccessible>
 193 XULTreeGridAccessible::CreateTreeItemAccessible(int32_t aRow) const {
 194   RefPtr<LocalAccessible> accessible = new XULTreeGridRowAccessible(
 195       mContent, mDoc, const_cast<XULTreeGridAccessible*>(this), mTree,
 196       mTreeView, aRow);
 197
 198   return accessible.forget();
 199 }
 200
 201 ////////////////////////////////////////////////////////////////////////////////
 202 // XULTreeGridRowAccessible
 203 ////////////////////////////////////////////////////////////////////////////////
 204
 205 XULTreeGridRowAccessible::XULTreeGridRowAccessible(
 206     nsIContent* aContent, DocAccessible* aDoc, LocalAccessible* aTreeAcc,
 207     dom::XULTreeElement* aTree, nsITreeView* aTreeView, int32_t aRow)
 208     : XULTreeItemAccessibleBase(aContent, aDoc, aTreeAcc, aTree, aTreeView,
 209                                 aRow),
 210       mAccessibleCache(kDefaultTreeCacheLength) {
 211   mGenericTypes |= eTableRow;
 212   mStateFlags |= eNoKidsFromDOM;
 213 }
 214
 215 XULTreeGridRowAccessible::~XULTreeGridRowAccessible() {}
 216
 217 ////////////////////////////////////////////////////////////////////////////////
 218 // XULTreeGridRowAccessible: nsISupports and cycle collection implementation
 219
 220 NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeGridRowAccessible,
 221                                    XULTreeItemAccessibleBase, mAccessibleCache)
 222
 223 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeGridRowAccessible)
 224 NS_INTERFACE_MAP_END_INHERITING(XULTreeItemAccessibleBase)
 225
 226 NS_IMPL_ADDREF_INHERITED(XULTreeGridRowAccessible, XULTreeItemAccessibleBase)
 227 NS_IMPL_RELEASE_INHERITED(XULTreeGridRowAccessible, XULTreeItemAccessibleBase)
 228
 229 ////////////////////////////////////////////////////////////////////////////////
 230 // XULTreeGridRowAccessible: LocalAccessible implementation
 231
 232 void XULTreeGridRowAccessible::Shutdown() {
 233   if (mDoc && !mDoc->IsDefunct()) {
 234     UnbindCacheEntriesFromDocument(mAccessibleCache);
 235   }
 236
 237   XULTreeItemAccessibleBase::Shutdown();
 238 }
 239
 240 role XULTreeGridRowAccessible::NativeRole() const { return roles::ROW; }
 241
 242 ENameValueFlag XULTreeGridRowAccessible::Name(nsString& aName) const {
 243   aName.Truncate();
 244
 245   // XXX: the row name sholdn't be a concatenation of cell names (bug 664384).
 246   RefPtr<nsTreeColumn> column = nsCoreUtils::GetFirstSensibleColumn(mTree);
 247   while (column) {
 248     if (!aName.IsEmpty()) aName.Append(' ');
 249
 250     nsAutoString cellName;
 251     GetCellName(column, cellName);
 252     aName.Append(cellName);
 253
 254     column = nsCoreUtils::GetNextSensibleColumn(column);
 255   }
 256
 257   return eNameOK;
 258 }
 259
 260 LocalAccessible* XULTreeGridRowAccessible::LocalChildAtPoint(
 261     int32_t aX, int32_t aY, EWhichChildAtPoint aWhichChild) {
 262   nsIFrame* frame = GetFrame();
 263   if (!frame) return nullptr;
 264
 265   nsPresContext* presContext = frame->PresContext();
 266   PresShell* presShell = presContext->PresShell();
 267
 268   nsIFrame* rootFrame = presShell->GetRootFrame();
 269   NS_ENSURE_TRUE(rootFrame, nullptr);
 270
 271   CSSIntRect rootRect = rootFrame->GetScreenRect();
 272
 273   int32_t clientX = presContext->DevPixelsToIntCSSPixels(aX) - rootRect.X();
 274   int32_t clientY = presContext->DevPixelsToIntCSSPixels(aY) - rootRect.Y();
 275
 276   ErrorResult rv;
 277   dom::TreeCellInfo cellInfo;
 278   mTree->GetCellAt(clientX, clientY, cellInfo, rv);
 279
 280   // Return if we failed to find tree cell in the row for the given point.
 281   if (cellInfo.mRow != mRow || !cellInfo.mCol) return nullptr;
 282
 283   return GetCellAccessible(cellInfo.mCol);
 284 }
 285
 286 LocalAccessible* XULTreeGridRowAccessible::LocalChildAt(uint32_t aIndex) const {
 287   if (IsDefunct()) return nullptr;
 288
 289   RefPtr<nsTreeColumn> column = nsCoreUtils::GetSensibleColumnAt(mTree, aIndex);
 290   if (!column) return nullptr;
 291
 292   return GetCellAccessible(column);
 293 }
 294
 295 uint32_t XULTreeGridRowAccessible::ChildCount() const {
 296   return nsCoreUtils::GetSensibleColumnCount(mTree);
 297 }
 298
 299 ////////////////////////////////////////////////////////////////////////////////
 300 // XULTreeGridRowAccessible: XULTreeItemAccessibleBase implementation
 301
 302 XULTreeGridCellAccessible* XULTreeGridRowAccessible::GetCellAccessible(
 303     nsTreeColumn* aColumn) const {
 304   MOZ_ASSERT(aColumn, "No tree column!");
 305
 306   void* key = static_cast<void*>(aColumn);
 307   XULTreeGridCellAccessible* cachedCell = mAccessibleCache.GetWeak(key);
 308   if (cachedCell) return cachedCell;
 309
 310   RefPtr<XULTreeGridCellAccessible> cell = new XULTreeGridCellAccessible(
 311       mContent, mDoc, const_cast<XULTreeGridRowAccessible*>(this), mTree,
 312       mTreeView, mRow, aColumn);
 313   mAccessibleCache.InsertOrUpdate(key, RefPtr{cell});
 314   Document()->BindToDocument(cell, nullptr);
 315   return cell;
 316 }
 317
 318 void XULTreeGridRowAccessible::RowInvalidated(int32_t aStartColIdx,
 319                                               int32_t aEndColIdx) {
 320   RefPtr<nsTreeColumns> treeColumns = mTree->GetColumns(FlushType::None);
 321   if (!treeColumns) return;
 322
 323   bool nameChanged = false;
 324   for (int32_t colIdx = aStartColIdx; colIdx <= aEndColIdx; ++colIdx) {
 325     nsTreeColumn* column = treeColumns->GetColumnAt(colIdx);
 326     if (column && !nsCoreUtils::IsColumnHidden(column)) {
 327       XULTreeGridCellAccessible* cell = GetCellAccessible(column);
 328       if (cell) nameChanged |= cell->CellInvalidated();
 329     }
 330   }
 331
 332   if (nameChanged) {
 333     nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
 334   }
 335 }
 336
 337 ////////////////////////////////////////////////////////////////////////////////
 338 // XULTreeGridCellAccessible
 339 ////////////////////////////////////////////////////////////////////////////////
 340
 341 XULTreeGridCellAccessible::XULTreeGridCellAccessible(
 342     nsIContent* aContent, DocAccessible* aDoc,
 343     XULTreeGridRowAccessible* aRowAcc, dom::XULTreeElement* aTree,
 344     nsITreeView* aTreeView, int32_t aRow, nsTreeColumn* aColumn)
 345     : LeafAccessible(aContent, aDoc),
 346       mTree(aTree),
 347       mTreeView(aTreeView),
 348       mRow(aRow),
 349       mColumn(aColumn) {
 350   mParent = aRowAcc;
 351   mStateFlags |= eSharedNode;
 352   mGenericTypes |= eTableCell;
 353
 354   NS_ASSERTION(mTreeView, "mTreeView is null");
 355
 356   if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
 357     mTreeView->GetCellValue(mRow, mColumn, mCachedTextEquiv);
 358   } else {
 359     mTreeView->GetCellText(mRow, mColumn, mCachedTextEquiv);
 360   }
 361 }
 362
 363 XULTreeGridCellAccessible::~XULTreeGridCellAccessible() {}
 364
 365 ////////////////////////////////////////////////////////////////////////////////
 366 // XULTreeGridCellAccessible: nsISupports implementation
 367
 368 NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeGridCellAccessible, LeafAccessible,
 369                                    mTree, mColumn)
 370
 371 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeGridCellAccessible)
 372 NS_INTERFACE_MAP_END_INHERITING(LeafAccessible)
 373 NS_IMPL_ADDREF_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
 374 NS_IMPL_RELEASE_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
 375
 376 ////////////////////////////////////////////////////////////////////////////////
 377 // XULTreeGridCellAccessible: LocalAccessible
 378
 379 void XULTreeGridCellAccessible::Shutdown() {
 380   mTree = nullptr;
 381   mTreeView = nullptr;
 382   mRow = -1;
 383   mColumn = nullptr;
 384   mParent = nullptr;  // null-out to prevent base class's shutdown ops
 385
 386   LeafAccessible::Shutdown();
 387 }
 388
 389 Accessible* XULTreeGridCellAccessible::FocusedChild() { return nullptr; }
 390
 391 ENameValueFlag XULTreeGridCellAccessible::Name(nsString& aName) const {
 392   aName.Truncate();
 393
 394   if (!mTreeView) return eNameOK;
 395
 396   mTreeView->GetCellText(mRow, mColumn, aName);
 397
 398   // If there is still no name try the cell value:
 399   // This is for graphical cells. We need tree/table view implementors to
 400   // implement FooView::GetCellValue to return a meaningful string for cases
 401   // where there is something shown in the cell (non-text) such as a star icon;
 402   // in which case GetCellValue for that cell would return "starred" or
 403   // "flagged" for example.
 404   if (aName.IsEmpty()) mTreeView->GetCellValue(mRow, mColumn, aName);
 405
 406   return eNameOK;
 407 }
 408
 409 nsIntRect XULTreeGridCellAccessible::BoundsInCSSPixels() const {
 410   // Get bounds for tree cell and add x and y of treechildren element to
 411   // x and y of the cell.
 412   nsresult rv;
 413   nsIntRect rect = mTree->GetCoordsForCellItem(mRow, mColumn, u"cell"_ns, rv);
 414   if (NS_FAILED(rv)) {
 415     return nsIntRect();
 416   }
 417
 418   RefPtr<dom::Element> bodyElement = mTree->GetTreeBody();
 419   if (!bodyElement || !bodyElement->IsXULElement()) {
 420     return nsIntRect();
 421   }
 422
 423   nsIFrame* bodyFrame = bodyElement->GetPrimaryFrame();
 424   if (!bodyFrame) {
 425     return nsIntRect();
 426   }
 427
 428   CSSIntRect screenRect = bodyFrame->GetScreenRect();
 429   rect.x += screenRect.x;
 430   rect.y += screenRect.y;
 431   return rect;
 432 }
 433
 434 nsRect XULTreeGridCellAccessible::BoundsInAppUnits() const {
 435   nsIntRect bounds = BoundsInCSSPixels();
 436   nsPresContext* presContext = mDoc->PresContext();
 437   return nsRect(presContext->CSSPixelsToAppUnits(bounds.X()),
 438                 presContext->CSSPixelsToAppUnits(bounds.Y()),
 439                 presContext->CSSPixelsToAppUnits(bounds.Width()),
 440                 presContext->CSSPixelsToAppUnits(bounds.Height()));
 441 }
 442
 443 bool XULTreeGridCellAccessible::HasPrimaryAction() const {
 444   return mColumn->Cycler() ||
 445          (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX &&
 446           IsEditable());
 447 }
 448
 449 void XULTreeGridCellAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName) {
 450   aName.Truncate();
 451
 452   if (aIndex != eAction_Click || !mTreeView) return;
 453
 454   if (mColumn->Cycler()) {
 455     aName.AssignLiteral("cycle");
 456     return;
 457   }
 458
 459   if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX &&
 460       IsEditable()) {
 461     nsAutoString value;
 462     mTreeView->GetCellValue(mRow, mColumn, value);
 463     if (value.EqualsLiteral("true")) {
 464       aName.AssignLiteral("uncheck");
 465     } else {
 466       aName.AssignLiteral("check");
 467     }
 468   }
 469 }
 470
 471 ////////////////////////////////////////////////////////////////////////////////
 472 // XULTreeGridCellAccessible: TableCell
 473
 474 TableAccessible* XULTreeGridCellAccessible::Table() const {
 475   LocalAccessible* grandParent = mParent->LocalParent();
 476   if (grandParent) return grandParent->AsTable();
 477
 478   return nullptr;
 479 }
 480
 481 uint32_t XULTreeGridCellAccessible::ColIdx() const {
 482   uint32_t colIdx = 0;
 483   RefPtr<nsTreeColumn> column = mColumn;
 484   while ((column = nsCoreUtils::GetPreviousSensibleColumn(column))) colIdx++;
 485
 486   return colIdx;
 487 }
 488
 489 uint32_t XULTreeGridCellAccessible::RowIdx() const { return mRow; }
 490
 491 void XULTreeGridCellAccessible::ColHeaderCells(
 492     nsTArray<Accessible*>* aHeaderCells) {
 493   dom::Element* columnElm = mColumn->Element();
 494
 495   LocalAccessible* headerCell = mDoc->GetAccessible(columnElm);
 496   if (headerCell) aHeaderCells->AppendElement(headerCell);
 497 }
 498
 499 bool XULTreeGridCellAccessible::Selected() {
 500   nsCOMPtr<nsITreeSelection> selection;
 501   nsresult rv = mTreeView->GetSelection(getter_AddRefs(selection));
 502   NS_ENSURE_SUCCESS(rv, false);
 503
 504   bool selected = false;
 505   selection->IsSelected(mRow, &selected);
 506   return selected;
 507 }
 508
 509 ////////////////////////////////////////////////////////////////////////////////
 510 // XULTreeGridCellAccessible: LocalAccessible public implementation
 511
 512 already_AddRefed<AccAttributes> XULTreeGridCellAccessible::NativeAttributes() {
 513   RefPtr<AccAttributes> attributes = new AccAttributes();
 514
 515   // "table-cell-index" attribute
 516   TableAccessible* table = Table();
 517   if (!table) return attributes.forget();
 518
 519   attributes->SetAttribute(nsGkAtoms::tableCellIndex,
 520                            table->CellIndexAt(mRow, ColIdx()));
 521
 522   // "cycles" attribute
 523   if (mColumn->Cycler()) {
 524     attributes->SetAttribute(nsGkAtoms::cycles, true);
 525   }
 526
 527   return attributes.forget();
 528 }
 529
 530 role XULTreeGridCellAccessible::NativeRole() const { return roles::GRID_CELL; }
 531
 532 uint64_t XULTreeGridCellAccessible::NativeState() const {
 533   if (!mTreeView) return states::DEFUNCT;
 534
 535   // selectable/selected state
 536   uint64_t states =
 537       states::SELECTABLE;  // keep in sync with NativeInteractiveState
 538
 539   nsCOMPtr<nsITreeSelection> selection;
 540   mTreeView->GetSelection(getter_AddRefs(selection));
 541   if (selection) {
 542     bool isSelected = false;
 543     selection->IsSelected(mRow, &isSelected);
 544     if (isSelected) states |= states::SELECTED;
 545   }
 546
 547   // checked state
 548   if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
 549     states |= states::CHECKABLE;
 550     nsAutoString checked;
 551     mTreeView->GetCellValue(mRow, mColumn, checked);
 552     if (checked.EqualsIgnoreCase("true")) states |= states::CHECKED;
 553   }
 554
 555   return states;
 556 }
 557
 558 uint64_t XULTreeGridCellAccessible::NativeInteractiveState() const {
 559   return states::SELECTABLE;
 560 }
 561
 562 int32_t XULTreeGridCellAccessible::IndexInParent() const { return ColIdx(); }
 563
 564 Relation XULTreeGridCellAccessible::RelationByType(RelationType aType) const {
 565   return Relation();
 566 }
 567
 568 ////////////////////////////////////////////////////////////////////////////////
 569 // XULTreeGridCellAccessible: public implementation
 570
 571 bool XULTreeGridCellAccessible::CellInvalidated() {
 572   nsAutoString textEquiv;
 573
 574   if (mColumn->Type() == dom::TreeColumn_Binding::TYPE_CHECKBOX) {
 575     mTreeView->GetCellValue(mRow, mColumn, textEquiv);
 576     if (mCachedTextEquiv != textEquiv) {
 577       bool isEnabled = textEquiv.EqualsLiteral("true");
 578       RefPtr<AccEvent> accEvent =
 579           new AccStateChangeEvent(this, states::CHECKED, isEnabled);
 580       nsEventShell::FireEvent(accEvent);
 581
 582       mCachedTextEquiv = textEquiv;
 583       return true;
 584     }
 585
 586     return false;
 587   }
 588
 589   mTreeView->GetCellText(mRow, mColumn, textEquiv);
 590   if (mCachedTextEquiv != textEquiv) {
 591     nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
 592     mCachedTextEquiv = textEquiv;
 593     return true;
 594   }
 595
 596   return false;
 597 }
 598
 599 ////////////////////////////////////////////////////////////////////////////////
 600 // XULTreeGridCellAccessible: LocalAccessible protected implementation
 601
 602 LocalAccessible* XULTreeGridCellAccessible::GetSiblingAtOffset(
 603     int32_t aOffset, nsresult* aError) const {
 604   if (aError) *aError = NS_OK;  // fail peacefully
 605
 606   RefPtr<nsTreeColumn> columnAtOffset(mColumn), column;
 607   if (aOffset < 0) {
 608     for (int32_t index = aOffset; index < 0 && columnAtOffset; index++) {
 609       column = nsCoreUtils::GetPreviousSensibleColumn(columnAtOffset);
 610       column.swap(columnAtOffset);
 611     }
 612   } else {
 613     for (int32_t index = aOffset; index > 0 && columnAtOffset; index--) {
 614       column = nsCoreUtils::GetNextSensibleColumn(columnAtOffset);
 615       column.swap(columnAtOffset);
 616     }
 617   }
 618
 619   if (!columnAtOffset) return nullptr;
 620
 621   RefPtr<XULTreeItemAccessibleBase> rowAcc = do_QueryObject(LocalParent());
 622   return rowAcc->GetCellAccessible(columnAtOffset);
 623 }
 624
 625 void XULTreeGridCellAccessible::DispatchClickEvent(
 626     nsIContent* aContent, uint32_t aActionIndex) const {
 627   if (IsDefunct()) return;
 628
 629   RefPtr<dom::XULTreeElement> tree = mTree;
 630   RefPtr<nsTreeColumn> column = mColumn;
 631   nsCoreUtils::DispatchClickEvent(tree, mRow, column);
 632 }
 633
 634 ////////////////////////////////////////////////////////////////////////////////
 635 // XULTreeGridCellAccessible: protected implementation
 636
 637 bool XULTreeGridCellAccessible::IsEditable() const {
 638   // XXX: logic corresponds to tree.xml, it's preferable to have interface
 639   // method to check it.
 640   bool isEditable = false;
 641   nsresult rv = mTreeView->IsEditable(mRow, mColumn, &isEditable);
 642   if (NS_FAILED(rv) || !isEditable) return false;
 643
 644   dom::Element* columnElm = mColumn->Element();
 645
 646   if (!columnElm->AttrValueIs(kNameSpaceID_None, nsGkAtoms::editable,
 647                               nsGkAtoms::_true, eCaseMatters)) {
 648     return false;
 649   }
 650
 651   return mContent->AsElement()->AttrValueIs(
 652       kNameSpaceID_None, nsGkAtoms::editable, nsGkAtoms::_true, eCaseMatters);
 653 }