AccessibilityObject* AccessibilityTableCell::titleUIElement() const { // Try to find if the first cell in this row is a <th>. If it is, // then it can act as the title ui element. (This is only in the // case when the table is not appearing as an AXTable.) if (!m_renderer || isTableCell()) return 0; RenderTableCell* renderCell = static_cast<RenderTableCell*>(m_renderer); // If this cell is in the first column, there is no need to continue. int col = renderCell->col(); if (!col) return 0; int row = renderCell->row(); RenderTableSection* section = renderCell->section(); if (!section) return 0; RenderTableCell* headerCell = section->cellAt(row, 0).cell; if (!headerCell || headerCell == renderCell) return 0; Node* cellElement = headerCell->element(); if (!cellElement || !cellElement->hasTagName(thTag)) return 0; return axObjectCache()->get(headerCell); }
/* recalculates the full structure needed to do layouting and minmax calculations. This is usually calculated on the fly, but needs to be done fully when table cells change dynamically */ void AutoTableLayout::recalcColumn( int effCol ) { Layout &l = layoutStruct[effCol]; RenderObject *child = table->firstChild(); // first we iterate over all rows. RenderTableCell *fixedContributor = 0; RenderTableCell *maxContributor = 0; while ( child ) { if ( child->isTableSection() ) { RenderTableSection *section = static_cast<RenderTableSection *>(child); int numRows = section->numRows(); RenderTableCell *last = 0; for ( int i = 0; i < numRows; i++ ) { RenderTableCell *cell = section->cellAt( i, effCol ); if ( cell == (RenderTableCell *)-1 ) continue; if ( cell && cell->colSpan() == 1 ) { // A cell originates in this column. Ensure we have // a min/max width of at least 1px for this column now. l.minWidth = kMax(int( l.minWidth ), 1); l.maxWidth = kMax(int( l.maxWidth ), 1); if ( !cell->minMaxKnown() ) cell->calcMinMaxWidth(); if ( cell->minWidth() > l.minWidth ) l.minWidth = cell->minWidth(); if ( cell->maxWidth() > l.maxWidth ) { l.maxWidth = cell->maxWidth(); maxContributor = cell; } Length w = cell->styleOrColWidth(); w.l.value = kMin( 32767, kMax( 0, w.value() ) ); switch( w.type() ) { case Fixed: // ignore width=0 if ( w.value() > 0 && !l.width.isPercent() ) { int wval = cell->calcBoxWidth(w.value()); if ( l.width.isFixed() ) { // Nav/IE weirdness if ((wval > l.width.value()) || ((l.width.value() == wval) && (maxContributor == cell))) { l.width.l.value = wval; fixedContributor = cell; } } else { l.width = Length( wval, Fixed ); fixedContributor = cell; } } break; case Percent: hasPercent = true; if ( w.value() > 0 && (!l.width.isPercent() || w.value() > l.width.value() ) ) l.width = w; break; case Relative: if ( w.isVariable() || (w.isRelative() && w.value() > l.width.value() ) ) l.width = w; default: break; } } else { if ( cell && (!effCol || section->cellAt( i, effCol-1 ) != cell) ) { // This spanning cell originates in this column. Ensure we have // a min/max width of at least 1px for this column now. l.minWidth = kMax(int( l.minWidth ), 1); l.maxWidth = kMax(int( l.maxWidth ), 1); insertSpanCell( cell ); } last = cell; } } } child = child->nextSibling(); } // Nav/IE weirdness if ( l.width.isFixed() ) { if ( table->style()->htmlHacks() && (l.maxWidth > l.width.value()) && (fixedContributor != maxContributor)) { l.width = Length(); fixedContributor = 0; } } l.maxWidth = kMax(l.maxWidth, int(l.minWidth)); #ifdef DEBUG_LAYOUT qDebug("col %d, final min=%d, max=%d, width=%d(%d)", effCol, l.minWidth, l.maxWidth, l.width.value(), l.width.type() ); #endif // ### we need to add col elements aswell }
bool AccessibilityTable::isTableExposableThroughAccessibility() { // the following is a heuristic used to determine if a // <table> should be exposed as an AXTable. The goal // is to only show "data" tables if (!m_renderer || !m_renderer->isTable()) return false; // if the developer assigned an aria role to this, then we shouldn't // expose it as a table, unless, of course, the aria role is a table AccessibilityRole ariaRole = ariaRoleAttribute(); if (ariaRole == TableRole) return true; if (ariaRole != UnknownRole) return false; RenderTable* table = static_cast<RenderTable*>(m_renderer); // this employs a heuristic to determine if this table should appear. // Only "data" tables should be exposed as tables. // Unfortunately, there is no good way to determine the difference // between a "layout" table and a "data" table Node* tableNode = table->element(); if (!tableNode || !tableNode->hasTagName(tableTag)) return false; // if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table HTMLTableElement* tableElement = static_cast<HTMLTableElement*>(tableNode); if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption()) return true; // if someone used "rules" attribute than the table should appear if (!tableElement->rules().isEmpty()) return true; // go through the cell's and check for tell-tale signs of "data" table status // cells have borders, or use attributes like headers, abbr, scope or axis RenderTableSection* firstBody = table->firstBody(); if (!firstBody) return false; int numCols = firstBody->numColumns(); int numRows = firstBody->numRows(); // if there's only one cell, it's not a good AXTable candidate if (numRows == 1 && numCols == 1) return false; // store the background color of the table to check against cell's background colors RenderStyle* tableStyle = table->style(); if (!tableStyle) return false; Color tableBGColor = tableStyle->backgroundColor(); // check enough of the cells to find if the table matches our criteria // Criteria: // 1) must have at least one valid cell (and) // 2) at least half of cells have borders (or) // 3) at least half of cells have different bg colors than the table, and there is cell spacing unsigned validCellCount = 0; unsigned borderedCellCount = 0; unsigned backgroundDifferenceCellCount = 0; for (int row = 0; row < numRows; ++row) { for (int col = 0; col < numCols; ++col) { RenderTableCell* cell = firstBody->cellAt(row, col).cell; if (!cell) continue; Node* cellNode = cell->element(); if (!cellNode) continue; if (cell->width() < 1 || cell->height() < 1) continue; validCellCount++; HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode); // in this case, the developer explicitly assigned a "data" table attribute if (!cellElement->headers().isEmpty() || !cellElement->abbr().isEmpty() || !cellElement->axis().isEmpty() || !cellElement->scope().isEmpty()) return true; RenderStyle* renderStyle = cell->style(); if (!renderStyle) continue; // a cell needs to have matching bordered sides, before it can be considered a bordered cell. if ((cell->borderTop() > 0 && cell->borderBottom() > 0) || (cell->borderLeft() > 0 && cell->borderRight() > 0)) borderedCellCount++; // if the cell has a different color from the table and there is cell spacing, // then it is probably a data table cell (spacing and colors take the place of borders) Color cellColor = renderStyle->backgroundColor(); if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0 && tableBGColor != cellColor && cellColor.alpha() != 1) backgroundDifferenceCellCount++; // if we've found 10 "good" cells, we don't need to keep searching if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10) return true; } } // if there is less than two valid cells, it's not a data table if (validCellCount <= 1) return false; // half of the cells had borders, it's a data table unsigned neededCellCount = validCellCount / 2; if (borderedCellCount >= neededCellCount) return true; // half had different background colors, it's a data table if (backgroundDifferenceCellCount >= neededCellCount) return true; return false; }
AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column, unsigned row) { if (!m_renderer) return 0; if (!hasChildren()) addChildren(); RenderTable* table = static_cast<RenderTable*>(m_renderer); RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); RenderTableCell* cell = 0; unsigned rowCount = 0; unsigned rowOffset = 0; while (tableSection) { rowCount += tableSection->numRows(); unsigned numCols = tableSection->numColumns(); if (row < rowCount && column < numCols) { int sectionSpecificRow = row - rowOffset; cell = tableSection->cellAt(sectionSpecificRow, column).cell; // we didn't find the cell, which means there's spanning happening // search backwards to find the spanning cell if (!cell) { // first try rows for (int testRow = sectionSpecificRow-1; testRow >= 0; --testRow) { cell = tableSection->cellAt(testRow, column).cell; // cell overlapped. use this one if (cell && ((cell->row() + (cell->rowSpan()-1)) >= (int)sectionSpecificRow)) break; cell = 0; } if (!cell) { // try cols for (int testCol = column-1; testCol >= 0; --testCol) { cell = tableSection->cellAt(sectionSpecificRow, testCol).cell; // cell overlapped. use this one if (cell && ((cell->col() + (cell->colSpan()-1)) >= (int)column)) break; cell = 0; } } } } if (cell) break; rowOffset += rowCount; // we didn't find anything between the rows we should have if (row < rowOffset) break; tableSection = table->sectionBelow(tableSection, true); } if (!cell) return 0; AccessibilityObject* cellObject = axObjectCache()->get(cell); ASSERT(cellObject->isTableCell()); return static_cast<AccessibilityTableCell*>(cellObject); }
void AccessibilityTable::addChildren() { if (!isDataTable()) { AccessibilityRenderObject::addChildren(); return; } ASSERT(!m_haveChildren); m_haveChildren = true; if (!m_renderer) return; RenderTable* table = static_cast<RenderTable*>(m_renderer); AXObjectCache* axCache = m_renderer->document()->axObjectCache(); // go through all the available sections to pull out the rows // and add them as children RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); if (!tableSection) return; RenderTableSection* initialTableSection = tableSection; while (tableSection) { HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); unsigned numCols = tableSection->numColumns(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { for (unsigned colIndex = 0; colIndex < numCols; ++colIndex) { RenderTableCell* cell = tableSection->cellAt(rowIndex, colIndex).cell; if (!cell) continue; AccessibilityObject* rowObject = axCache->get(cell->parent()); if (!rowObject->isTableRow()) continue; AccessibilityTableRow* row = static_cast<AccessibilityTableRow*>(rowObject); // we need to check every cell for a new row, because cell spans // can cause us to mess rows if we just check the first column if (appendedRows.contains(row)) continue; row->setRowIndex((int)m_rows.size()); m_rows.append(row); m_children.append(row); appendedRows.add(row); } } tableSection = table->sectionBelow(tableSection, true); } // make the columns based on the number of columns in the first body unsigned length = initialTableSection->numColumns(); for (unsigned i = 0; i < length; ++i) { AccessibilityTableColumn* column = static_cast<AccessibilityTableColumn*>(axCache->get(ColumnRole)); column->setColumnIndex((int)i); column->setParentTable(this); m_columns.append(column); m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject) m_children.append(headerContainerObject); }