gecko-dev/accessible/xul/XULTreeAccessible.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* 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 "XULTreeAccessible.h"

#include "LocalAccessible-inl.h"
#include "DocAccessible-inl.h"
#include "nsAccCache.h"
#include "nsAccUtils.h"
#include "nsCoreUtils.h"
#include "nsEventShell.h"
#include "DocAccessible.h"
#include "Relation.h"
#include "mozilla/a11y/Role.h"
#include "States.h"
#include "XULTreeGridAccessible.h"
#include "nsQueryObject.h"

#include "nsComponentManagerUtils.h"
#include "nsIAutoCompletePopup.h"
#include "nsIDOMXULMenuListElement.h"
#include "nsITreeSelection.h"
#include "nsTreeBodyFrame.h"
#include "nsTreeColumns.h"
#include "nsTreeUtils.h"
#include "mozilla/PresShell.h"
#include "mozilla/dom/XULTreeElementBinding.h"

using namespace mozilla::a11y;

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible
////////////////////////////////////////////////////////////////////////////////

XULTreeAccessible::XULTreeAccessible(nsIContent* aContent, DocAccessible* aDoc,
                                     nsTreeBodyFrame* aTreeFrame)
    : AccessibleWrap(aContent, aDoc),
      mAccessibleCache(kDefaultTreeCacheLength) {
  mType = eXULTreeType;
  mGenericTypes |= eSelect;

  nsCOMPtr<nsITreeView> view = aTreeFrame->GetExistingView();
  mTreeView = view;

  mTree = nsCoreUtils::GetTree(aContent);
  NS_ASSERTION(mTree, "Can't get mTree!\n");

  nsIContent* parentContent = mContent->GetParent();
  if (parentContent) {
    nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
        do_QueryInterface(parentContent);
    if (autoCompletePopupElm) mGenericTypes |= eAutoCompletePopup;
  }
}

XULTreeAccessible::~XULTreeAccessible() {}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: nsISupports and cycle collection implementation

NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeAccessible, LocalAccessible, mTree,
                                   mAccessibleCache)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeAccessible)
NS_INTERFACE_MAP_END_INHERITING(LocalAccessible)

NS_IMPL_ADDREF_INHERITED(XULTreeAccessible, LocalAccessible)
NS_IMPL_RELEASE_INHERITED(XULTreeAccessible, LocalAccessible)

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: LocalAccessible implementation

uint64_t XULTreeAccessible::NativeState() const {
  // Get focus status from base class.
  uint64_t state = LocalAccessible::NativeState();

  // readonly state
  state |= states::READONLY;

  // multiselectable state.
  if (!mTreeView) return state;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  NS_ENSURE_TRUE(selection, state);

  bool isSingle = false;
  nsresult rv = selection->GetSingle(&isSingle);
  NS_ENSURE_SUCCESS(rv, state);

  if (!isSingle) state |= states::MULTISELECTABLE;

  return state;
}

