ui::AXTableInfo Class Reference

#include <ax_table_info.h>

Classes
struct	CellData

Public Member Functions
	~AXTableInfo ()
bool	Update ()
bool	valid () const
void	Invalidate ()
std::string	ToString () const

Static Public Member Functions
static AXTableInfo *	Create (AXTree *tree, AXNode *table_node)

Public Attributes
size_t	row_count = 0
size_t	col_count = 0
std::vector< std::vector< int32_t > >	col_headers
std::vector< std::vector< int32_t > >	row_headers
std::vector< int32_t >	all_headers
int32_t	caption_id
std::vector< std::vector< int32_t > >	cell_ids
std::vector< CellData >	cell_data_vector
std::vector< int32_t >	unique_cell_ids
std::vector< AXNode * >	extra_mac_nodes
std::unordered_map< int32_t, size_t >	cell_id_to_index
std::unordered_map< int32_t, size_t >	row_id_to_index
std::vector< AXNode * >	row_nodes
int	aria_row_count = 0
int	aria_col_count = 0

Detailed Description

Definition at line 22 of file ax_table_info.h.

Constructor & Destructor Documentation

~AXTableInfo()

ui::AXTableInfo::~AXTableInfo

(

)

Definition at line 547 of file ax_table_info.cc.

                          {
  if (!extra_mac_nodes.empty()) {
    ClearExtraMacNodes();
    for (AXTreeObserver* observer : tree_->observers()) {
      observer->OnAtomicUpdateFinished(
          tree_, false,
          {{table_node_, AXTreeObserver::ChangeType::NODE_CHANGED}});
    }
  }
}

Member Function Documentation

Create()

AXTableInfo * ui::AXTableInfo::Create ( AXTree *  tree, AXNode *  table_node  )

static

Definition at line 75 of file ax_table_info.cc.

                                                                 {
  BASE_DCHECK(tree);
  BASE_DCHECK(table_node);
 
#ifndef NDEBUG
  // Sanity check, make sure the node is in the tree.
  AXNode* node = table_node;
  while (node && node != tree->root())
    node = node->parent();
  BASE_DCHECK(node == tree->root());
#endif
 
  if (!IsTableLike(table_node->data().role))
    return nullptr;
 
  AXTableInfo* info = new AXTableInfo(tree, table_node);
  bool success = info->Update();
  BASE_DCHECK(success);
 
  return info;
}

Invalidate()

void ui::AXTableInfo::Invalidate

(

)

Definition at line 146 of file ax_table_info.cc.

                             {
  valid_ = false;
}

ToString()

std::string ui::AXTableInfo::ToString

(

)

const

Definition at line 518 of file ax_table_info.cc.

                                      {
  // First, scan through to get the length of the largest id.
  int padding = 0;
  for (size_t r = 0; r < row_count; r++) {
    for (size_t c = 0; c < col_count; c++) {
      // Extract the length of the id for padding purposes.
      padding = std::max(padding, static_cast<int>(log10(cell_ids[r][c])));
    }
  }
 
  std::string result;
  for (size_t r = 0; r < row_count; r++) {
    result += "|";
    for (size_t c = 0; c < col_count; c++) {
      int cell_id = cell_ids[r][c];
      result += base::NumberToString(cell_id);
      int cell_padding = padding;
      if (cell_id != 0)
        cell_padding = padding - static_cast<int>(log10(cell_id));
      result += std::string(cell_padding, ' ') + '|';
    }
    result += "\n";
  }
  return result;
}

Update()

bool ui::AXTableInfo::Update

(

)

