void AccessibilityTableCell::rowIndexRange(std::pair<unsigned, unsigned>& rowRange) { if (!m_renderer || !m_renderer->isTableCell()) return; RenderTableCell* renderCell = toRenderTableCell(m_renderer); rowRange.first = renderCell->rowIndex(); rowRange.second = renderCell->rowSpan(); // since our table might have multiple sections, we have to offset our row appropriately RenderTableSection* section = renderCell->section(); RenderTable* table = renderCell->table(); if (!table || !section) return; RenderTableSection* footerSection = table->footer(); unsigned rowOffset = 0; for (RenderTableSection* tableSection = table->topSection(); tableSection; tableSection = table->sectionBelow(tableSection, SkipEmptySections)) { // Don't add row offsets for bottom sections that are placed in before the body section. if (tableSection == footerSection) continue; if (tableSection == section) break; rowOffset += tableSection->numRows(); } rowRange.first += rowOffset; }
void AccessibilityTableCell::rowIndexRange(pair<int, int>& rowRange) { if (!m_renderer) return; RenderTableCell* renderCell = static_cast<RenderTableCell*>(m_renderer); rowRange.first = renderCell->row(); rowRange.second = renderCell->rowSpan(); // since our table might have multiple sections, we have to offset our row appropriately RenderTableSection* section = renderCell->section(); RenderTable* table = renderCell->table(); if (!table || !section) return; RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); unsigned rowOffset = 0; while (tableSection) { if (tableSection == section) break; rowOffset += tableSection->numRows(); tableSection = table->sectionBelow(tableSection, true); } rowRange.first += rowOffset; }
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); }
void AccessibilityTableCell::rowIndexRange(pair<int, int>& rowRange) { if (!m_renderer || !m_renderer->isTableCell()) return; RenderTableCell* renderCell = toRenderTableCell(m_renderer); rowRange.first = renderCell->rowIndex(); rowRange.second = renderCell->rowSpan(); // since our table might have multiple sections, we have to offset our row appropriately RenderTableSection* section = renderCell->section(); RenderTable* table = renderCell->table(); if (!table || !section) return; // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection. RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); unsigned rowOffset = 0; while (tableSection) { if (tableSection == section) break; rowOffset += tableSection->numRows(); tableSection = table->sectionBelow(tableSection, SkipEmptySections); } rowRange.first += rowOffset; }
void AccessibilityTableCell::rowIndexRange(std::pair<unsigned, unsigned>& rowRange) { if (!m_renderer || !m_renderer->isTableCell()) return; RenderTableCell* renderCell = toRenderTableCell(m_renderer); rowRange.first = renderCell->rowIndex(); rowRange.second = renderCell->rowSpan(); // since our table might have multiple sections, we have to offset our row appropriately RenderTableSection* section = renderCell->section(); RenderTable* table = renderCell->table(); if (!table || !section) return; RenderTableSection* tableSection = table->topSection(); unsigned rowOffset = 0; while (tableSection) { if (tableSection == section) break; rowOffset += tableSection->numRows(); tableSection = table->sectionBelow(tableSection, SkipEmptySections); } rowRange.first += rowOffset; }
void RenderTableRow::destroy() { RenderTableSection *s = section(); if (s) s->setNeedCellRecalc(); RenderContainer::destroy(); }
void RenderTableCell::willBeDestroyed() { RenderTableSection* recalcSection = parent() ? section() : 0; RenderBlock::willBeDestroyed(); if (recalcSection) recalcSection->setNeedsCellRecalc(); }
void RenderTableRow::willBeDestroyed() { RenderTableSection* recalcSection = section(); RenderBox::willBeDestroyed(); if (recalcSection) recalcSection->setNeedsCellRecalc(); }
void RenderTableRow::destroy() { RenderTableSection* recalcSection = section(); RenderContainer::destroy(); if (recalcSection) recalcSection->setNeedsCellRecalc(); }
HTMLTableElement* AccessibilityTable::tableElement() const { if (!m_renderer->isTable()) return nullptr; RenderTable* table = toRenderTable(m_renderer); if (table->element() && isHTMLTableElement(table->element())) return toHTMLTableElement(table->element()); // If the table has a display:table-row-group, then the RenderTable does not have a pointer to it's HTMLTableElement. // We can instead find it by asking the firstSection for its parent. RenderTableSection* firstBody = table->firstBody(); if (!firstBody || !firstBody->element()) return nullptr; Element* actualTable = firstBody->element()->parentElement(); if (!actualTable || !isHTMLTableElement(actualTable)) return nullptr; return toHTMLTableElement(actualTable); }
HTMLTableElement* AccessibilityTable::tableElement() const { if (!is<RenderTable>(*m_renderer)) return nullptr; RenderTable& table = downcast<RenderTable>(*m_renderer); if (is<HTMLTableElement>(table.element())) return downcast<HTMLTableElement>(table.element()); // If the table has a display:table-row-group, then the RenderTable does not have a pointer to it's HTMLTableElement. // We can instead find it by asking the firstSection for its parent. RenderTableSection* firstBody = table.firstBody(); if (!firstBody || !firstBody->element()) return nullptr; Element* actualTable = firstBody->element()->parentElement(); if (!is<HTMLTableElement>(actualTable)) return nullptr; return downcast<HTMLTableElement>(actualTable); }
AccessibilityObject* AccessibilityTableColumn::headerObject() { if (!m_parent) return nullptr; RenderObject* renderer = m_parent->renderer(); if (!renderer) return nullptr; if (!is<AccessibilityTable>(*m_parent)) return nullptr; auto& parentTable = downcast<AccessibilityTable>(*m_parent); if (!parentTable.isExposableThroughAccessibility()) return nullptr; if (parentTable.isAriaTable()) { for (const auto& cell : children()) { if (cell->ariaRoleAttribute() == ColumnHeaderRole) return cell.get(); } return nullptr; } if (!is<RenderTable>(*renderer)) return nullptr; RenderTable& table = downcast<RenderTable>(*renderer); // try the <thead> section first. this doesn't require th tags if (auto* headerObject = headerObjectForSection(table.header(), false)) return headerObject; RenderTableSection* bodySection = table.firstBody(); while (bodySection && bodySection->isAnonymous()) bodySection = table.sectionBelow(bodySection, SkipEmptySections); // now try for <th> tags in the first body. If the first body is return headerObjectForSection(bodySection, true); }
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 (isTableCell() || !m_renderer || !m_renderer->isTableCell()) return 0; // Table cells that are th cannot have title ui elements, since by definition // they are title ui elements Node* node = m_renderer->node(); if (node && node->hasTagName(thTag)) return 0; RenderTableCell* renderCell = toRenderTableCell(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->rowIndex(); RenderTableSection* section = renderCell->section(); if (!section) return 0; RenderTableCell* headerCell = section->primaryCellAt(row, 0); if (!headerCell || headerCell == renderCell) return 0; Node* cellElement = headerCell->node(); if (!cellElement || !cellElement->hasTagName(thTag)) return 0; return axObjectCache()->getOrCreate(headerCell); }
bool AccessibilityTable::isDataTable() const { if (!m_renderer) return false; // Do not consider it a data table is it has an ARIA role. if (hasARIARole()) return false; // 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. RenderTable* table = toRenderTable(m_renderer); Node* tableNode = table->node(); 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->visitedDependentColor(CSSPropertyBackgroundColor); // 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; Color alternatingRowColors[5]; int alternatingRowColorCount = 0; int headersInFirstColumnCount = 0; for (int row = 0; row < numRows; ++row) { int headersInFirstRowCount = 0; for (int col = 0; col < numCols; ++col) { RenderTableCell* cell = firstBody->primaryCellAt(row, col); if (!cell) continue; Node* cellNode = cell->node(); if (!cellNode) continue; if (cell->width() < 1 || cell->height() < 1) continue; validCellCount++; HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode); bool isTHCell = cellElement->hasTagName(thTag); // If the first row is comprised of all <th> tags, assume it is a data table. if (!row && isTHCell) headersInFirstRowCount++; // If the first column is comprised of all <th> tags, assume it is a data table. if (!col && isTHCell) headersInFirstColumnCount++; // 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->visitedDependentColor(CSSPropertyBackgroundColor); 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; // For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows. if (row < 5 && row == alternatingRowColorCount) { RenderObject* renderRow = cell->parent(); if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow()) continue; RenderStyle* rowRenderStyle = renderRow->style(); if (!rowRenderStyle) continue; Color rowColor = rowRenderStyle->visitedDependentColor(CSSPropertyBackgroundColor); alternatingRowColors[alternatingRowColorCount] = rowColor; alternatingRowColorCount++; } } if (!row && headersInFirstRowCount == numCols && numCols > 1) return true; } if (headersInFirstColumnCount == numRows && numRows > 1) 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; // Check if there is an alternating row background color indicating a zebra striped style pattern. if (alternatingRowColorCount > 2) { Color firstColor = alternatingRowColors[0]; for (int k = 1; k < alternatingRowColorCount; k++) { // If an odd row was the same color as the first row, its not alternating. if (k % 2 == 1 && alternatingRowColors[k] == firstColor) return false; // If an even row is not the same as the first row, its not alternating. if (!(k % 2) && alternatingRowColors[k] != firstColor) return false; } return true; } return false; }
int FixedTableLayout::calcWidthArray(int tableWidth) { int usedWidth = 0; // iterate over all <col> elements RenderObject* child = m_table->firstChild(); int cCol = 0; int nEffCols = m_table->numEffCols(); m_width.resize(nEffCols); m_width.fill(Length(Auto)); Length grpWidth; while (child) { if (child->isTableCol()) { RenderTableCol *col = static_cast<RenderTableCol *>(child); int span = col->span(); if (col->firstChild()) grpWidth = col->style()->width(); else { Length w = col->style()->width(); if (w.isAuto()) w = grpWidth; int effWidth = 0; if (w.isFixed() && w.value() > 0) effWidth = w.value(); int usedSpan = 0; int i = 0; while (usedSpan < span) { if(cCol + i >= nEffCols) { m_table->appendColumn(span - usedSpan); nEffCols++; m_width.resize(nEffCols); m_width[nEffCols-1] = Length(); } int eSpan = m_table->spanOfEffCol(cCol+i); if ((w.isFixed() || w.isPercent()) && w.isPositive()) { m_width[cCol + i].setRawValue(w.type(), w.rawValue() * eSpan); usedWidth += effWidth * eSpan; } usedSpan += eSpan; i++; } cCol += i; } } else break; RenderObject *next = child->firstChild(); if (!next) next = child->nextSibling(); if (!next && child->parent()->isTableCol()) { next = child->parent()->nextSibling(); grpWidth = Length(); } child = next; } // Iterate over the first row in case some are unspecified. RenderTableSection* section = m_table->header(); if (!section) section = m_table->firstBody(); if (!section) section = m_table->footer(); if (section && !section->numRows()) section = m_table->sectionBelow(section, true); if (section) { cCol = 0; RenderObject* firstRow = section->firstChild(); child = firstRow->firstChild(); while (child) { if (child->isTableCell()) { RenderTableCell* cell = static_cast<RenderTableCell*>(child); if (cell->prefWidthsDirty()) cell->calcPrefWidths(); Length w = cell->styleOrColWidth(); int span = cell->colSpan(); int effWidth = 0; if (w.isFixed() && w.isPositive()) effWidth = w.value(); int usedSpan = 0; int i = 0; while (usedSpan < span) { ASSERT(cCol + i < nEffCols); int eSpan = m_table->spanOfEffCol(cCol + i); // Only set if no col element has already set it. if (m_width[cCol + i].isAuto() && w.type() != Auto) { m_width[cCol + i].setRawValue(w.type(), w.rawValue() * eSpan / span); usedWidth += effWidth * eSpan / span; } usedSpan += eSpan; i++; } cCol += i; } child = child->nextSibling(); } } return usedWidth; }
int FixedTableLayout::calcWidthArray(int) { int usedWidth = 0; // iterate over all <col> elements RenderObject* child = m_table->firstChild(); int nEffCols = m_table->numEffCols(); m_width.resize(nEffCols); m_width.fill(Length(Auto)); int currentEffectiveColumn = 0; Length grpWidth; while (child && child->isTableCol()) { RenderTableCol* col = toRenderTableCol(child); if (col->firstChild()) grpWidth = col->style()->logicalWidth(); else { Length w = col->style()->logicalWidth(); if (w.isAuto()) w = grpWidth; int effWidth = 0; if (w.isFixed() && w.value() > 0) effWidth = w.value(); int span = col->span(); while (span) { int spanInCurrentEffectiveColumn; if (currentEffectiveColumn >= nEffCols) { m_table->appendColumn(span); nEffCols++; m_width.append(Length()); spanInCurrentEffectiveColumn = span; } else { if (span < m_table->spanOfEffCol(currentEffectiveColumn)) { m_table->splitColumn(currentEffectiveColumn, span); nEffCols++; m_width.append(Length()); } spanInCurrentEffectiveColumn = m_table->spanOfEffCol(currentEffectiveColumn); } if ((w.isFixed() || w.isPercent()) && w.isPositive()) { m_width[currentEffectiveColumn] = w; m_width[currentEffectiveColumn] *= spanInCurrentEffectiveColumn; usedWidth += effWidth * spanInCurrentEffectiveColumn; } span -= spanInCurrentEffectiveColumn; currentEffectiveColumn++; } } col->computePreferredLogicalWidths(); RenderObject* next = child->firstChild(); if (!next) next = child->nextSibling(); if (!next && child->parent()->isTableCol()) { next = child->parent()->nextSibling(); grpWidth = Length(); } child = next; } // Iterate over the first row in case some are unspecified. RenderTableSection* section = m_table->topNonEmptySection(); if (section) { int cCol = 0; RenderObject* firstRow = section->firstChild(); child = firstRow->firstChild(); while (child) { if (child->isTableCell()) { RenderTableCell* cell = toRenderTableCell(child); if (cell->preferredLogicalWidthsDirty()) cell->computePreferredLogicalWidths(); Length w = cell->styleOrColLogicalWidth(); int span = cell->colSpan(); int effWidth = 0; if (w.isFixed() && w.isPositive()) effWidth = w.value(); int usedSpan = 0; int i = 0; while (usedSpan < span && cCol + i < nEffCols) { float eSpan = m_table->spanOfEffCol(cCol + i); // Only set if no col element has already set it. if (m_width[cCol + i].isAuto() && w.type() != Auto) { m_width[cCol + i] = w; m_width[cCol + i] *= eSpan / span; usedWidth += effWidth * eSpan / span; } usedSpan += eSpan; i++; } cCol += i; } child = child->nextSibling(); } } return usedWidth; }
int FixedTableLayout::calcWidthArray(int) { int usedWidth = 0; // iterate over all <col> elements unsigned nEffCols = m_table->numEffCols(); m_width.resize(nEffCols); m_width.fill(Length(Auto)); unsigned currentEffectiveColumn = 0; for (RenderTableCol* col = m_table->firstColumn(); col; col = col->nextColumn()) { col->computePreferredLogicalWidths(); // Width specified by column-groups that have column child does not affect column width in fixed layout tables if (col->isTableColumnGroupWithColumnChildren()) continue; Length colStyleLogicalWidth = col->style()->logicalWidth(); int effectiveColWidth = 0; if (colStyleLogicalWidth.isFixed() && colStyleLogicalWidth.value() > 0) effectiveColWidth = colStyleLogicalWidth.value(); unsigned span = col->span(); while (span) { unsigned spanInCurrentEffectiveColumn; if (currentEffectiveColumn >= nEffCols) { m_table->appendColumn(span); nEffCols++; m_width.append(Length()); spanInCurrentEffectiveColumn = span; } else { if (span < m_table->spanOfEffCol(currentEffectiveColumn)) { m_table->splitColumn(currentEffectiveColumn, span); nEffCols++; m_width.append(Length()); } spanInCurrentEffectiveColumn = m_table->spanOfEffCol(currentEffectiveColumn); } if ((colStyleLogicalWidth.isFixed() || colStyleLogicalWidth.isPercent()) && colStyleLogicalWidth.isPositive()) { m_width[currentEffectiveColumn] = colStyleLogicalWidth; m_width[currentEffectiveColumn] *= spanInCurrentEffectiveColumn; usedWidth += effectiveColWidth * spanInCurrentEffectiveColumn; } span -= spanInCurrentEffectiveColumn; currentEffectiveColumn++; } } // Iterate over the first row in case some are unspecified. RenderTableSection* section = m_table->topNonEmptySection(); if (!section) return usedWidth; unsigned currentColumn = 0; RenderObject* firstRow = section->firstChild(); for (RenderObject* child = firstRow->firstChild(); child; child = child->nextSibling()) { if (!child->isTableCell()) continue; RenderTableCell* cell = toRenderTableCell(child); if (cell->preferredLogicalWidthsDirty()) cell->computePreferredLogicalWidths(); Length logicalWidth = cell->styleOrColLogicalWidth(); unsigned span = cell->colSpan(); int fixedBorderBoxLogicalWidth = 0; if (logicalWidth.isFixed() && logicalWidth.isPositive()) { fixedBorderBoxLogicalWidth = cell->adjustBorderBoxLogicalWidthForBoxSizing(logicalWidth.value()); logicalWidth.setValue(fixedBorderBoxLogicalWidth); } unsigned usedSpan = 0; while (usedSpan < span && currentColumn < nEffCols) { float eSpan = m_table->spanOfEffCol(currentColumn); // Only set if no col element has already set it. if (m_width[currentColumn].isAuto() && logicalWidth.type() != Auto) { m_width[currentColumn] = logicalWidth; m_width[currentColumn] *= eSpan / span; usedWidth += fixedBorderBoxLogicalWidth * eSpan / span; } usedSpan += eSpan; ++currentColumn; } } return usedWidth; }
AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column, unsigned row) { if (!m_renderer || !m_renderer->isTable()) return 0; updateChildrenIfNecessary(); RenderTable* table = toRenderTable(m_renderer); // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection. RenderTableSection* tableSection = table->header(); if (!tableSection) tableSection = table->firstBody(); RenderTableCell* cell = 0; unsigned rowCount = 0; unsigned rowOffset = 0; while (tableSection) { unsigned numRows = tableSection->numRows(); unsigned numCols = tableSection->numColumns(); rowCount += numRows; unsigned sectionSpecificRow = row - rowOffset; if (row < rowCount && column < numCols && sectionSpecificRow < numRows) { cell = tableSection->primaryCellAt(sectionSpecificRow, column); // 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->primaryCellAt(testRow, column); // cell overlapped. use this one ASSERT(cell->rowSpan() >= 1); if (cell && ((cell->rowIndex() + (cell->rowSpan() - 1)) >= sectionSpecificRow)) break; cell = 0; } if (!cell) { // try cols for (int testCol = column - 1; testCol >= 0; --testCol) { cell = tableSection->primaryCellAt(sectionSpecificRow, testCol); // cell overlapped. use this one ASSERT(cell->rowSpan() >= 1); if (cell && ((cell->col() + (cell->colSpan() - 1)) >= column)) break; cell = 0; } } } } if (cell) break; rowOffset += numRows; // we didn't find anything between the rows we should have if (row < rowCount) break; tableSection = table->sectionBelow(tableSection, SkipEmptySections); } if (!cell) return 0; AccessibilityObject* cellObject = axObjectCache()->getOrCreate(cell); ASSERT(cellObject->isTableCell()); return static_cast<AccessibilityTableCell*>(cellObject); }
int FixedTableLayout::calcWidthArray() { int usedWidth = 0; // iterate over all <col> elements RenderObject *child = table->firstChild(); int cCol = 0; int nEffCols = table->numEffCols(); width.resize( nEffCols ); width.fill( Length( Variable ) ); #ifdef DEBUG_LAYOUT qDebug("FixedTableLayout::calcWidthArray()" ); qDebug(" col elements:"); #endif Length grpWidth; while ( child ) { if ( child->isTableCol() ) { RenderTableCol *col = static_cast<RenderTableCol *>(child); int span = col->span(); if ( col->firstChild() ) { grpWidth = col->style()->width(); } else { Length w = col->style()->width(); if ( w.isVariable() ) w = grpWidth; int effWidth = 0; if ( w.isFixed() && w.value() > 0 ) { effWidth = w.value(); effWidth = KMIN( effWidth, 32760 ); } #ifdef DEBUG_LAYOUT qDebug(" col element: effCol=%d, span=%d: %d w=%d type=%d", cCol, span, effWidth, w.value(), w.type()); #endif int usedSpan = 0; int i = 0; while ( usedSpan < span ) { if( cCol + i >= nEffCols ) { table->appendColumn( span - usedSpan ); nEffCols++; width.resize( nEffCols ); width[nEffCols-1] = Length(); } int eSpan = table->spanOfEffCol( cCol+i ); if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) { width[cCol+i] = Length( w.value() * eSpan, w.type() ); usedWidth += effWidth * eSpan; #ifdef DEBUG_LAYOUT qDebug(" setting effCol %d (span=%d) to width %d(type=%d)", cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() ); #endif } usedSpan += eSpan; i++; } cCol += i; } } else { break; } RenderObject *next = child->firstChild(); if ( !next ) next = child->nextSibling(); if ( !next && child->parent()->isTableCol() ) { next = child->parent()->nextSibling(); grpWidth = Length(); } child = next; } #ifdef DEBUG_LAYOUT qDebug(" first row:"); #endif // iterate over the first row in case some are unspecified. RenderTableSection *section = table->head; if ( !section ) section = table->firstBody; if ( !section ) section = table->foot; if ( section && section->firstChild() ) { cCol = 0; // get the first cell in the first row child = section->firstChild()->firstChild(); while ( child ) { if ( child->isTableCell() ) { RenderTableCell *cell = static_cast<RenderTableCell *>(child); Length w = cell->styleOrColWidth(); int span = cell->colSpan(); int effWidth = 0; if ( (w.isFixed() || w.isPercent()) && w.value() > 0 ) { effWidth = w.value(); effWidth = kMin( effWidth, 32760 ); } #ifdef DEBUG_LAYOUT qDebug(" table cell: effCol=%d, span=%d: %d", cCol, span, effWidth); #endif int usedSpan = 0; int i = 0; while ( usedSpan < span ) { Q_ASSERT( cCol + i < nEffCols ); int eSpan = table->spanOfEffCol( cCol+i ); // only set if no col element has already set it. if ( width[cCol+i].isVariable() && !w.isVariable() ) { width[cCol+i] = Length( w.value()*eSpan, w.type() ); usedWidth += effWidth*eSpan; #ifdef DEBUG_LAYOUT qDebug(" setting effCol %d (span=%d) to width %d(type=%d)", cCol+i, eSpan, width[cCol+i].value(), width[cCol+i].type() ); #endif } #ifdef DEBUG_LAYOUT else { qDebug(" width of col %d already defined (span=%d)", cCol, table->spanOfEffCol( cCol ) ); } #endif usedSpan += eSpan; i++; } cCol += i; } else { Q_ASSERT( false ); } child = child->nextSibling(); } } return usedWidth; }
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); }
void AccessibilityTable::addChildren() { if (!isAccessibilityTable()) { AccessibilityRenderObject::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; unsigned maxColumnCount = 0; while (tableSection) { HashSet<AccessibilityObject*> appendedRows; unsigned numRows = tableSection->numRows(); for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) { RenderTableRow* renderRow = tableSection->rowRendererAt(rowIndex); if (!renderRow) continue; AccessibilityObject* rowObject = axCache->getOrCreate(renderRow); if (!rowObject->isTableRow()) continue; AccessibilityTableRow* row = toAccessibilityTableRow(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); #if PLATFORM(GTK) || PLATFORM(EFL) else m_children.appendVector(row->children()); #endif appendedRows.add(row); } maxColumnCount = std::max(tableSection->numColumns(), maxColumnCount); tableSection = table->sectionBelow(tableSection, SkipEmptySections); } // make the columns based on the number of columns in the first body unsigned length = maxColumnCount; for (unsigned i = 0; i < length; ++i) { AccessibilityTableColumn* column = toAccessibilityTableColumn(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }
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); }
CollapsedBorderValue RenderTableCell::collapsedBeforeBorder() const { RenderTable* table = this->table(); // For before border, we need to check, in order of precedence: // (1) Our before border. int before = CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, table->style()->direction(), table->style()->writingMode()); int after = CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, table->style()->direction(), table->style()->writingMode()); CollapsedBorderValue result = CollapsedBorderValue(&style()->borderBefore(), style()->visitedDependentColor(before), BCELL); RenderTableCell* prevCell = table->cellAbove(this); if (prevCell) { // (2) A before cell's after border. result = chooseBorder(CollapsedBorderValue(&prevCell->style()->borderAfter(), prevCell->style()->visitedDependentColor(after), BCELL), result); if (!result.exists()) return result; } // (3) Our row's before border. result = chooseBorder(result, CollapsedBorderValue(&parent()->style()->borderBefore(), parent()->style()->visitedDependentColor(before), BROW)); if (!result.exists()) return result; // (4) The previous row's after border. if (prevCell) { RenderObject* prevRow = 0; if (prevCell->section() == section()) prevRow = parent()->previousSibling(); else prevRow = prevCell->section()->lastChild(); if (prevRow) { result = chooseBorder(CollapsedBorderValue(&prevRow->style()->borderAfter(), prevRow->style()->visitedDependentColor(after), BROW), result); if (!result.exists()) return result; } } // Now check row groups. RenderTableSection* currSection = section(); if (!row()) { // (5) Our row group's before border. result = chooseBorder(result, CollapsedBorderValue(&currSection->style()->borderBefore(), currSection->style()->visitedDependentColor(before), BROWGROUP)); if (!result.exists()) return result; // (6) Previous row group's after border. currSection = table->sectionAbove(currSection); if (currSection) { result = chooseBorder(CollapsedBorderValue(&currSection->style()->borderAfter(), currSection->style()->visitedDependentColor(after), BROWGROUP), result); if (!result.exists()) return result; } } if (!currSection) { // (8) Our column and column group's before borders. RenderTableCol* colElt = table->colElement(col()); if (colElt) { result = chooseBorder(result, CollapsedBorderValue(&colElt->style()->borderBefore(), colElt->style()->visitedDependentColor(before), BCOL)); if (!result.exists()) return result; if (colElt->parent()->isTableCol()) { result = chooseBorder(result, CollapsedBorderValue(&colElt->parent()->style()->borderBefore(), colElt->parent()->style()->visitedDependentColor(before), BCOLGROUP)); if (!result.exists()) return result; } } // (9) The table's before border. result = chooseBorder(result, CollapsedBorderValue(&table->style()->borderBefore(), table->style()->visitedDependentColor(before), BTABLE)); if (!result.exists()) return result; } return result; }
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; }
int FixedTableLayout::calcWidthArray() { // FIXME: We might want to wait until we have all of the first row before computing for the first time. int usedWidth = 0; // iterate over all <col> elements unsigned nEffCols = m_table->numEffCols(); m_width.resize(nEffCols); m_width.fill(Length(Auto)); unsigned currentEffectiveColumn = 0; for (RenderTableCol* col = m_table->firstColumn(); col; col = col->nextColumn()) { // RenderTableCols don't have the concept of preferred logical width, but we need to clear their dirty bits // so that if we call setPreferredWidthsDirty(true) on a col or one of its descendants, we'll mark it's // ancestors as dirty. col->clearPreferredLogicalWidthsDirtyBits(); // Width specified by column-groups that have column child does not affect column width in fixed layout tables if (col->isTableColumnGroupWithColumnChildren()) continue; Length colStyleLogicalWidth = col->style().logicalWidth(); int effectiveColWidth = 0; if (colStyleLogicalWidth.isFixed() && colStyleLogicalWidth.value() > 0) effectiveColWidth = colStyleLogicalWidth.value(); unsigned span = col->span(); while (span) { unsigned spanInCurrentEffectiveColumn; if (currentEffectiveColumn >= nEffCols) { m_table->appendColumn(span); nEffCols++; m_width.append(Length()); spanInCurrentEffectiveColumn = span; } else { if (span < m_table->spanOfEffCol(currentEffectiveColumn)) { m_table->splitColumn(currentEffectiveColumn, span); nEffCols++; m_width.append(Length()); } spanInCurrentEffectiveColumn = m_table->spanOfEffCol(currentEffectiveColumn); } if ((colStyleLogicalWidth.isFixed() || colStyleLogicalWidth.isPercent()) && colStyleLogicalWidth.isPositive()) { m_width[currentEffectiveColumn] = colStyleLogicalWidth; m_width[currentEffectiveColumn] *= spanInCurrentEffectiveColumn; usedWidth += effectiveColWidth * spanInCurrentEffectiveColumn; } span -= spanInCurrentEffectiveColumn; currentEffectiveColumn++; } } // Iterate over the first row in case some are unspecified. RenderTableSection* section = m_table->topNonEmptySection(); if (!section) return usedWidth; unsigned currentColumn = 0; RenderTableRow* firstRow = section->firstRow(); for (RenderTableCell* cell = firstRow->firstCell(); cell; cell = cell->nextCell()) { Length logicalWidth = cell->styleOrColLogicalWidth(); unsigned span = cell->colSpan(); int fixedBorderBoxLogicalWidth = 0; // FIXME: Support other length types. If the width is non-auto, it should probably just use // RenderBox::computeLogicalWidthInRegionUsing to compute the width. if (logicalWidth.isFixed() && logicalWidth.isPositive()) { fixedBorderBoxLogicalWidth = cell->adjustBorderBoxLogicalWidthForBoxSizing(logicalWidth.value()); logicalWidth.setValue(Fixed, fixedBorderBoxLogicalWidth); } unsigned usedSpan = 0; while (usedSpan < span && currentColumn < nEffCols) { float eSpan = m_table->spanOfEffCol(currentColumn); // Only set if no col element has already set it. if (m_width[currentColumn].isAuto() && logicalWidth.type() != Auto) { m_width[currentColumn] = logicalWidth; m_width[currentColumn] *= eSpan / span; usedWidth += fixedBorderBoxLogicalWidth * eSpan / span; } usedSpan += eSpan; ++currentColumn; } // FixedTableLayout doesn't use min/maxPreferredLogicalWidths, but we need to clear the // dirty bit on the cell so that we'll correctly mark its ancestors dirty // in case we later call setPreferredLogicalWidthsDirty(true) on it later. if (cell->preferredLogicalWidthsDirty()) cell->setPreferredLogicalWidthsDirty(false); } return usedWidth; }
CollapsedBorderValue RenderTableCell::collapsedAfterBorder() const { RenderTable* table = this->table(); // For after border, we need to check, in order of precedence: // (1) Our after border. int before = CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderBeforeColor, table->style()->direction(), table->style()->writingMode()); int after = CSSProperty::resolveDirectionAwareProperty(CSSPropertyWebkitBorderAfterColor, table->style()->direction(), table->style()->writingMode()); CollapsedBorderValue result = CollapsedBorderValue(&style()->borderAfter(), style()->visitedDependentColor(after), BCELL); RenderTableCell* nextCell = table->cellBelow(this); if (nextCell) { // (2) An after cell's before border. result = chooseBorder(result, CollapsedBorderValue(&nextCell->style()->borderBefore(), nextCell->style()->visitedDependentColor(before), BCELL)); if (!result.exists()) return result; } // (3) Our row's after border. (FIXME: Deal with rowspan!) result = chooseBorder(result, CollapsedBorderValue(&parent()->style()->borderAfter(), parent()->style()->visitedDependentColor(after), BROW)); if (!result.exists()) return result; // (4) The next row's before border. if (nextCell) { result = chooseBorder(result, CollapsedBorderValue(&nextCell->parent()->style()->borderBefore(), nextCell->parent()->style()->visitedDependentColor(before), BROW)); if (!result.exists()) return result; } // Now check row groups. RenderTableSection* currSection = section(); if (row() + rowSpan() >= currSection->numRows()) { // (5) Our row group's after border. result = chooseBorder(result, CollapsedBorderValue(&currSection->style()->borderAfter(), currSection->style()->visitedDependentColor(after), BROWGROUP)); if (!result.exists()) return result; // (6) Following row group's before border. currSection = table->sectionBelow(currSection); if (currSection) { result = chooseBorder(result, CollapsedBorderValue(&currSection->style()->borderBefore(), currSection->style()->visitedDependentColor(before), BROWGROUP)); if (!result.exists()) return result; } } if (!currSection) { // (8) Our column and column group's after borders. RenderTableCol* colElt = table->colElement(col()); if (colElt) { result = chooseBorder(result, CollapsedBorderValue(&colElt->style()->borderAfter(), colElt->style()->visitedDependentColor(after), BCOL)); if (!result.exists()) return result; if (colElt->parent()->isTableCol()) { result = chooseBorder(result, CollapsedBorderValue(&colElt->parent()->style()->borderAfter(), colElt->parent()->style()->visitedDependentColor(after), BCOLGROUP)); if (!result.exists()) return result; } } // (9) The table's after border. result = chooseBorder(result, CollapsedBorderValue(&table->style()->borderAfter(), table->style()->visitedDependentColor(after), BTABLE)); if (!result.exists()) return result; } return result; }
bool AccessibilityTable::isDataTable() const { if (!m_renderer) return false; // Do not consider it a data table is it has an ARIA role. if (hasARIARole()) return false; // When a section of the document is contentEditable, all tables should be // treated as data tables, otherwise users may not be able to work with rich // text editors that allow creating and editing tables. if (node() && node()->hasEditableStyle()) return true; // 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. RenderTable* table = toRenderTable(m_renderer); if (!table->element() || !isHTMLTableElement(table->element())) return false; // if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table HTMLTableElement* tableElement = toHTMLTableElement(table->element()); 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; // if there's a colgroup or col element, it's probably a data table. for (const auto& child : childrenOfType<Element>(*tableElement)) { if (child.hasTagName(colTag) || child.hasTagName(colgroupTag)) 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 table->recalcSectionsIfNeeded(); 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; // If there are at least 20 rows, we'll call it a data table. if (numRows >= 20) return true; // Store the background color of the table to check against cell's background colors. const RenderStyle& tableStyle = table->style(); Color tableBGColor = tableStyle.visitedDependentColor(CSSPropertyBackgroundColor); // 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; unsigned cellsWithTopBorder = 0; unsigned cellsWithBottomBorder = 0; unsigned cellsWithLeftBorder = 0; unsigned cellsWithRightBorder = 0; Color alternatingRowColors[5]; int alternatingRowColorCount = 0; int headersInFirstColumnCount = 0; for (int row = 0; row < numRows; ++row) { int headersInFirstRowCount = 0; for (int col = 0; col < numCols; ++col) { RenderTableCell* cell = firstBody->primaryCellAt(row, col); if (!cell) continue; Element* cellElement = cell->element(); if (!cellElement) continue; if (cell->width() < 1 || cell->height() < 1) continue; validCellCount++; bool isTHCell = cellElement->hasTagName(thTag); // If the first row is comprised of all <th> tags, assume it is a data table. if (!row && isTHCell) headersInFirstRowCount++; // If the first column is comprised of all <th> tags, assume it is a data table. if (!col && isTHCell) headersInFirstColumnCount++; // In this case, the developer explicitly assigned a "data" table attribute. if (cellElement->hasTagName(tdTag) || cellElement->hasTagName(thTag)) { HTMLTableCellElement* tableCellElement = toHTMLTableCellElement(cellElement); if (!tableCellElement->headers().isEmpty() || !tableCellElement->abbr().isEmpty() || !tableCellElement->axis().isEmpty() || !tableCellElement->scope().isEmpty()) return true; } const RenderStyle& renderStyle = cell->style(); // If the empty-cells style is set, we'll call it a data table. if (renderStyle.emptyCells() == HIDE) return true; // If a cell has matching bordered sides, call it a (fully) bordered cell. if ((cell->borderTop() > 0 && cell->borderBottom() > 0) || (cell->borderLeft() > 0 && cell->borderRight() > 0)) borderedCellCount++; // Also keep track of each individual border, so we can catch tables where most // cells have a bottom border, for example. if (cell->borderTop() > 0) cellsWithTopBorder++; if (cell->borderBottom() > 0) cellsWithBottomBorder++; if (cell->borderLeft() > 0) cellsWithLeftBorder++; if (cell->borderRight() > 0) cellsWithRightBorder++; // 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.visitedDependentColor(CSSPropertyBackgroundColor); 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; // For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows. if (row < 5 && row == alternatingRowColorCount) { RenderObject* renderRow = cell->parent(); if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow()) continue; const RenderStyle& rowRenderStyle = renderRow->style(); Color rowColor = rowRenderStyle.visitedDependentColor(CSSPropertyBackgroundColor); alternatingRowColors[alternatingRowColorCount] = rowColor; alternatingRowColorCount++; } } if (!row && headersInFirstRowCount == numCols && numCols > 1) return true; } if (headersInFirstColumnCount == numRows && numRows > 1) 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 || cellsWithTopBorder >= neededCellCount || cellsWithBottomBorder >= neededCellCount || cellsWithLeftBorder >= neededCellCount || cellsWithRightBorder >= neededCellCount) return true; // half had different background colors, it's a data table if (backgroundDifferenceCellCount >= neededCellCount) return true; // Check if there is an alternating row background color indicating a zebra striped style pattern. if (alternatingRowColorCount > 2) { Color firstColor = alternatingRowColors[0]; for (int k = 1; k < alternatingRowColorCount; k++) { // If an odd row was the same color as the first row, its not alternating. if (k % 2 == 1 && alternatingRowColors[k] == firstColor) return false; // If an even row is not the same as the first row, its not alternating. if (!(k % 2) && alternatingRowColors[k] != firstColor) return false; } return true; } return false; }
/* 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 }
CollapsedBorderValue RenderTableCell::collapsedBottomBorder() const { // For border top, we need to check, in order of precedence: // (1) Our bottom border. CollapsedBorderValue result = CollapsedBorderValue(&style()->borderBottom(), BCELL); RenderTableCell* nextCell = table()->cellBelow(this); if (nextCell) { // (2) A following cell's top border. result = compareBorders(result, CollapsedBorderValue(&nextCell->style()->borderTop(), BCELL)); if (!result.exists()) return result; } // (3) Our row's bottom border. (FIXME: Deal with rowspan!) result = compareBorders(result, CollapsedBorderValue(&parent()->style()->borderBottom(), BROW)); if (!result.exists()) return result; // (4) The next row's top border. if (nextCell) { result = compareBorders(result, CollapsedBorderValue(&nextCell->parent()->style()->borderTop(), BROW)); if (!result.exists()) return result; } // Now check row groups. RenderTableSection* currSection = section(); if (row() + rowSpan() >= currSection->numRows()) { // (5) Our row group's bottom border. result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderBottom(), BROWGROUP)); if (!result.exists()) return result; // (6) Following row group's top border. currSection = table()->sectionBelow(currSection); if (currSection) { result = compareBorders(result, CollapsedBorderValue(&currSection->style()->borderTop(), BROWGROUP)); if (!result.exists()) return result; } } if (!currSection) { // (8) Our column and column group's bottom borders. RenderTableCol* colElt = table()->colElement(col()); if (colElt) { result = compareBorders(result, CollapsedBorderValue(&colElt->style()->borderBottom(), BCOL)); if (!result.exists()) return result; if (colElt->parent()->isTableCol()) { result = compareBorders(result, CollapsedBorderValue(&colElt->parent()->style()->borderBottom(), BCOLGROUP)); if (!result.exists()) return result; } } // (9) The table's bottom border. result = compareBorders(result, CollapsedBorderValue(&table()->style()->borderBottom(), BTABLE)); if (!result.exists()) return result; } return result; }
void AccessibilityTable::addChildren() { if (!isAccessibilityTable()) { AccessibilityRenderObject::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 // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection. 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->primaryCellAt(rowIndex, colIndex); if (!cell) continue; AccessibilityObject* rowObject = axCache->getOrCreate(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); if (!row->accessibilityIsIgnored()) m_children.append(row); #if PLATFORM(GTK) else m_children.append(row->children()); #endif 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) { AccessibilityTableColumn* column = static_cast<AccessibilityTableColumn*>(axCache->getOrCreate(ColumnRole)); column->setColumnIndex((int)i); column->setParent(this); m_columns.append(column); if (!column->accessibilityIsIgnored()) m_children.append(column); } AccessibilityObject* headerContainerObject = headerContainer(); if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored()) m_children.append(headerContainerObject); }