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 : }
|
