#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}});
    }
  }
}

References extra_mac_nodes, ui::AXTreeObserver::NODE_CHANGED, and ui::AXTree::observers().

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;
}

References BASE_DCHECK, ui::AXNode::data(), ui::IsTableLike(), ui::AXNode::parent(), ui::AXNodeData::role, ui::AXTree::root(), and Update().

◆ 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;
}

References cell_ids, col_count, base::NumberToString(), padding, and row_count.

Referenced by ui::TEST_F().

◆ 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;
}