9968b14fd8e41e51388836abc9f894b4195f6562
[WebKit-https.git] / Source / WebCore / accessibility / AccessibilityTable.cpp
1 /*
2  * Copyright (C) 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "AccessibilityTable.h"
31
32 #include "AXObjectCache.h"
33 #include "AccessibilityTableCell.h"
34 #include "AccessibilityTableColumn.h"
35 #include "AccessibilityTableHeaderContainer.h"
36 #include "AccessibilityTableRow.h"
37 #include "HTMLNames.h"
38 #include "HTMLTableCaptionElement.h"
39 #include "HTMLTableCellElement.h"
40 #include "HTMLTableElement.h"
41 #include "RenderObject.h"
42 #include "RenderTable.h"
43 #include "RenderTableCell.h"
44 #include "RenderTableSection.h"
45
46 namespace WebCore {
47
48 using namespace HTMLNames;
49
50 AccessibilityTable::AccessibilityTable(RenderObject* renderer)
51     : AccessibilityRenderObject(renderer),
52     m_headerContainer(0)
53 {
54 }
55
56 AccessibilityTable::~AccessibilityTable()
57 {
58 }
59
60 void AccessibilityTable::init()
61 {
62     AccessibilityRenderObject::init();
63 #if ACCESSIBILITY_TABLES
64     m_isAccessibilityTable = isTableExposableThroughAccessibility();
65 #else
66     m_isAccessibilityTable = false;
67 #endif
68 }
69
70 PassRefPtr<AccessibilityTable> AccessibilityTable::create(RenderObject* renderer)
71 {
72     return adoptRef(new AccessibilityTable(renderer));
73 }
74
75 bool AccessibilityTable::hasARIARole() const
76 {
77     if (!m_renderer)
78         return false;
79     
80     AccessibilityRole ariaRole = ariaRoleAttribute();
81     if (ariaRole != UnknownRole)
82         return true;
83
84     return false;
85 }
86
87 bool AccessibilityTable::isAccessibilityTable() const
88 {
89     if (!m_renderer)
90         return false;
91     
92     return m_isAccessibilityTable;
93 }
94
95 bool AccessibilityTable::isDataTable() const
96 {
97     if (!m_renderer)
98         return false;
99
100     // Do not consider it a data table is it has an ARIA role.
101     if (hasARIARole())
102         return false;
103
104     // When a section of the document is contentEditable, all tables should be
105     // treated as data tables, otherwise users may not be able to work with rich
106     // text editors that allow creating and editing tables.
107     if (node() && node()->rendererIsEditable())
108         return true;
109
110     // This employs a heuristic to determine if this table should appear.
111     // Only "data" tables should be exposed as tables.
112     // Unfortunately, there is no good way to determine the difference
113     // between a "layout" table and a "data" table.
114     
115     RenderTable* table = toRenderTable(m_renderer);
116     Node* tableNode = table->node();
117     if (!tableNode || !tableNode->hasTagName(tableTag))
118         return false;
119
120     // if there is a caption element, summary, THEAD, or TFOOT section, it's most certainly a data table
121     HTMLTableElement* tableElement = static_cast<HTMLTableElement*>(tableNode);
122     if (!tableElement->summary().isEmpty() || tableElement->tHead() || tableElement->tFoot() || tableElement->caption())
123         return true;
124     
125     // if someone used "rules" attribute than the table should appear
126     if (!tableElement->rules().isEmpty())
127         return true;    
128
129     // if there's a colgroup or col element, it's probably a data table.
130     for (Node* child = tableElement->firstChild(); child; child = child->nextSibling()) {
131         if (child->hasTagName(colTag) || child->hasTagName(colgroupTag))
132             return true;
133     }
134     
135     // go through the cell's and check for tell-tale signs of "data" table status
136     // cells have borders, or use attributes like headers, abbr, scope or axis
137     table->recalcSectionsIfNeeded();
138     RenderTableSection* firstBody = table->firstBody();
139     if (!firstBody)
140         return false;
141     
142     int numCols = firstBody->numColumns();
143     int numRows = firstBody->numRows();
144     
145     // If there's only one cell, it's not a good AXTable candidate.
146     if (numRows == 1 && numCols == 1)
147         return false;
148
149     // If there are at least 20 rows, we'll call it a data table.
150     if (numRows >= 20)
151         return true;
152     
153     // Store the background color of the table to check against cell's background colors.
154     RenderStyle* tableStyle = table->style();
155     if (!tableStyle)
156         return false;
157     Color tableBGColor = tableStyle->visitedDependentColor(CSSPropertyBackgroundColor);
158     
159     // check enough of the cells to find if the table matches our criteria
160     // Criteria: 
161     //   1) must have at least one valid cell (and)
162     //   2) at least half of cells have borders (or)
163     //   3) at least half of cells have different bg colors than the table, and there is cell spacing
164     unsigned validCellCount = 0;
165     unsigned borderedCellCount = 0;
166     unsigned backgroundDifferenceCellCount = 0;
167     unsigned cellsWithTopBorder = 0;
168     unsigned cellsWithBottomBorder = 0;
169     unsigned cellsWithLeftBorder = 0;
170     unsigned cellsWithRightBorder = 0;
171     
172     Color alternatingRowColors[5];
173     int alternatingRowColorCount = 0;
174     
175     int headersInFirstColumnCount = 0;
176     for (int row = 0; row < numRows; ++row) {
177     
178         int headersInFirstRowCount = 0;
179         for (int col = 0; col < numCols; ++col) {    
180             RenderTableCell* cell = firstBody->primaryCellAt(row, col);
181             if (!cell)
182                 continue;
183             Node* cellNode = cell->node();
184             if (!cellNode)
185                 continue;
186             
187             if (cell->width() < 1 || cell->height() < 1)
188                 continue;
189             
190             validCellCount++;
191             
192             HTMLTableCellElement* cellElement = static_cast<HTMLTableCellElement*>(cellNode);
193             
194             bool isTHCell = cellElement->hasTagName(thTag);
195             // If the first row is comprised of all <th> tags, assume it is a data table.
196             if (!row && isTHCell)
197                 headersInFirstRowCount++;
198
199             // If the first column is comprised of all <th> tags, assume it is a data table.
200             if (!col && isTHCell)
201                 headersInFirstColumnCount++;
202             
203             // in this case, the developer explicitly assigned a "data" table attribute
204             if (!cellElement->headers().isEmpty() || !cellElement->abbr().isEmpty()
205                 || !cellElement->axis().isEmpty() || !cellElement->scope().isEmpty())
206                 return true;
207             
208             RenderStyle* renderStyle = cell->style();
209             if (!renderStyle)
210                 continue;
211
212             // If the empty-cells style is set, we'll call it a data table.
213             if (renderStyle->emptyCells() == HIDE)
214                 return true;
215
216             // If a cell has matching bordered sides, call it a (fully) bordered cell.
217             if ((cell->borderTop() > 0 && cell->borderBottom() > 0)
218                 || (cell->borderLeft() > 0 && cell->borderRight() > 0))
219                 borderedCellCount++;
220
221             // Also keep track of each individual border, so we can catch tables where most
222             // cells have a bottom border, for example.
223             if (cell->borderTop() > 0)
224                 cellsWithTopBorder++;
225             if (cell->borderBottom() > 0)
226                 cellsWithBottomBorder++;
227             if (cell->borderLeft() > 0)
228                 cellsWithLeftBorder++;
229             if (cell->borderRight() > 0)
230                 cellsWithRightBorder++;
231             
232             // If the cell has a different color from the table and there is cell spacing,
233             // then it is probably a data table cell (spacing and colors take the place of borders).
234             Color cellColor = renderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
235             if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0
236                 && tableBGColor != cellColor && cellColor.alpha() != 1)
237                 backgroundDifferenceCellCount++;
238             
239             // If we've found 10 "good" cells, we don't need to keep searching.
240             if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
241                 return true;
242             
243             // For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows.
244             if (row < 5 && row == alternatingRowColorCount) {
245                 RenderObject* renderRow = cell->parent();
246                 if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow())
247                     continue;
248                 RenderStyle* rowRenderStyle = renderRow->style();
249                 if (!rowRenderStyle)
250                     continue;
251                 Color rowColor = rowRenderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
252                 alternatingRowColors[alternatingRowColorCount] = rowColor;
253                 alternatingRowColorCount++;
254             }
255         }
256         
257         if (!row && headersInFirstRowCount == numCols && numCols > 1)
258             return true;
259     }
260
261     if (headersInFirstColumnCount == numRows && numRows > 1)
262         return true;
263     
264     // if there is less than two valid cells, it's not a data table
265     if (validCellCount <= 1)
266         return false;
267     
268     // half of the cells had borders, it's a data table
269     unsigned neededCellCount = validCellCount / 2;
270     if (borderedCellCount >= neededCellCount
271         || cellsWithTopBorder >= neededCellCount
272         || cellsWithBottomBorder >= neededCellCount
273         || cellsWithLeftBorder >= neededCellCount
274         || cellsWithRightBorder >= neededCellCount)
275         return true;
276     
277     // half had different background colors, it's a data table
278     if (backgroundDifferenceCellCount >= neededCellCount)
279         return true;
280
281     // Check if there is an alternating row background color indicating a zebra striped style pattern.
282     if (alternatingRowColorCount > 2) {
283         Color firstColor = alternatingRowColors[0];
284         for (int k = 1; k < alternatingRowColorCount; k++) {
285             // If an odd row was the same color as the first row, its not alternating.
286             if (k % 2 == 1 && alternatingRowColors[k] == firstColor)
287                 return false;
288             // If an even row is not the same as the first row, its not alternating.
289             if (!(k % 2) && alternatingRowColors[k] != firstColor)
290                 return false;
291         }
292         return true;
293     }
294     
295     return false;
296 }
297     
298 bool AccessibilityTable::isTableExposableThroughAccessibility() const
299 {
300     // The following is a heuristic used to determine if a
301     // <table> should be exposed as an AXTable. The goal
302     // is to only show "data" tables.
303
304     if (!m_renderer)
305         return false;
306
307     // If the developer assigned an aria role to this, then we
308     // shouldn't expose it as a table, unless, of course, the aria
309     // role is a table.
310     if (hasARIARole())
311         return false;
312
313     // Gtk+ ATs expect all tables to be exposed as tables.
314 #if PLATFORM(GTK)
315     Node* tableNode = toRenderTable(m_renderer)->node();
316     return tableNode && tableNode->hasTagName(tableTag);
317 #endif
318
319     return isDataTable();
320 }
321
322 void AccessibilityTable::clearChildren()
323 {
324     AccessibilityRenderObject::clearChildren();
325     m_rows.clear();
326     m_columns.clear();
327
328     if (m_headerContainer) {
329         m_headerContainer->detachFromParent();
330         m_headerContainer = 0;
331     }
332 }
333
334 void AccessibilityTable::addChildren()
335 {
336     if (!isAccessibilityTable()) {
337         AccessibilityRenderObject::addChildren();
338         return;
339     }
340     
341     ASSERT(!m_haveChildren); 
342     
343     m_haveChildren = true;
344     if (!m_renderer || !m_renderer->isTable())
345         return;
346     
347     RenderTable* table = toRenderTable(m_renderer);
348     AXObjectCache* axCache = m_renderer->document()->axObjectCache();
349
350     // go through all the available sections to pull out the rows
351     // and add them as children
352     // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection.
353     RenderTableSection* tableSection = table->header();
354     if (!tableSection)
355         tableSection = table->firstBody();
356     
357     if (!tableSection)
358         return;
359     
360     RenderTableSection* initialTableSection = tableSection;
361     
362     while (tableSection) {
363         
364         HashSet<AccessibilityObject*> appendedRows;
365
366         unsigned numRows = tableSection->numRows();
367         unsigned numCols = tableSection->numColumns();
368         for (unsigned rowIndex = 0; rowIndex < numRows; ++rowIndex) {
369             for (unsigned colIndex = 0; colIndex < numCols; ++colIndex) {
370                 
371                 RenderTableCell* cell = tableSection->primaryCellAt(rowIndex, colIndex);
372                 if (!cell)
373                     continue;
374                 
375                 AccessibilityObject* rowObject = axCache->getOrCreate(cell->parent());
376                 if (!rowObject->isTableRow())
377                     continue;
378                 
379                 AccessibilityTableRow* row = static_cast<AccessibilityTableRow*>(rowObject);
380                 // we need to check every cell for a new row, because cell spans
381                 // can cause us to mess rows if we just check the first column
382                 if (appendedRows.contains(row))
383                     continue;
384                 
385                 row->setRowIndex((int)m_rows.size());        
386                 m_rows.append(row);
387                 if (!row->accessibilityIsIgnored())
388                     m_children.append(row);
389 #if PLATFORM(GTK)
390                 else
391                     m_children.append(row->children());
392 #endif
393                 appendedRows.add(row);
394             }
395         }
396         
397         tableSection = table->sectionBelow(tableSection, SkipEmptySections);
398     }
399     
400     // make the columns based on the number of columns in the first body
401     unsigned length = initialTableSection->numColumns();
402     for (unsigned i = 0; i < length; ++i) {
403         AccessibilityTableColumn* column = static_cast<AccessibilityTableColumn*>(axCache->getOrCreate(ColumnRole));
404         column->setColumnIndex((int)i);
405         column->setParent(this);
406         m_columns.append(column);
407         if (!column->accessibilityIsIgnored())
408             m_children.append(column);
409     }
410     
411     AccessibilityObject* headerContainerObject = headerContainer();
412     if (headerContainerObject && !headerContainerObject->accessibilityIsIgnored())
413         m_children.append(headerContainerObject);
414 }
415     
416 AccessibilityObject* AccessibilityTable::headerContainer()
417 {
418     if (m_headerContainer)
419         return m_headerContainer.get();
420     
421     AccessibilityMockObject* tableHeader = toAccessibilityMockObject(axObjectCache()->getOrCreate(TableHeaderContainerRole));
422     tableHeader->setParent(this);
423
424     m_headerContainer = tableHeader;
425     return m_headerContainer.get();
426 }
427
428 AccessibilityObject::AccessibilityChildrenVector& AccessibilityTable::columns()
429 {
430     updateChildrenIfNecessary();
431         
432     return m_columns;
433 }
434
435 AccessibilityObject::AccessibilityChildrenVector& AccessibilityTable::rows()
436 {
437     updateChildrenIfNecessary();
438     
439     return m_rows;
440 }
441     
442 void AccessibilityTable::rowHeaders(AccessibilityChildrenVector& headers)
443 {
444     if (!m_renderer)
445         return;
446     
447     updateChildrenIfNecessary();
448     
449     unsigned rowCount = m_rows.size();
450     for (unsigned k = 0; k < rowCount; ++k) {
451         AccessibilityObject* header = static_cast<AccessibilityTableRow*>(m_rows[k].get())->headerObject();
452         if (!header)
453             continue;
454         headers.append(header);
455     }
456 }
457
458 void AccessibilityTable::columnHeaders(AccessibilityChildrenVector& headers)
459 {
460     if (!m_renderer)
461         return;
462     
463     updateChildrenIfNecessary();
464     
465     unsigned colCount = m_columns.size();
466     for (unsigned k = 0; k < colCount; ++k) {
467         AccessibilityObject* header = static_cast<AccessibilityTableColumn*>(m_columns[k].get())->headerObject();
468         if (!header)
469             continue;
470         headers.append(header);
471     }
472 }
473     
474 void AccessibilityTable::cells(AccessibilityObject::AccessibilityChildrenVector& cells)
475 {
476     if (!m_renderer)
477         return;
478     
479     updateChildrenIfNecessary();
480     
481     int numRows = m_rows.size();
482     for (int row = 0; row < numRows; ++row) {
483         AccessibilityChildrenVector rowChildren = m_rows[row]->children();
484         cells.append(rowChildren);
485     }
486 }
487     
488 unsigned AccessibilityTable::columnCount()
489 {
490     updateChildrenIfNecessary();
491     
492     return m_columns.size();    
493 }
494     
495 unsigned AccessibilityTable::rowCount()
496 {
497     updateChildrenIfNecessary();
498     
499     return m_rows.size();
500 }
501
502 int AccessibilityTable::tableLevel() const
503 {
504     int level = 0;
505     for (AccessibilityObject* obj = static_cast<AccessibilityObject*>(const_cast<AccessibilityTable*>(this)); obj; obj = obj->parentObject()) {
506         if (obj->isAccessibilityTable())
507             ++level;
508     }
509     
510     return level;
511 }
512
513 AccessibilityTableCell* AccessibilityTable::cellForColumnAndRow(unsigned column, unsigned row)
514 {
515     if (!m_renderer || !m_renderer->isTable())
516         return 0;
517     
518     updateChildrenIfNecessary();
519     
520     RenderTable* table = toRenderTable(m_renderer);
521     // FIXME: This will skip a table with just a tfoot. Should fix by using RenderTable::topSection.
522     RenderTableSection* tableSection = table->header();
523     if (!tableSection)
524         tableSection = table->firstBody();
525     
526     RenderTableCell* cell = 0;
527     unsigned rowCount = 0;
528     unsigned rowOffset = 0;
529     while (tableSection) {
530         
531         unsigned numRows = tableSection->numRows();
532         unsigned numCols = tableSection->numColumns();
533         
534         rowCount += numRows;
535         
536         unsigned sectionSpecificRow = row - rowOffset;            
537         if (row < rowCount && column < numCols && sectionSpecificRow < numRows) {
538             cell = tableSection->primaryCellAt(sectionSpecificRow, column);
539             
540             // we didn't find the cell, which means there's spanning happening
541             // search backwards to find the spanning cell
542             if (!cell) {
543                 
544                 // first try rows
545                 for (int testRow = sectionSpecificRow - 1; testRow >= 0; --testRow) {
546                     cell = tableSection->primaryCellAt(testRow, column);
547                     // cell overlapped. use this one
548                     ASSERT(!cell || cell->rowSpan() >= 1);
549                     if (cell && ((cell->rowIndex() + (cell->rowSpan() - 1)) >= sectionSpecificRow))
550                         break;
551                     cell = 0;
552                 }
553                 
554                 if (!cell) {
555                     // try cols
556                     for (int testCol = column - 1; testCol >= 0; --testCol) {
557                         cell = tableSection->primaryCellAt(sectionSpecificRow, testCol);
558                         // cell overlapped. use this one
559                         ASSERT(!cell || cell->rowSpan() >= 1);
560                         if (cell && ((cell->col() + (cell->colSpan() - 1)) >= column))
561                             break;
562                         cell = 0;
563                     }
564                 }
565             }
566         }
567         
568         if (cell)
569             break;
570         
571         rowOffset += numRows;
572         // we didn't find anything between the rows we should have
573         if (row < rowCount)
574             break;
575         tableSection = table->sectionBelow(tableSection, SkipEmptySections);
576     }
577     
578     if (!cell)
579         return 0;
580     
581     AccessibilityObject* cellObject = axObjectCache()->getOrCreate(cell);
582     ASSERT_WITH_SECURITY_IMPLICATION(cellObject->isTableCell());
583     
584     return static_cast<AccessibilityTableCell*>(cellObject);
585 }
586
587 AccessibilityRole AccessibilityTable::roleValue() const
588 {
589     if (!isAccessibilityTable())
590         return AccessibilityRenderObject::roleValue();
591
592     return TableRole;
593 }
594     
595 bool AccessibilityTable::accessibilityIsIgnored() const
596 {
597     AccessibilityObjectInclusion decision = accessibilityIsIgnoredBase();
598     if (decision == IncludeObject)
599         return false;
600     if (decision == IgnoreObject)
601         return true;
602     
603     if (!isAccessibilityTable())
604         return AccessibilityRenderObject::accessibilityIsIgnored();
605         
606     return false;
607 }
608     
609 String AccessibilityTable::title() const
610 {
611     if (!isAccessibilityTable())
612         return AccessibilityRenderObject::title();
613     
614     String title;
615     if (!m_renderer)
616         return title;
617     
618     // see if there is a caption
619     Node* tableElement = m_renderer->node();
620     if (tableElement && tableElement->hasTagName(tableTag)) {
621         HTMLTableCaptionElement* caption = static_cast<HTMLTableElement*>(tableElement)->caption();
622         if (caption)
623             title = caption->innerText();
624     }
625     
626     // try the standard 
627     if (title.isEmpty())
628         title = AccessibilityRenderObject::title();
629     
630     return title;
631 }
632
633 } // namespace WebCore