void XULTreeAccessible::Value(nsString& aValue) const {
  aValue.Truncate();
  if (!mTreeView) return;

  // Return the value is the first selected child.
  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (!selection) return;

  int32_t currentIndex;
  selection->GetCurrentIndex(&currentIndex);
  if (currentIndex >= 0) {
    RefPtr<nsTreeColumn> keyCol;

    RefPtr<nsTreeColumns> cols = mTree->GetColumns();
    if (cols) keyCol = cols->GetKeyColumn();

    mTreeView->GetCellText(currentIndex, keyCol, aValue);
  }
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: LocalAccessible implementation

void XULTreeAccessible::Shutdown() {
  if (mDoc && !mDoc->IsDefunct()) {
    UnbindCacheEntriesFromDocument(mAccessibleCache);
  }

  mTree = nullptr;
  mTreeView = nullptr;

  AccessibleWrap::Shutdown();
}

role XULTreeAccessible::NativeRole() const {
  // No primary column means we're in a list. In fact, history and mail turn off
  // the primary flag when switching to a flat view.

  nsIContent* child =
      nsTreeUtils::GetDescendantChild(mContent, nsGkAtoms::treechildren);
  NS_ASSERTION(child, "tree without treechildren!");
  nsTreeBodyFrame* treeFrame = do_QueryFrame(child->GetPrimaryFrame());
  NS_ASSERTION(treeFrame, "xul tree accessible for tree without a frame!");
  if (!treeFrame) return roles::LIST;

  RefPtr<nsTreeColumns> cols = treeFrame->Columns();
  nsTreeColumn* primaryCol = cols->GetPrimaryColumn();

  return primaryCol ? roles::OUTLINE : roles::LIST;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: LocalAccessible implementation (DON'T put methods here)

LocalAccessible* XULTreeAccessible::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);

  // If we failed to find tree cell for the given point then it might be
  // tree columns.
  if (cellInfo.mRow == -1 || !cellInfo.mCol) {
    return AccessibleWrap::LocalChildAtPoint(aX, aY, aWhichChild);
  }

  XULTreeItemAccessibleBase* child = GetTreeItemAccessible(cellInfo.mRow);
  if (aWhichChild == EWhichChildAtPoint::DeepestChild && child) {
    LocalAccessible* cell = child->GetCellAccessible(cellInfo.mCol);
    if (cell) {
      return cell;
    }
  }

  return child;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: SelectAccessible

LocalAccessible* XULTreeAccessible::CurrentItem() const {
  if (!mTreeView) return nullptr;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    int32_t currentIndex = -1;
    selection->GetCurrentIndex(&currentIndex);
    if (currentIndex >= 0) return GetTreeItemAccessible(currentIndex);
  }

  return nullptr;
}

void XULTreeAccessible::SetCurrentItem(const LocalAccessible* aItem) {
  NS_ERROR("XULTreeAccessible::SetCurrentItem not implemented");
}

void XULTreeAccessible::SelectedItems(nsTArray<Accessible*>* aItems) {
  if (!mTreeView) return;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (!selection) return;

  int32_t rangeCount = 0;
  selection->GetRangeCount(&rangeCount);
  for (int32_t rangeIdx = 0; rangeIdx < rangeCount; rangeIdx++) {
    int32_t firstIdx = 0, lastIdx = -1;
    selection->GetRangeAt(rangeIdx, &firstIdx, &lastIdx);
    for (int32_t rowIdx = firstIdx; rowIdx <= lastIdx; rowIdx++) {
      LocalAccessible* item = GetTreeItemAccessible(rowIdx);
      if (item) aItems->AppendElement(item);
    }
  }
}

uint32_t XULTreeAccessible::SelectedItemCount() {
  if (!mTreeView) return 0;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    int32_t count = 0;
    selection->GetCount(&count);
    return count;
  }

  return 0;
}

bool XULTreeAccessible::AddItemToSelection(uint32_t aIndex) {
  if (!mTreeView) return false;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool isSelected = false;
    selection->IsSelected(aIndex, &isSelected);
    if (!isSelected) selection->ToggleSelect(aIndex);

    return true;
  }
  return false;
}

bool XULTreeAccessible::RemoveItemFromSelection(uint32_t aIndex) {
  if (!mTreeView) return false;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool isSelected = false;
    selection->IsSelected(aIndex, &isSelected);
    if (isSelected) selection->ToggleSelect(aIndex);

    return true;
  }
  return false;
}

bool XULTreeAccessible::IsItemSelected(uint32_t aIndex) {
  if (!mTreeView) return false;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool isSelected = false;
    selection->IsSelected(aIndex, &isSelected);
    return isSelected;
  }
  return false;
}

bool XULTreeAccessible::UnselectAll() {
  if (!mTreeView) return false;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (!selection) return false;

  selection->ClearSelection();
  return true;
}

Accessible* XULTreeAccessible::GetSelectedItem(uint32_t aIndex) {
  if (!mTreeView) return nullptr;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (!selection) return nullptr;

  uint32_t selCount = 0;
  int32_t rangeCount = 0;
  selection->GetRangeCount(&rangeCount);
  for (int32_t rangeIdx = 0; rangeIdx < rangeCount; rangeIdx++) {
    int32_t firstIdx = 0, lastIdx = -1;
    selection->GetRangeAt(rangeIdx, &firstIdx, &lastIdx);
    for (int32_t rowIdx = firstIdx; rowIdx <= lastIdx; rowIdx++) {
      if (selCount == aIndex) return GetTreeItemAccessible(rowIdx);

      selCount++;
    }
  }

  return nullptr;
}

