LCOV - code coverage report
Current view: top level - accessible/generic - ARIAGridAccessible.cpp (source / functions) Hit Total Coverage
Test: output.info Lines: 0 375 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 40 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
       2             : /* This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #include "ARIAGridAccessible-inl.h"
       7             : 
       8             : #include "Accessible-inl.h"
       9             : #include "AccIterator.h"
      10             : #include "nsAccUtils.h"
      11             : #include "Role.h"
      12             : #include "States.h"
      13             : 
      14             : #include "nsIMutableArray.h"
      15             : #include "nsIPersistentProperties2.h"
      16             : #include "nsComponentManagerUtils.h"
      17             : 
      18             : using namespace mozilla;
      19             : using namespace mozilla::a11y;
      20             : 
      21             : ////////////////////////////////////////////////////////////////////////////////
      22             : // ARIAGridAccessible
      23             : ////////////////////////////////////////////////////////////////////////////////
      24             : 
      25             : 
      26             : ////////////////////////////////////////////////////////////////////////////////
      27             : // Constructor
      28             : 
      29           0 : ARIAGridAccessible::
      30           0 :   ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc) :
      31           0 :   AccessibleWrap(aContent, aDoc)
      32             : {
      33           0 : }
      34             : 
      35           0 : NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridAccessible, Accessible)
      36             : 
      37             : ////////////////////////////////////////////////////////////////////////////////
      38             : // Table
      39             : 
      40             : uint32_t
      41           0 : ARIAGridAccessible::ColCount()
      42             : {
      43           0 :   AccIterator rowIter(this, filters::GetRow);
      44           0 :   Accessible* row = rowIter.Next();
      45           0 :   if (!row)
      46           0 :     return 0;
      47             : 
      48           0 :   AccIterator cellIter(row, filters::GetCell);
      49           0 :   Accessible* cell = nullptr;
      50             : 
      51           0 :   uint32_t colCount = 0;
      52           0 :   while ((cell = cellIter.Next()))
      53           0 :     colCount++;
      54             : 
      55           0 :   return colCount;
      56             : }
      57             : 
      58             : uint32_t
      59           0 : ARIAGridAccessible::RowCount()
      60             : {
      61           0 :   uint32_t rowCount = 0;
      62           0 :   AccIterator rowIter(this, filters::GetRow);
      63           0 :   while (rowIter.Next())
      64           0 :     rowCount++;
      65             : 
      66           0 :   return rowCount;
      67             : }
      68             : 
      69             : Accessible*
      70           0 : ARIAGridAccessible::CellAt(uint32_t aRowIndex, uint32_t aColumnIndex)
      71             : {
      72           0 :   Accessible* row = GetRowAt(aRowIndex);
      73           0 :   if (!row)
      74           0 :     return nullptr;
      75             : 
      76           0 :   return GetCellInRowAt(row, aColumnIndex);
      77             : }
      78             : 
      79             : bool
      80           0 : ARIAGridAccessible::IsColSelected(uint32_t aColIdx)
      81             : {
      82           0 :   if (IsARIARole(nsGkAtoms::table))
      83           0 :     return false;
      84             : 
      85           0 :   AccIterator rowIter(this, filters::GetRow);
      86           0 :   Accessible* row = rowIter.Next();
      87           0 :   if (!row)
      88           0 :     return false;
      89             : 
      90           0 :   do {
      91           0 :     if (!nsAccUtils::IsARIASelected(row)) {
      92           0 :       Accessible* cell = GetCellInRowAt(row, aColIdx);
      93           0 :       if (!cell || !nsAccUtils::IsARIASelected(cell))
      94           0 :         return false;
      95             :     }
      96             :   } while ((row = rowIter.Next()));
      97             : 
      98           0 :   return true;
      99             : }
     100             : 
     101             : bool
     102           0 : ARIAGridAccessible::IsRowSelected(uint32_t aRowIdx)
     103             : {
     104           0 :   if (IsARIARole(nsGkAtoms::table))
     105           0 :     return false;
     106             : 
     107           0 :   Accessible* row = GetRowAt(aRowIdx);
     108           0 :   if(!row)
     109           0 :     return false;
     110             : 
     111           0 :   if (!nsAccUtils::IsARIASelected(row)) {
     112           0 :     AccIterator cellIter(row, filters::GetCell);
     113           0 :     Accessible* cell = nullptr;
     114           0 :     while ((cell = cellIter.Next())) {
     115           0 :       if (!nsAccUtils::IsARIASelected(cell))
     116           0 :         return false;
     117             :     }
     118             :   }
     119             : 
     120           0 :   return true;
     121             : }
     122             : 
     123             : bool
     124           0 : ARIAGridAccessible::IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx)
     125             : {
     126           0 :   if (IsARIARole(nsGkAtoms::table))
     127           0 :     return false;
     128             : 
     129           0 :   Accessible* row = GetRowAt(aRowIdx);
     130           0 :   if(!row)
     131           0 :     return false;
     132             : 
     133           0 :   if (!nsAccUtils::IsARIASelected(row)) {
     134           0 :     Accessible* cell = GetCellInRowAt(row, aColIdx);
     135           0 :     if (!cell || !nsAccUtils::IsARIASelected(cell))
     136           0 :       return false;
     137             :   }
     138             : 
     139           0 :   return true;
     140             : }
     141             : 
     142             : uint32_t
     143           0 : ARIAGridAccessible::SelectedCellCount()
     144             : {
     145           0 :   if (IsARIARole(nsGkAtoms::table))
     146           0 :     return 0;
     147             : 
     148           0 :   uint32_t count = 0, colCount = ColCount();
     149             : 
     150           0 :   AccIterator rowIter(this, filters::GetRow);
     151           0 :   Accessible* row = nullptr;
     152             : 
     153           0 :   while ((row = rowIter.Next())) {
     154           0 :     if (nsAccUtils::IsARIASelected(row)) {
     155           0 :       count += colCount;
     156           0 :       continue;
     157             :     }
     158             : 
     159           0 :     AccIterator cellIter(row, filters::GetCell);
     160           0 :     Accessible* cell = nullptr;
     161             : 
     162           0 :     while ((cell = cellIter.Next())) {
     163           0 :       if (nsAccUtils::IsARIASelected(cell))
     164           0 :         count++;
     165             :     }
     166             :   }
     167             : 
     168           0 :   return count;
     169             : }
     170             : 
     171             : uint32_t
     172           0 : ARIAGridAccessible::SelectedColCount()
     173             : {
     174           0 :   if (IsARIARole(nsGkAtoms::table))
     175           0 :     return 0;
     176             : 
     177           0 :   uint32_t colCount = ColCount();
     178           0 :   if (!colCount)
     179           0 :     return 0;
     180             : 
     181           0 :   AccIterator rowIter(this, filters::GetRow);
     182           0 :   Accessible* row = rowIter.Next();
     183           0 :   if (!row)
     184           0 :     return 0;
     185             : 
     186           0 :   nsTArray<bool> isColSelArray(colCount);
     187           0 :   isColSelArray.AppendElements(colCount);
     188           0 :   memset(isColSelArray.Elements(), true, colCount * sizeof(bool));
     189             : 
     190           0 :   uint32_t selColCount = colCount;
     191           0 :   do {
     192           0 :     if (nsAccUtils::IsARIASelected(row))
     193           0 :       continue;
     194             : 
     195           0 :     AccIterator cellIter(row, filters::GetCell);
     196           0 :     Accessible* cell = nullptr;
     197           0 :     for (uint32_t colIdx = 0;
     198           0 :          (cell = cellIter.Next()) && colIdx < colCount; colIdx++)
     199           0 :       if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) {
     200           0 :         isColSelArray[colIdx] = false;
     201           0 :         selColCount--;
     202             :       }
     203             :   } while ((row = rowIter.Next()));
     204             : 
     205           0 :   return selColCount;
     206             : }
     207             : 
     208             : uint32_t
     209           0 : ARIAGridAccessible::SelectedRowCount()
     210             : {
     211           0 :   if (IsARIARole(nsGkAtoms::table))
     212           0 :     return 0;
     213             : 
     214           0 :   uint32_t count = 0;
     215             : 
     216           0 :   AccIterator rowIter(this, filters::GetRow);
     217           0 :   Accessible* row = nullptr;
     218             : 
     219           0 :   while ((row = rowIter.Next())) {
     220           0 :     if (nsAccUtils::IsARIASelected(row)) {
     221           0 :       count++;
     222           0 :       continue;
     223             :     }
     224             : 
     225           0 :     AccIterator cellIter(row, filters::GetCell);
     226           0 :     Accessible* cell = cellIter.Next();
     227           0 :     if (!cell)
     228           0 :       continue;
     229             : 
     230           0 :     bool isRowSelected = true;
     231           0 :     do {
     232           0 :       if (!nsAccUtils::IsARIASelected(cell)) {
     233           0 :         isRowSelected = false;
     234           0 :         break;
     235             :       }
     236             :     } while ((cell = cellIter.Next()));
     237             : 
     238           0 :     if (isRowSelected)
     239           0 :       count++;
     240             :   }
     241             : 
     242           0 :   return count;
     243             : }
     244             : 
     245             : void
     246           0 : ARIAGridAccessible::SelectedCells(nsTArray<Accessible*>* aCells)
     247             : {
     248           0 :   if (IsARIARole(nsGkAtoms::table))
     249           0 :     return;
     250             : 
     251           0 :   AccIterator rowIter(this, filters::GetRow);
     252             : 
     253           0 :   Accessible* row = nullptr;
     254           0 :   while ((row = rowIter.Next())) {
     255           0 :     AccIterator cellIter(row, filters::GetCell);
     256           0 :     Accessible* cell = nullptr;
     257             : 
     258           0 :     if (nsAccUtils::IsARIASelected(row)) {
     259           0 :       while ((cell = cellIter.Next()))
     260           0 :         aCells->AppendElement(cell);
     261             : 
     262           0 :       continue;
     263             :     }
     264             : 
     265           0 :     while ((cell = cellIter.Next())) {
     266           0 :       if (nsAccUtils::IsARIASelected(cell))
     267           0 :         aCells->AppendElement(cell);
     268             :     }
     269             :   }
     270             : }
     271             : 
     272             : void
     273           0 : ARIAGridAccessible::SelectedCellIndices(nsTArray<uint32_t>* aCells)
     274             : {
     275           0 :   if (IsARIARole(nsGkAtoms::table))
     276           0 :     return;
     277             : 
     278           0 :   uint32_t colCount = ColCount();
     279             : 
     280           0 :   AccIterator rowIter(this, filters::GetRow);
     281           0 :   Accessible* row = nullptr;
     282           0 :   for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
     283           0 :     if (nsAccUtils::IsARIASelected(row)) {
     284           0 :       for (uint32_t colIdx = 0; colIdx < colCount; colIdx++)
     285           0 :         aCells->AppendElement(rowIdx * colCount + colIdx);
     286             : 
     287           0 :       continue;
     288             :     }
     289             : 
     290           0 :     AccIterator cellIter(row, filters::GetCell);
     291           0 :     Accessible* cell = nullptr;
     292           0 :     for (uint32_t colIdx = 0; (cell = cellIter.Next()); colIdx++) {
     293           0 :       if (nsAccUtils::IsARIASelected(cell))
     294           0 :         aCells->AppendElement(rowIdx * colCount + colIdx);
     295             :     }
     296             :   }
     297             : }
     298             : 
     299             : void
     300           0 : ARIAGridAccessible::SelectedColIndices(nsTArray<uint32_t>* aCols)
     301             : {
     302           0 :   if (IsARIARole(nsGkAtoms::table))
     303           0 :     return;
     304             : 
     305           0 :   uint32_t colCount = ColCount();
     306           0 :   if (!colCount)
     307           0 :     return;
     308             : 
     309           0 :   AccIterator rowIter(this, filters::GetRow);
     310           0 :   Accessible* row = rowIter.Next();
     311           0 :   if (!row)
     312           0 :     return;
     313             : 
     314           0 :   nsTArray<bool> isColSelArray(colCount);
     315           0 :   isColSelArray.AppendElements(colCount);
     316           0 :   memset(isColSelArray.Elements(), true, colCount * sizeof(bool));
     317             : 
     318           0 :   do {
     319           0 :     if (nsAccUtils::IsARIASelected(row))
     320           0 :       continue;
     321             : 
     322           0 :     AccIterator cellIter(row, filters::GetCell);
     323           0 :     Accessible* cell = nullptr;
     324           0 :     for (uint32_t colIdx = 0;
     325           0 :          (cell = cellIter.Next()) && colIdx < colCount; colIdx++)
     326           0 :       if (isColSelArray[colIdx] && !nsAccUtils::IsARIASelected(cell)) {
     327           0 :         isColSelArray[colIdx] = false;
     328             :       }
     329             :   } while ((row = rowIter.Next()));
     330             : 
     331           0 :   for (uint32_t colIdx = 0; colIdx < colCount; colIdx++)
     332           0 :     if (isColSelArray[colIdx])
     333           0 :       aCols->AppendElement(colIdx);
     334             : }
     335             : 
     336             : void
     337           0 : ARIAGridAccessible::SelectedRowIndices(nsTArray<uint32_t>* aRows)
     338             : {
     339           0 :   if (IsARIARole(nsGkAtoms::table))
     340           0 :     return;
     341             : 
     342           0 :   AccIterator rowIter(this, filters::GetRow);
     343           0 :   Accessible* row = nullptr;
     344           0 :   for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
     345           0 :     if (nsAccUtils::IsARIASelected(row)) {
     346           0 :       aRows->AppendElement(rowIdx);
     347           0 :       continue;
     348             :     }
     349             : 
     350           0 :     AccIterator cellIter(row, filters::GetCell);
     351           0 :     Accessible* cell = cellIter.Next();
     352           0 :     if (!cell)
     353           0 :       continue;
     354             : 
     355           0 :     bool isRowSelected = true;
     356           0 :     do {
     357           0 :       if (!nsAccUtils::IsARIASelected(cell)) {
     358           0 :         isRowSelected = false;
     359           0 :         break;
     360             :       }
     361             :     } while ((cell = cellIter.Next()));
     362             : 
     363           0 :     if (isRowSelected)
     364           0 :       aRows->AppendElement(rowIdx);
     365             :   }
     366             : }
     367             : 
     368             : void
     369           0 : ARIAGridAccessible::SelectRow(uint32_t aRowIdx)
     370             : {
     371           0 :   if (IsARIARole(nsGkAtoms::table))
     372           0 :     return;
     373             : 
     374           0 :   AccIterator rowIter(this, filters::GetRow);
     375             : 
     376           0 :   Accessible* row = nullptr;
     377           0 :   for (uint32_t rowIdx = 0; (row = rowIter.Next()); rowIdx++) {
     378           0 :     DebugOnly<nsresult> rv = SetARIASelected(row, rowIdx == aRowIdx);
     379           0 :     NS_ASSERTION(NS_SUCCEEDED(rv), "SetARIASelected() Shouldn't fail!");
     380             :   }
     381             : }
     382             : 
     383             : void
     384           0 : ARIAGridAccessible::SelectCol(uint32_t aColIdx)
     385             : {
     386           0 :   if (IsARIARole(nsGkAtoms::table))
     387           0 :     return;
     388             : 
     389           0 :   AccIterator rowIter(this, filters::GetRow);
     390             : 
     391           0 :   Accessible* row = nullptr;
     392           0 :   while ((row = rowIter.Next())) {
     393             :     // Unselect all cells in the row.
     394           0 :     DebugOnly<nsresult> rv = SetARIASelected(row, false);
     395           0 :     NS_ASSERTION(NS_SUCCEEDED(rv), "SetARIASelected() Shouldn't fail!");
     396             : 
     397             :     // Select cell at the column index.
     398           0 :     Accessible* cell = GetCellInRowAt(row, aColIdx);
     399           0 :     if (cell)
     400           0 :       SetARIASelected(cell, true);
     401             :   }
     402             : }
     403             : 
     404             : void
     405           0 : ARIAGridAccessible::UnselectRow(uint32_t aRowIdx)
     406             : {
     407           0 :   if (IsARIARole(nsGkAtoms::table))
     408           0 :     return;
     409             : 
     410           0 :   Accessible* row = GetRowAt(aRowIdx);
     411           0 :   if (row)
     412           0 :     SetARIASelected(row, false);
     413             : }
     414             : 
     415             : void
     416           0 : ARIAGridAccessible::UnselectCol(uint32_t aColIdx)
     417             : {
     418           0 :   if (IsARIARole(nsGkAtoms::table))
     419           0 :     return;
     420             : 
     421           0 :   AccIterator rowIter(this, filters::GetRow);
     422             : 
     423           0 :   Accessible* row = nullptr;
     424           0 :   while ((row = rowIter.Next())) {
     425           0 :     Accessible* cell = GetCellInRowAt(row, aColIdx);
     426           0 :     if (cell)
     427           0 :       SetARIASelected(cell, false);
     428             :   }
     429             : }
     430             : 
     431             : ////////////////////////////////////////////////////////////////////////////////
     432             : // Protected
     433             : 
     434             : Accessible*
     435           0 : ARIAGridAccessible::GetRowAt(int32_t aRow)
     436             : {
     437           0 :   int32_t rowIdx = aRow;
     438             : 
     439           0 :   AccIterator rowIter(this, filters::GetRow);
     440             : 
     441           0 :   Accessible* row = rowIter.Next();
     442           0 :   while (rowIdx != 0 && (row = rowIter.Next()))
     443           0 :     rowIdx--;
     444             : 
     445           0 :   return row;
     446             : }
     447             : 
     448             : Accessible*
     449           0 : ARIAGridAccessible::GetCellInRowAt(Accessible* aRow, int32_t aColumn)
     450             : {
     451           0 :   int32_t colIdx = aColumn;
     452             : 
     453           0 :   AccIterator cellIter(aRow, filters::GetCell);
     454           0 :   Accessible* cell = cellIter.Next();
     455           0 :   while (colIdx != 0 && (cell = cellIter.Next()))
     456           0 :     colIdx--;
     457             : 
     458           0 :   return cell;
     459             : }
     460             : 
     461             : nsresult
     462           0 : ARIAGridAccessible::SetARIASelected(Accessible* aAccessible,
     463             :                                     bool aIsSelected, bool aNotify)
     464             : {
     465           0 :   if (IsARIARole(nsGkAtoms::table))
     466           0 :     return NS_OK;
     467             : 
     468           0 :   nsIContent *content = aAccessible->GetContent();
     469           0 :   NS_ENSURE_STATE(content);
     470             : 
     471           0 :   nsresult rv = NS_OK;
     472           0 :   if (aIsSelected)
     473           0 :     rv = content->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected,
     474           0 :                           NS_LITERAL_STRING("true"), aNotify);
     475             :   else
     476           0 :     rv = content->SetAttr(kNameSpaceID_None, nsGkAtoms::aria_selected,
     477           0 :                           NS_LITERAL_STRING("false"), aNotify);
     478             : 
     479           0 :   NS_ENSURE_SUCCESS(rv, rv);
     480             : 
     481             :   // No "smart" select/unselect for internal call.
     482           0 :   if (!aNotify)
     483           0 :     return NS_OK;
     484             : 
     485             :   // If row or cell accessible was selected then we're able to not bother about
     486             :   // selection of its cells or its row because our algorithm is row oriented,
     487             :   // i.e. we check selection on row firstly and then on cells.
     488           0 :   if (aIsSelected)
     489           0 :     return NS_OK;
     490             : 
     491           0 :   roles::Role role = aAccessible->Role();
     492             : 
     493             :   // If the given accessible is row that was unselected then remove
     494             :   // aria-selected from cell accessible.
     495           0 :   if (role == roles::ROW) {
     496           0 :     AccIterator cellIter(aAccessible, filters::GetCell);
     497           0 :     Accessible* cell = nullptr;
     498             : 
     499           0 :     while ((cell = cellIter.Next())) {
     500           0 :       rv = SetARIASelected(cell, false, false);
     501           0 :       NS_ENSURE_SUCCESS(rv, rv);
     502             :     }
     503           0 :     return NS_OK;
     504             :   }
     505             : 
     506             :   // If the given accessible is cell that was unselected and its row is selected
     507             :   // then remove aria-selected from row and put aria-selected on
     508             :   // siblings cells.
     509           0 :   if (role == roles::GRID_CELL || role == roles::ROWHEADER ||
     510             :       role == roles::COLUMNHEADER) {
     511           0 :     Accessible* row = aAccessible->Parent();
     512             : 
     513           0 :     if (row && row->Role() == roles::ROW &&
     514           0 :         nsAccUtils::IsARIASelected(row)) {
     515           0 :       rv = SetARIASelected(row, false, false);
     516           0 :       NS_ENSURE_SUCCESS(rv, rv);
     517             : 
     518           0 :       AccIterator cellIter(row, filters::GetCell);
     519           0 :       Accessible* cell = nullptr;
     520           0 :       while ((cell = cellIter.Next())) {
     521           0 :         if (cell != aAccessible) {
     522           0 :           rv = SetARIASelected(cell, true, false);
     523           0 :           NS_ENSURE_SUCCESS(rv, rv);
     524             :         }
     525             :       }
     526             :     }
     527             :   }
     528             : 
     529           0 :   return NS_OK;
     530             : }
     531             : 
     532             : 
     533             : ////////////////////////////////////////////////////////////////////////////////
     534             : // ARIARowAccessible
     535             : ////////////////////////////////////////////////////////////////////////////////
     536             : 
     537           0 : ARIARowAccessible::
     538           0 :   ARIARowAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     539           0 :   AccessibleWrap(aContent, aDoc)
     540             : {
     541           0 :   mGenericTypes |= eTableRow;
     542           0 : }
     543             : 
     544           0 : NS_IMPL_ISUPPORTS_INHERITED0(ARIARowAccessible, Accessible)
     545             : 
     546             : GroupPos
     547           0 : ARIARowAccessible::GroupPosition()
     548             : {
     549           0 :   int32_t count = 0, index = 0;
     550           0 :   Accessible* table = nsAccUtils::TableFor(this);
     551           0 :   if (table && nsCoreUtils::GetUIntAttr(table->GetContent(),
     552           0 :                                         nsGkAtoms::aria_rowcount, &count) &&
     553           0 :       nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_rowindex, &index)) {
     554           0 :     return GroupPos(0, index, count);
     555             :   }
     556             : 
     557           0 :   return AccessibleWrap::GroupPosition();
     558             : }
     559             : 
     560             : 
     561             : ////////////////////////////////////////////////////////////////////////////////
     562             : // ARIAGridCellAccessible
     563             : ////////////////////////////////////////////////////////////////////////////////
     564             : 
     565             : 
     566             : ////////////////////////////////////////////////////////////////////////////////
     567             : // Constructor
     568             : 
     569           0 : ARIAGridCellAccessible::
     570           0 :   ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     571           0 :   HyperTextAccessibleWrap(aContent, aDoc)
     572             : {
     573           0 :   mGenericTypes |= eTableCell;
     574           0 : }
     575             : 
     576           0 : NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridCellAccessible, HyperTextAccessible)
     577             : 
     578             : ////////////////////////////////////////////////////////////////////////////////
     579             : // TableCell
     580             : 
     581             : TableAccessible*
     582           0 : ARIAGridCellAccessible::Table() const
     583             : {
     584           0 :   Accessible* table = nsAccUtils::TableFor(Row());
     585           0 :   return table ? table->AsTable() : nullptr;
     586             : }
     587             : 
     588             : uint32_t
     589           0 : ARIAGridCellAccessible::ColIdx() const
     590             : {
     591           0 :   Accessible* row = Row();
     592           0 :   if (!row)
     593           0 :     return 0;
     594             : 
     595           0 :   int32_t indexInRow = IndexInParent();
     596           0 :   uint32_t colIdx = 0;
     597           0 :   for (int32_t idx = 0; idx < indexInRow; idx++) {
     598           0 :     Accessible* cell = row->GetChildAt(idx);
     599           0 :     roles::Role role = cell->Role();
     600           0 :     if (role == roles::CELL || role == roles::GRID_CELL ||
     601           0 :         role == roles::ROWHEADER || role == roles::COLUMNHEADER)
     602           0 :       colIdx++;
     603             :   }
     604             : 
     605           0 :   return colIdx;
     606             : }
     607             : 
     608             : uint32_t
     609           0 : ARIAGridCellAccessible::RowIdx() const
     610             : {
     611           0 :   return RowIndexFor(Row());
     612             : }
     613             : 
     614             : bool
     615           0 : ARIAGridCellAccessible::Selected()
     616             : {
     617           0 :   Accessible* row = Row();
     618           0 :   if (!row)
     619           0 :     return false;
     620             : 
     621           0 :   return nsAccUtils::IsARIASelected(row) || nsAccUtils::IsARIASelected(this);
     622             : }
     623             : 
     624             : ////////////////////////////////////////////////////////////////////////////////
     625             : // Accessible
     626             : 
     627             : void
     628           0 : ARIAGridCellAccessible::ApplyARIAState(uint64_t* aState) const
     629             : {
     630           0 :   HyperTextAccessibleWrap::ApplyARIAState(aState);
     631             : 
     632             :   // Return if the gridcell has aria-selected="true".
     633           0 :   if (*aState & states::SELECTED)
     634           0 :     return;
     635             : 
     636             :   // Check aria-selected="true" on the row.
     637           0 :   Accessible* row = Parent();
     638           0 :   if (!row || row->Role() != roles::ROW)
     639           0 :     return;
     640             : 
     641           0 :   nsIContent *rowContent = row->GetContent();
     642           0 :   if (nsAccUtils::HasDefinedARIAToken(rowContent,
     643           0 :                                       nsGkAtoms::aria_selected) &&
     644           0 :       !rowContent->AttrValueIs(kNameSpaceID_None,
     645             :                                nsGkAtoms::aria_selected,
     646             :                                nsGkAtoms::_false, eCaseMatters))
     647           0 :     *aState |= states::SELECTABLE | states::SELECTED;
     648             : }
     649             : 
     650             : already_AddRefed<nsIPersistentProperties>
     651           0 : ARIAGridCellAccessible::NativeAttributes()
     652             : {
     653             :   nsCOMPtr<nsIPersistentProperties> attributes =
     654           0 :     HyperTextAccessibleWrap::NativeAttributes();
     655             : 
     656             :   // Expose "table-cell-index" attribute.
     657           0 :   Accessible* thisRow = Row();
     658           0 :   if (!thisRow)
     659           0 :     return attributes.forget();
     660             : 
     661           0 :   int32_t colIdx = 0, colCount = 0;
     662           0 :   uint32_t childCount = thisRow->ChildCount();
     663           0 :   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
     664           0 :     Accessible* child = thisRow->GetChildAt(childIdx);
     665           0 :     if (child == this)
     666           0 :       colIdx = colCount;
     667             : 
     668           0 :     roles::Role role = child->Role();
     669           0 :     if (role == roles::CELL || role == roles::GRID_CELL ||
     670           0 :         role == roles::ROWHEADER || role == roles::COLUMNHEADER)
     671           0 :       colCount++;
     672             :   }
     673             : 
     674           0 :   int32_t rowIdx = RowIndexFor(thisRow);
     675             : 
     676           0 :   nsAutoString stringIdx;
     677           0 :   stringIdx.AppendInt(rowIdx * colCount + colIdx);
     678           0 :   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tableCellIndex, stringIdx);
     679             : 
     680             : #ifdef DEBUG
     681           0 :   nsAutoString unused;
     682           0 :   attributes->SetStringProperty(NS_LITERAL_CSTRING("cppclass"),
     683           0 :                                 NS_LITERAL_STRING("ARIAGridCellAccessible"),
     684           0 :                                 unused);
     685             : #endif
     686             : 
     687           0 :   return attributes.forget();
     688             : }
     689             : 
     690             : GroupPos
     691           0 : ARIAGridCellAccessible::GroupPosition()
     692             : {
     693           0 :   int32_t count = 0, index = 0;
     694           0 :   TableAccessible* table = Table();
     695           0 :   if (table && nsCoreUtils::GetUIntAttr(table->AsAccessible()->GetContent(),
     696           0 :                                         nsGkAtoms::aria_colcount, &count) &&
     697           0 :       nsCoreUtils::GetUIntAttr(mContent, nsGkAtoms::aria_colindex, &index)) {
     698           0 :     return GroupPos(0, index, count);
     699             :   }
     700             : 
     701           0 :   return GroupPos();
     702             : }

Generated by: LCOV version 1.13