void AXARIAGrid::addChildren()
{
ASSERT(!m_haveChildren);
if (!isAXTable()) {
AXRenderObject::addChildren();
return;
}
m_haveChildren = true;
if (!m_renderer)
return;
AXObjectCache* axCache = m_renderer->document().axObjectCache();
// add only rows that are labeled as aria rows
HashSet<AXObject*> appendedRows;
unsigned columnCount = 0;
for (RefPtr<AXObject> child = firstChild(); child; child = child->nextSibling()) {
if (!addTableCellChild(child.get(), appendedRows, columnCount)) {
// in case the render tree doesn't match the expected ARIA hierarchy, look at the children
if (!child->hasChildren())
child->addChildren();
// The children of this non-row will contain all non-ignored elements (recursing to find them).
// This allows the table to dive arbitrarily deep to find the rows.
AccessibilityChildrenVector children = child->children();
size_t length = children.size();
for (size_t i = 0; i < length; ++i)
addTableCellChild(children[i].get(), appendedRows, columnCount);
}
}
// make the columns based on the number of columns in the first body
for (unsigned i = 0; i < columnCount; ++i) {
AXTableColumn* column = toAXTableColumn(axCache->getOrCreate(ColumnRole));
column->setColumnIndex((int)i);
column->setParent(this);
m_columns.append(column);
if (!column->accessibilityIsIgnored())
m_children.append(column);
}
AXObject* headerContainerObject = headerContainer();
if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored())
m_children.append(headerContainerObject);
}
void AXTable::addChildren()
{
ASSERT(!isDetached());
if (!isAXTable()) {
AXLayoutObject::addChildren();
return;
}
ASSERT(!m_haveChildren);
m_haveChildren = true;
if (!m_layoutObject || !m_layoutObject->isTable())
return;
LayoutTable* table = toLayoutTable(m_layoutObject);
AXObjectCacheImpl& axCache = axObjectCache();
Node* tableNode = table->node();
if (!isHTMLTableElement(tableNode))
return;
// Add caption
if (HTMLTableCaptionElement* caption = toHTMLTableElement(tableNode)->caption()) {
AXObject* captionObject = axCache.getOrCreate(caption);
if (captionObject && !captionObject->accessibilityIsIgnored())
m_children.append(captionObject);
}
// Go through all the available sections to pull out the rows and add them as children.
table->recalcSectionsIfNeeded();
LayoutTableSection* tableSection = table->topSection();
if (!tableSection)
return;
LayoutTableSection* initialTableSection = tableSection;
while (tableSection) {
HeapHashSet<Member<AXObject>> appendedRows;
unsigned numRows = tableSection->numRows();
for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
LayoutTableRow* layoutRow = tableSection->rowLayoutObjectAt(rowIndex);
if (!layoutRow)
continue;
AXObject* rowObject = axCache.getOrCreate(layoutRow);
if (!rowObject || !rowObject->isTableRow())
continue;
AXTableRow* row = toAXTableRow(rowObject);
// We need to check every cell for a new row, because cell spans
// can cause us to miss rows if we just check the first column.
if (appendedRows.contains(row))
continue;
row->setRowIndex(static_cast<int>(m_rows.size()));
m_rows.append(row);
if (!row->accessibilityIsIgnored())
m_children.append(row);
appendedRows.add(row);
}
tableSection = table->sectionBelow(tableSection, SkipEmptySections);
}
// make the columns based on the number of columns in the first body
unsigned length = initialTableSection->numEffectiveColumns();
for (unsigned i = 0; i < length; ++i) {
AXTableColumn* column = toAXTableColumn(axCache.getOrCreate(ColumnRole));
column->setColumnIndex((int)i);
column->setParent(this);
m_columns.append(column);
if (!column->accessibilityIsIgnored())
m_children.append(column);
}
AXObject* headerContainerObject = headerContainer();
if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored())
m_children.append(headerContainerObject);
}
void AXTable::addChildren()
{
if (!isAXTable()) {
AXRenderObject::addChildren();
return;
}
ASSERT(!m_haveChildren);
m_haveChildren = true;
if (!m_renderer || !m_renderer->isTable())
return;
RenderTable* table = toRenderTable(m_renderer);
AXObjectCache* axCache = m_renderer->document().axObjectCache();
// Go through all the available sections to pull out the rows and add them as children.
table->recalcSectionsIfNeeded();
RenderTableSection* tableSection = table->topSection();
if (!tableSection)
return;
RenderTableSection* initialTableSection = tableSection;
while (tableSection) {
HashSet<AXObject*> appendedRows;
unsigned numRows = tableSection->numRows();
for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
RenderTableRow* renderRow = tableSection->rowRendererAt(rowIndex);
if (!renderRow)
continue;
AXObject* rowObject = axCache->getOrCreate(renderRow);
if (!rowObject->isTableRow())
continue;
AXTableRow* row = toAXTableRow(rowObject);
// We need to check every cell for a new row, because cell spans
// can cause us to miss rows if we just check the first column.
if (appendedRows.contains(row))
continue;
row->setRowIndex(static_cast<int>(m_rows.size()));
m_rows.append(row);
if (!row->accessibilityIsIgnored())
m_children.append(row);
appendedRows.add(row);
}
tableSection = table->sectionBelow(tableSection, SkipEmptySections);
}
// make the columns based on the number of columns in the first body
unsigned length = initialTableSection->numColumns();
for (unsigned i = 0; i < length; ++i) {
AXTableColumn* column = toAXTableColumn(axCache->getOrCreate(ColumnRole));
column->setColumnIndex((int)i);
column->setParent(this);
m_columns.append(column);
if (!column->accessibilityIsIgnored())
m_children.append(column);
}
AXObject* headerContainerObject = headerContainer();
if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored())
m_children.append(headerContainerObject);
}