bool XULTreeAccessible::SelectAll() {
  // see if we are multiple select if so set ourselves as such
  if (!mTreeView) return false;

  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool single = false;
    selection->GetSingle(&single);
    if (!single) {
      selection->SelectAll();
      return true;
    }
  }

  return false;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: LocalAccessible implementation

LocalAccessible* XULTreeAccessible::LocalChildAt(uint32_t aIndex) const {
  uint32_t childCount = LocalAccessible::ChildCount();
  if (aIndex < childCount) {
    return LocalAccessible::LocalChildAt(aIndex);
  }

  return GetTreeItemAccessible(aIndex - childCount);
}

uint32_t XULTreeAccessible::ChildCount() const {
  // Tree's children count is row count + treecols count.
  uint32_t childCount = LocalAccessible::ChildCount();
  if (!mTreeView) return childCount;

  int32_t rowCount = 0;
  mTreeView->GetRowCount(&rowCount);
  childCount += rowCount;

  return childCount;
}

Relation XULTreeAccessible::RelationByType(RelationType aType) const {
  if (aType == RelationType::NODE_PARENT_OF) {
    if (mTreeView) {
      return Relation(new XULTreeItemIterator(this, mTreeView, -1));
    }

    return Relation();
  }

  return LocalAccessible::RelationByType(aType);
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: Widgets

bool XULTreeAccessible::IsWidget() const { return true; }

bool XULTreeAccessible::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 XULTreeAccessible::AreItemsOperable() const {
  if (IsAutoCompletePopup()) {
    nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
        do_QueryInterface(mContent->GetParent());

    if (autoCompletePopupElm) {
      bool isOpen = false;
      autoCompletePopupElm->GetPopupOpen(&isOpen);
      return isOpen;
    }
  }
  return true;
}

LocalAccessible* XULTreeAccessible::ContainerWidget() const { return nullptr; }

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: public implementation

XULTreeItemAccessibleBase* XULTreeAccessible::GetTreeItemAccessible(
    int32_t aRow) const {
  if (aRow < 0 || IsDefunct() || !mTreeView) return nullptr;

  int32_t rowCount = 0;
  nsresult rv = mTreeView->GetRowCount(&rowCount);
  if (NS_FAILED(rv) || aRow >= rowCount) return nullptr;

  void* key = reinterpret_cast<void*>(intptr_t(aRow));
  return mAccessibleCache.WithEntryHandle(
      key, [&](auto&& entry) -> XULTreeItemAccessibleBase* {
        if (entry) {
          return entry->get();
        }

        RefPtr<XULTreeItemAccessibleBase> treeItem =
            CreateTreeItemAccessible(aRow);
        if (treeItem) {
          entry.Insert(RefPtr{treeItem});
          Document()->BindToDocument(treeItem, nullptr);
          return treeItem.get();
        }

        return nullptr;
      });
}

void XULTreeAccessible::InvalidateCache(int32_t aRow, int32_t aCount) {
  if (IsDefunct()) return;

  if (!mTreeView) {
    UnbindCacheEntriesFromDocument(mAccessibleCache);
    return;
  }

  // Do not invalidate the cache if rows have been inserted.
  if (aCount > 0) return;

  DocAccessible* document = Document();

  // Fire destroy event for removed tree items and delete them from caches.
  for (int32_t rowIdx = aRow; rowIdx < aRow - aCount; rowIdx++) {
    void* key = reinterpret_cast<void*>(intptr_t(rowIdx));
    XULTreeItemAccessibleBase* treeItem = mAccessibleCache.GetWeak(key);

    if (treeItem) {
      RefPtr<AccEvent> event =
          new AccEvent(nsIAccessibleEvent::EVENT_HIDE, treeItem);
      nsEventShell::FireEvent(event);

      // Unbind from document, shutdown and remove from tree cache.
      document->UnbindFromDocument(treeItem);
      mAccessibleCache.Remove(key);
    }
  }

  // We dealt with removed tree items already however we may keep tree items
  // having row indexes greater than row count. We should remove these dead tree
  // items silently from caches.
  int32_t newRowCount = 0;
  nsresult rv = mTreeView->GetRowCount(&newRowCount);
  if (NS_FAILED(rv)) return;

  int32_t oldRowCount = newRowCount - aCount;

  for (int32_t rowIdx = newRowCount; rowIdx < oldRowCount; ++rowIdx) {
    void* key = reinterpret_cast<void*>(intptr_t(rowIdx));
    XULTreeItemAccessibleBase* treeItem = mAccessibleCache.GetWeak(key);

    if (treeItem) {
      // Unbind from document, shutdown and remove from tree cache.
      document->UnbindFromDocument(treeItem);
      mAccessibleCache.Remove(key);
    }
  }
}

void XULTreeAccessible::TreeViewInvalidated(int32_t aStartRow, int32_t aEndRow,
                                            int32_t aStartCol,
                                            int32_t aEndCol) {
  if (IsDefunct()) return;

  if (!mTreeView) {
    UnbindCacheEntriesFromDocument(mAccessibleCache);
    return;
  }

  int32_t endRow = aEndRow;

  nsresult rv;
  if (endRow == -1) {
    int32_t rowCount = 0;
    rv = mTreeView->GetRowCount(&rowCount);
    if (NS_FAILED(rv)) return;

    endRow = rowCount - 1;
  }

  RefPtr<nsTreeColumns> treeColumns = mTree->GetColumns();
  if (!treeColumns) return;

  int32_t endCol = aEndCol;

  if (endCol == -1) {
    // We need to make sure to cast to int32_t before we do the subtraction, in
    // case the column count is 0.
    endCol = static_cast<int32_t>(treeColumns->Count()) - 1;
  }

  for (int32_t rowIdx = aStartRow; rowIdx <= endRow; ++rowIdx) {
    void* key = reinterpret_cast<void*>(intptr_t(rowIdx));
    XULTreeItemAccessibleBase* treeitemAcc = mAccessibleCache.GetWeak(key);

    if (treeitemAcc) {
      treeitemAcc->RowInvalidated(aStartCol, endCol);
    }
  }
}

void XULTreeAccessible::TreeViewChanged(nsITreeView* aView) {
  if (IsDefunct()) return;

  // Fire reorder event on tree accessible on accessible tree (do not fire
  // show/hide events on tree items because it can be expensive to fire them for
  // each tree item.
  RefPtr<AccReorderEvent> reorderEvent = new AccReorderEvent(this);
  Document()->FireDelayedEvent(reorderEvent);

  // Clear cache.
  UnbindCacheEntriesFromDocument(mAccessibleCache);

  mTreeView = aView;
  LocalAccessible* item = CurrentItem();
  if (item) {
    FocusMgr()->ActiveItemChanged(item, true);
  }
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeAccessible: protected implementation

already_AddRefed<XULTreeItemAccessibleBase>
XULTreeAccessible::CreateTreeItemAccessible(int32_t aRow) const {
  RefPtr<XULTreeItemAccessibleBase> accessible = new XULTreeItemAccessible(
      mContent, mDoc, const_cast<XULTreeAccessible*>(this), mTree, mTreeView,
      aRow);

  return accessible.forget();
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase
////////////////////////////////////////////////////////////////////////////////

XULTreeItemAccessibleBase::XULTreeItemAccessibleBase(
    nsIContent* aContent, DocAccessible* aDoc, LocalAccessible* aParent,
    dom::XULTreeElement* aTree, nsITreeView* aTreeView, int32_t aRow)
    : AccessibleWrap(aContent, aDoc),
      mTree(aTree),
      mTreeView(aTreeView),
      mRow(aRow) {
  mParent = aParent;
  mStateFlags |= eSharedNode;
}

XULTreeItemAccessibleBase::~XULTreeItemAccessibleBase() {}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: nsISupports implementation

NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeItemAccessibleBase, LocalAccessible,
                                   mTree)

NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(XULTreeItemAccessibleBase,
                                               LocalAccessible)

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: LocalAccessible

Accessible* XULTreeItemAccessibleBase::FocusedChild() {
  return FocusMgr()->FocusedLocalAccessible() == this ? this : nullptr;
}

nsIntRect XULTreeItemAccessibleBase::BoundsInCSSPixels() const {
  // Get x coordinate and width from treechildren element, get y coordinate and
  // height from tree cell.

  RefPtr<nsTreeColumn> column = nsCoreUtils::GetFirstSensibleColumn(mTree);

  nsresult rv;
  nsIntRect rect = mTree->GetCoordsForCellItem(mRow, column, u"cell"_ns, rv);
  if (NS_FAILED(rv)) {
    return nsIntRect();
  }

  RefPtr<dom::Element> bodyElement = mTree->GetTreeBody();
  if (!bodyElement || !bodyElement->IsXULElement()) {
    return nsIntRect();
  }

  rect.width = bodyElement->ClientWidth();

  nsIFrame* bodyFrame = bodyElement->GetPrimaryFrame();
  if (!bodyFrame) {
    return nsIntRect();
  }

  CSSIntRect screenRect = bodyFrame->GetScreenRect();
  rect.x = screenRect.x;
  rect.y += screenRect.y;
  return rect;
}

nsRect XULTreeItemAccessibleBase::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()));
}