Definition at line 97 of file ax_table_info.cc.

                         {
  if (!table_node_->IsTable())
    return false;
 
  ClearVectors();
 
  std::vector<std::vector<AXNode*>> cell_nodes_per_row;
  caption_id = 0;
  FindRowsAndThenCells(table_node_, &row_nodes, &cell_nodes_per_row,
                       caption_id);
  BASE_DCHECK(cell_nodes_per_row.size() == row_nodes.size());
 
  // Get the optional row and column count from the table. If we encounter
  // a cell with an index or span larger than this, we'll update the
  // table row and column count to be large enough to fit all cells.
  row_count = GetSizeTAttribute(*table_node_, IntAttribute::kTableRowCount);
  col_count = GetSizeTAttribute(*table_node_, IntAttribute::kTableColumnCount);
 
  // Note - GetIntAttribute returns 0 if no value has been specified for the
  // attribute.
  aria_row_count = static_cast<int>(
      table_node_->GetIntAttribute(IntAttribute::kAriaRowCount));
  aria_col_count = static_cast<int>(
      table_node_->GetIntAttribute(IntAttribute::kAriaColumnCount));
 
  // Iterate over the cells and build up an array of CellData
  // entries, one for each cell. Compute the actual row and column
  BuildCellDataVectorFromRowAndCellNodes(row_nodes, cell_nodes_per_row);
 
  // At this point we have computed valid row and column indices for
  // every cell in the table, and an accurate row and column count for the
  // whole table that fits every cell and its spans. The final step is to
  // fill in a 2-dimensional array that lets us look up an individual cell
  // by its (row, column) coordinates, plus arrays to hold row and column
  // headers.
  BuildCellAndHeaderVectorsFromCellData();
 
  // On Mac, we add a few extra nodes to the table - see comment
  // at the top of UpdateExtraMacNodes for details.
  if (tree_->enable_extra_mac_nodes())
    UpdateExtraMacNodes();
 
  // The table metadata is now valid, any table queries will now be
  // fast. Any time a node in the table is updated, we'll have to
  // recompute all of this.
  valid_ = true;
  return true;
}

valid()

bool ui::AXTableInfo::valid ( ) const

inline

Definition at line 47 of file ax_table_info.h.

{ return valid_; }

Member Data Documentation

all_headers

std::vector<int32_t> ui::AXTableInfo::all_headers

Definition at line 65 of file ax_table_info.h.

aria_col_count

int ui::AXTableInfo::aria_col_count = 0

Definition at line 99 of file ax_table_info.h.

aria_row_count

int ui::AXTableInfo::aria_row_count = 0

Definition at line 98 of file ax_table_info.h.

caption_id

int32_t ui::AXTableInfo::caption_id

Definition at line 68 of file ax_table_info.h.

cell_data_vector

std::vector<CellData> ui::AXTableInfo::cell_data_vector

Definition at line 77 of file ax_table_info.h.

cell_id_to_index

std::unordered_map<int32_t, size_t> ui::AXTableInfo::cell_id_to_index

Definition at line 88 of file ax_table_info.h.

cell_ids

std::vector<std::vector<int32_t> > ui::AXTableInfo::cell_ids

Definition at line 74 of file ax_table_info.h.

col_count

size_t ui::AXTableInfo::col_count = 0

Definition at line 56 of file ax_table_info.h.

col_headers

std::vector<std::vector<int32_t> > ui::AXTableInfo::col_headers

Definition at line 59 of file ax_table_info.h.

extra_mac_nodes

std::vector<AXNode*> ui::AXTableInfo::extra_mac_nodes

Definition at line 85 of file ax_table_info.h.

row_count

size_t ui::AXTableInfo::row_count = 0

Definition at line 52 of file ax_table_info.h.

row_headers

std::vector<std::vector<int32_t> > ui::AXTableInfo::row_headers

Definition at line 62 of file ax_table_info.h.

row_id_to_index

std::unordered_map<int32_t, size_t> ui::AXTableInfo::row_id_to_index

Definition at line 91 of file ax_table_info.h.

row_nodes

std::vector<AXNode*> ui::AXTableInfo::row_nodes

Definition at line 94 of file ax_table_info.h.

unique_cell_ids

std::vector<int32_t> ui::AXTableInfo::unique_cell_ids

Definition at line 80 of file ax_table_info.h.

---

The documentation for this class was generated from the following files:

• third_party/accessibility/ax/ax_table_info.h
• third_party/accessibility/ax/ax_table_info.cc