void XULTreeItemAccessibleBase::SetSelected(bool aSelect) {
  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool isSelected = false;
    selection->IsSelected(mRow, &isSelected);
    if (isSelected != aSelect) selection->ToggleSelect(mRow);
  }
}

void XULTreeItemAccessibleBase::TakeFocus() const {
  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) selection->SetCurrentIndex(mRow);

  // focus event will be fired here
  LocalAccessible::TakeFocus();
}

Relation XULTreeItemAccessibleBase::RelationByType(RelationType aType) const {
  switch (aType) {
    case RelationType::NODE_CHILD_OF: {
      int32_t parentIndex = -1;
      if (!NS_SUCCEEDED(mTreeView->GetParentIndex(mRow, &parentIndex))) {
        return Relation();
      }

      if (parentIndex == -1) return Relation(mParent);

      XULTreeAccessible* treeAcc = mParent->AsXULTree();
      return Relation(treeAcc->GetTreeItemAccessible(parentIndex));
    }

    case RelationType::NODE_PARENT_OF: {
      bool isTrue = false;
      if (NS_FAILED(mTreeView->IsContainerEmpty(mRow, &isTrue)) || isTrue) {
        return Relation();
      }

      if (NS_FAILED(mTreeView->IsContainerOpen(mRow, &isTrue)) || !isTrue) {
        return Relation();
      }

      XULTreeAccessible* tree = mParent->AsXULTree();
      return Relation(new XULTreeItemIterator(tree, mTreeView, mRow));
    }

    default:
      return Relation();
  }
}

bool XULTreeItemAccessibleBase::HasPrimaryAction() const { return true; }

uint8_t XULTreeItemAccessibleBase::ActionCount() const {
  // "activate" action is available for all treeitems, "expand/collapse" action
  // is avaible for treeitem which is container.
  return IsExpandable() ? 2 : 1;
}

void XULTreeItemAccessibleBase::ActionNameAt(uint8_t aIndex, nsAString& aName) {
  if (aIndex == eAction_Click) {
    aName.AssignLiteral("activate");
    return;
  }

  if (aIndex == eAction_Expand && IsExpandable()) {
    bool isContainerOpen = false;
    mTreeView->IsContainerOpen(mRow, &isContainerOpen);
    if (isContainerOpen) {
      aName.AssignLiteral("collapse");
    } else {
      aName.AssignLiteral("expand");
    }
  }
}

bool XULTreeItemAccessibleBase::DoAction(uint8_t aIndex) const {
  if (aIndex != eAction_Click &&
      (aIndex != eAction_Expand || !IsExpandable())) {
    return false;
  }

  DoCommand(nullptr, aIndex);
  return true;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: LocalAccessible implementation

void XULTreeItemAccessibleBase::Shutdown() {
  mTree = nullptr;
  mTreeView = nullptr;
  mRow = -1;
  mParent = nullptr;  // null-out to prevent base class's shutdown ops

  AccessibleWrap::Shutdown();
}

GroupPos XULTreeItemAccessibleBase::GroupPosition() {
  GroupPos groupPos;

  int32_t level;
  nsresult rv = mTreeView->GetLevel(mRow, &level);
  NS_ENSURE_SUCCESS(rv, groupPos);

  int32_t topCount = 1;
  for (int32_t index = mRow - 1; index >= 0; index--) {
    int32_t lvl = -1;
    if (NS_SUCCEEDED(mTreeView->GetLevel(index, &lvl))) {
      if (lvl < level) break;

      if (lvl == level) topCount++;
    }
  }

  int32_t rowCount = 0;
  rv = mTreeView->GetRowCount(&rowCount);
  NS_ENSURE_SUCCESS(rv, groupPos);

  int32_t bottomCount = 0;
  for (int32_t index = mRow + 1; index < rowCount; index++) {
    int32_t lvl = -1;
    if (NS_SUCCEEDED(mTreeView->GetLevel(index, &lvl))) {
      if (lvl < level) break;

      if (lvl == level) bottomCount++;
    }
  }

  groupPos.level = level + 1;
  groupPos.setSize = topCount + bottomCount;
  groupPos.posInSet = topCount;

  return groupPos;
}

uint64_t XULTreeItemAccessibleBase::NativeState() const {
  // focusable and selectable states
  uint64_t state = NativeInteractiveState();

  // expanded/collapsed state
  if (IsExpandable()) {
    bool isContainerOpen;
    mTreeView->IsContainerOpen(mRow, &isContainerOpen);
    state |= isContainerOpen ? states::EXPANDED : states::COLLAPSED;
  }

  // selected state
  nsCOMPtr<nsITreeSelection> selection;
  mTreeView->GetSelection(getter_AddRefs(selection));
  if (selection) {
    bool isSelected;
    selection->IsSelected(mRow, &isSelected);
    if (isSelected) state |= states::SELECTED;
  }

  // focused state
  if (FocusMgr()->IsFocused(this)) state |= states::FOCUSED;

  // invisible state
  int32_t firstVisibleRow = mTree->GetFirstVisibleRow();
  int32_t lastVisibleRow = mTree->GetLastVisibleRow();
  if (mRow < firstVisibleRow || mRow > lastVisibleRow) {
    state |= states::INVISIBLE;
  }

  return state;
}

uint64_t XULTreeItemAccessibleBase::NativeInteractiveState() const {
  return states::FOCUSABLE | states::SELECTABLE;
}

int32_t XULTreeItemAccessibleBase::IndexInParent() const {
  return mParent ? mParent->ContentChildCount() + mRow : -1;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: Widgets

LocalAccessible* XULTreeItemAccessibleBase::ContainerWidget() const {
  return mParent;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: LocalAccessible protected methods

void XULTreeItemAccessibleBase::DispatchClickEvent(
    nsIContent* aContent, uint32_t aActionIndex) const {
  if (IsDefunct()) return;

  RefPtr<nsTreeColumns> columns = mTree->GetColumns();
  if (!columns) return;

  // Get column and pseudo element.
  RefPtr<nsTreeColumn> column;
  nsAutoString pseudoElm;

  if (aActionIndex == eAction_Click) {
    // Key column is visible and clickable.
    column = columns->GetKeyColumn();
  } else {
    // Primary column contains a twisty we should click on.
    column = columns->GetPrimaryColumn();
    pseudoElm = u"twisty"_ns;
  }

  if (column) {
    RefPtr<dom::XULTreeElement> tree = mTree;
    nsCoreUtils::DispatchClickEvent(tree, mRow, column, pseudoElm);
  }
}

LocalAccessible* XULTreeItemAccessibleBase::GetSiblingAtOffset(
    int32_t aOffset, nsresult* aError) const {
  if (aError) *aError = NS_OK;  // fail peacefully

  return mParent->LocalChildAt(IndexInParent() + aOffset);
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessibleBase: protected implementation

bool XULTreeItemAccessibleBase::IsExpandable() const {
  bool isContainer = false;
  mTreeView->IsContainer(mRow, &isContainer);
  if (isContainer) {
    bool isEmpty = false;
    mTreeView->IsContainerEmpty(mRow, &isEmpty);
    if (!isEmpty) {
      RefPtr<nsTreeColumns> columns = mTree->GetColumns();
      if (columns) {
        nsTreeColumn* primaryColumn = columns->GetPrimaryColumn();
        if (primaryColumn && !nsCoreUtils::IsColumnHidden(primaryColumn)) {
          return true;
        }
      }
    }
  }

  return false;
}

void XULTreeItemAccessibleBase::GetCellName(nsTreeColumn* aColumn,
                                            nsAString& aName) const {
  mTreeView->GetCellText(mRow, aColumn, 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, aColumn, aName);
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessible
////////////////////////////////////////////////////////////////////////////////

XULTreeItemAccessible::XULTreeItemAccessible(
    nsIContent* aContent, DocAccessible* aDoc, LocalAccessible* aParent,
    dom::XULTreeElement* aTree, nsITreeView* aTreeView, int32_t aRow)
    : XULTreeItemAccessibleBase(aContent, aDoc, aParent, aTree, aTreeView,
                                aRow) {
  mStateFlags |= eNoKidsFromDOM;
  mColumn = nsCoreUtils::GetFirstSensibleColumn(mTree, FlushType::None);
  GetCellName(mColumn, mCachedName);
}

XULTreeItemAccessible::~XULTreeItemAccessible() {}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessible: nsISupports implementation

NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeItemAccessible,
                                   XULTreeItemAccessibleBase, mColumn)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(XULTreeItemAccessible)
NS_INTERFACE_MAP_END_INHERITING(XULTreeItemAccessibleBase)
NS_IMPL_ADDREF_INHERITED(XULTreeItemAccessible, XULTreeItemAccessibleBase)
NS_IMPL_RELEASE_INHERITED(XULTreeItemAccessible, XULTreeItemAccessibleBase)

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessible: nsIAccessible implementation

ENameValueFlag XULTreeItemAccessible::Name(nsString& aName) const {
  aName.Truncate();

  GetCellName(mColumn, aName);
  return eNameOK;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessible: LocalAccessible implementation

void XULTreeItemAccessible::Shutdown() {
  mColumn = nullptr;
  XULTreeItemAccessibleBase::Shutdown();
}

role XULTreeItemAccessible::NativeRole() const {
  RefPtr<nsTreeColumns> columns = mTree->GetColumns();
  if (!columns) {
    NS_ERROR("No tree columns object in the tree!");
    return roles::NOTHING;
  }

  nsTreeColumn* primaryColumn = columns->GetPrimaryColumn();

  return primaryColumn ? roles::OUTLINEITEM : roles::LISTITEM;
}

////////////////////////////////////////////////////////////////////////////////
// XULTreeItemAccessible: XULTreeItemAccessibleBase implementation

void XULTreeItemAccessible::RowInvalidated(int32_t aStartColIdx,
                                           int32_t aEndColIdx) {
  nsAutoString name;
  Name(name);

  if (name != mCachedName) {
    nsEventShell::FireEvent(nsIAccessibleEvent::EVENT_NAME_CHANGE, this);
    mCachedName = name;
  }
}

////////////////////////////////////////////////////////////////////////////////
//  XULTreeColumAccessible
////////////////////////////////////////////////////////////////////////////////

XULTreeColumAccessible::XULTreeColumAccessible(nsIContent* aContent,
                                               DocAccessible* aDoc)
    : XULColumAccessible(aContent, aDoc) {}

LocalAccessible* XULTreeColumAccessible::GetSiblingAtOffset(
    int32_t aOffset, nsresult* aError) const {
  if (aOffset < 0) {
    return XULColumAccessible::GetSiblingAtOffset(aOffset, aError);
  }

  if (aError) *aError = NS_OK;  // fail peacefully

  RefPtr<dom::XULTreeElement> tree = nsCoreUtils::GetTree(mContent);
  if (tree) {
    nsCOMPtr<nsITreeView> treeView = tree->GetView(FlushType::None);
    if (treeView) {
      int32_t rowCount = 0;
      treeView->GetRowCount(&rowCount);
      if (rowCount > 0 && aOffset <= rowCount) {
        XULTreeAccessible* treeAcc = LocalParent()->AsXULTree();

        if (treeAcc) return treeAcc->GetTreeItemAccessible(aOffset - 1);
      }
    }
  }

  return nullptr;
}