Line data Source code
1 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 : /* vim: set ts=2 et sw=2 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this file,
5 : * You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : #include "xpcAccessibleTable.h"
8 :
9 : #include "Accessible.h"
10 : #include "TableAccessible.h"
11 : #include "xpcAccessibleDocument.h"
12 :
13 : #include "nsIMutableArray.h"
14 : #include "nsComponentManagerUtils.h"
15 :
16 : using namespace mozilla::a11y;
17 :
18 : static const uint32_t XPC_TABLE_DEFAULT_SIZE = 40;
19 :
20 : ////////////////////////////////////////////////////////////////////////////////
21 : // nsISupports
22 :
23 0 : NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTable,
24 : xpcAccessibleGeneric,
25 : nsIAccessibleTable)
26 :
27 : ////////////////////////////////////////////////////////////////////////////////
28 : // nsIAccessibleTable
29 :
30 : NS_IMETHODIMP
31 0 : xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)
32 : {
33 0 : NS_ENSURE_ARG_POINTER(aCaption);
34 0 : *aCaption = nullptr;
35 0 : if (!Intl())
36 0 : return NS_ERROR_FAILURE;
37 :
38 0 : NS_IF_ADDREF(*aCaption = ToXPC(Intl()->Caption()));
39 0 : return NS_OK;
40 : }
41 :
42 : NS_IMETHODIMP
43 0 : xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount)
44 : {
45 0 : NS_ENSURE_ARG_POINTER(aColumnCount);
46 0 : *aColumnCount = 0;
47 :
48 0 : if (!Intl())
49 0 : return NS_ERROR_FAILURE;
50 :
51 0 : *aColumnCount = Intl()->ColCount();
52 0 : return NS_OK;
53 : }
54 :
55 : NS_IMETHODIMP
56 0 : xpcAccessibleTable::GetRowCount(int32_t* aRowCount)
57 : {
58 0 : NS_ENSURE_ARG_POINTER(aRowCount);
59 0 : *aRowCount = 0;
60 :
61 0 : if (!Intl())
62 0 : return NS_ERROR_FAILURE;
63 :
64 0 : *aRowCount = Intl()->RowCount();
65 0 : return NS_OK;
66 : }
67 :
68 : NS_IMETHODIMP
69 0 : xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,
70 : nsIAccessible** aCell)
71 : {
72 0 : NS_ENSURE_ARG_POINTER(aCell);
73 0 : *aCell = nullptr;
74 :
75 0 : if (!Intl())
76 0 : return NS_ERROR_FAILURE;
77 :
78 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
79 0 : aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
80 0 : return NS_ERROR_INVALID_ARG;
81 :
82 0 : NS_IF_ADDREF(*aCell = ToXPC(Intl()->CellAt(aRowIdx, aColIdx)));
83 0 : return NS_OK;
84 : }
85 :
86 : NS_IMETHODIMP
87 0 : xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,
88 : int32_t* aCellIdx)
89 : {
90 0 : NS_ENSURE_ARG_POINTER(aCellIdx);
91 0 : *aCellIdx = -1;
92 :
93 0 : if (!Intl())
94 0 : return NS_ERROR_FAILURE;
95 :
96 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
97 0 : aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
98 0 : return NS_ERROR_INVALID_ARG;
99 :
100 0 : *aCellIdx = Intl()->CellIndexAt(aRowIdx, aColIdx);
101 0 : return NS_OK;
102 : }
103 :
104 : NS_IMETHODIMP
105 0 : xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,
106 : int32_t* aColumnExtent)
107 : {
108 0 : NS_ENSURE_ARG_POINTER(aColumnExtent);
109 0 : *aColumnExtent = -1;
110 :
111 0 : if (!Intl())
112 0 : return NS_ERROR_FAILURE;
113 :
114 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
115 0 : aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
116 0 : return NS_ERROR_INVALID_ARG;
117 :
118 0 : *aColumnExtent = Intl()->ColExtentAt(aRowIdx, aColIdx);
119 0 : return NS_OK;
120 : }
121 :
122 : NS_IMETHODIMP
123 0 : xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,
124 : int32_t* aRowExtent)
125 : {
126 0 : NS_ENSURE_ARG_POINTER(aRowExtent);
127 0 : *aRowExtent = -1;
128 :
129 0 : if (!Intl())
130 0 : return NS_ERROR_FAILURE;
131 :
132 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
133 0 : aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
134 0 : return NS_ERROR_INVALID_ARG;
135 :
136 0 : *aRowExtent = Intl()->RowExtentAt(aRowIdx, aColIdx);
137 0 : return NS_OK;
138 : }
139 :
140 : NS_IMETHODIMP
141 0 : xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,
142 : nsAString& aDescription)
143 : {
144 0 : if (!Intl())
145 0 : return NS_ERROR_FAILURE;
146 :
147 0 : if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
148 0 : return NS_ERROR_INVALID_ARG;
149 :
150 0 : nsAutoString description;
151 0 : Intl()->ColDescription(aColIdx, description);
152 0 : aDescription.Assign(description);
153 :
154 0 : return NS_OK;
155 : }
156 :
157 : NS_IMETHODIMP
158 0 : xpcAccessibleTable::GetRowDescription(int32_t aRowIdx, nsAString& aDescription)
159 : {
160 0 : if (!Intl())
161 0 : return NS_ERROR_FAILURE;
162 :
163 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->ColCount())
164 0 : return NS_ERROR_INVALID_ARG;
165 :
166 0 : nsAutoString description;
167 0 : Intl()->RowDescription(aRowIdx, description);
168 0 : aDescription.Assign(description);
169 :
170 0 : return NS_OK;
171 : }
172 :
173 : NS_IMETHODIMP
174 0 : xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected)
175 : {
176 0 : NS_ENSURE_ARG_POINTER(aIsSelected);
177 0 : *aIsSelected = false;
178 :
179 0 : if (!Intl())
180 0 : return NS_ERROR_FAILURE;
181 :
182 0 : if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
183 0 : return NS_ERROR_INVALID_ARG;
184 :
185 0 : *aIsSelected = Intl()->IsColSelected(aColIdx);
186 0 : return NS_OK;
187 : }
188 :
189 : NS_IMETHODIMP
190 0 : xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected)
191 : {
192 0 : NS_ENSURE_ARG_POINTER(aIsSelected);
193 0 : *aIsSelected = false;
194 :
195 0 : if (!Intl())
196 0 : return NS_ERROR_FAILURE;
197 :
198 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
199 0 : return NS_ERROR_INVALID_ARG;
200 :
201 0 : *aIsSelected = Intl()->IsRowSelected(aRowIdx);
202 0 : return NS_OK;
203 : }
204 :
205 : NS_IMETHODIMP
206 0 : xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,
207 : bool* aIsSelected)
208 : {
209 0 : NS_ENSURE_ARG_POINTER(aIsSelected);
210 0 : *aIsSelected = false;
211 :
212 0 : if (!Intl())
213 0 : return NS_ERROR_FAILURE;
214 :
215 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
216 0 : aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
217 0 : return NS_ERROR_INVALID_ARG;
218 :
219 0 : *aIsSelected = Intl()->IsCellSelected(aRowIdx, aColIdx);
220 0 : return NS_OK;
221 : }
222 :
223 : NS_IMETHODIMP
224 0 : xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount)
225 : {
226 0 : NS_ENSURE_ARG_POINTER(aSelectedCellCount);
227 0 : *aSelectedCellCount = 0;
228 :
229 0 : if (!Intl())
230 0 : return NS_ERROR_FAILURE;
231 :
232 0 : *aSelectedCellCount = Intl()->SelectedCellCount();
233 0 : return NS_OK;
234 : }
235 :
236 : NS_IMETHODIMP
237 0 : xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount)
238 : {
239 0 : NS_ENSURE_ARG_POINTER(aSelectedColumnCount);
240 0 : *aSelectedColumnCount = 0;
241 :
242 0 : if (!Intl())
243 0 : return NS_ERROR_FAILURE;
244 :
245 0 : *aSelectedColumnCount = Intl()->SelectedColCount();
246 0 : return NS_OK;
247 : }
248 :
249 : NS_IMETHODIMP
250 0 : xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount)
251 : {
252 0 : NS_ENSURE_ARG_POINTER(aSelectedRowCount);
253 0 : *aSelectedRowCount = 0;
254 :
255 0 : if (!Intl())
256 0 : return NS_ERROR_FAILURE;
257 :
258 0 : *aSelectedRowCount = Intl()->SelectedRowCount();
259 0 : return NS_OK;
260 : }
261 :
262 : NS_IMETHODIMP
263 0 : xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells)
264 : {
265 0 : NS_ENSURE_ARG_POINTER(aSelectedCells);
266 0 : *aSelectedCells = nullptr;
267 :
268 0 : if (!Intl())
269 0 : return NS_ERROR_FAILURE;
270 :
271 0 : nsresult rv = NS_OK;
272 : nsCOMPtr<nsIMutableArray> selCells =
273 0 : do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
274 0 : NS_ENSURE_SUCCESS(rv, rv);
275 :
276 0 : AutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;
277 0 : Intl()->SelectedCells(&cellsArray);
278 :
279 0 : uint32_t totalCount = cellsArray.Length();
280 0 : for (uint32_t idx = 0; idx < totalCount; idx++) {
281 0 : Accessible* cell = cellsArray.ElementAt(idx);
282 0 : selCells->AppendElement(static_cast<nsIAccessible*>(ToXPC(cell)), false);
283 : }
284 :
285 0 : NS_ADDREF(*aSelectedCells = selCells);
286 0 : return NS_OK;
287 : }
288 :
289 : NS_IMETHODIMP
290 0 : xpcAccessibleTable::GetSelectedCellIndices(uint32_t* aCellsArraySize,
291 : int32_t** aCellsArray)
292 : {
293 0 : NS_ENSURE_ARG_POINTER(aCellsArraySize);
294 0 : *aCellsArraySize = 0;
295 :
296 0 : NS_ENSURE_ARG_POINTER(aCellsArray);
297 0 : *aCellsArray = 0;
298 :
299 0 : if (!Intl())
300 0 : return NS_ERROR_FAILURE;
301 :
302 0 : AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> cellsArray;
303 0 : Intl()->SelectedCellIndices(&cellsArray);
304 :
305 0 : *aCellsArraySize = cellsArray.Length();
306 0 : *aCellsArray = static_cast<int32_t*>
307 0 : (moz_xmalloc(*aCellsArraySize * sizeof(int32_t)));
308 0 : memcpy(*aCellsArray, cellsArray.Elements(),
309 0 : *aCellsArraySize * sizeof(int32_t));
310 :
311 0 : return NS_OK;
312 : }
313 :
314 : NS_IMETHODIMP
315 0 : xpcAccessibleTable::GetSelectedColumnIndices(uint32_t* aColsArraySize,
316 : int32_t** aColsArray)
317 : {
318 0 : NS_ENSURE_ARG_POINTER(aColsArraySize);
319 0 : *aColsArraySize = 0;
320 :
321 0 : NS_ENSURE_ARG_POINTER(aColsArray);
322 0 : *aColsArray = 0;
323 :
324 0 : if (!Intl())
325 0 : return NS_ERROR_FAILURE;
326 :
327 0 : AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> colsArray;
328 0 : Intl()->SelectedColIndices(&colsArray);
329 :
330 0 : *aColsArraySize = colsArray.Length();
331 0 : *aColsArray = static_cast<int32_t*>
332 0 : (moz_xmalloc(*aColsArraySize * sizeof(int32_t)));
333 0 : memcpy(*aColsArray, colsArray.Elements(),
334 0 : *aColsArraySize * sizeof(int32_t));
335 :
336 0 : return NS_OK;
337 : }
338 :
339 : NS_IMETHODIMP
340 0 : xpcAccessibleTable::GetSelectedRowIndices(uint32_t* aRowsArraySize,
341 : int32_t** aRowsArray)
342 : {
343 0 : NS_ENSURE_ARG_POINTER(aRowsArraySize);
344 0 : *aRowsArraySize = 0;
345 :
346 0 : NS_ENSURE_ARG_POINTER(aRowsArray);
347 0 : *aRowsArray = 0;
348 :
349 0 : if (!Intl())
350 0 : return NS_ERROR_FAILURE;
351 :
352 0 : AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> rowsArray;
353 0 : Intl()->SelectedRowIndices(&rowsArray);
354 :
355 0 : *aRowsArraySize = rowsArray.Length();
356 0 : *aRowsArray = static_cast<int32_t*>
357 0 : (moz_xmalloc(*aRowsArraySize * sizeof(int32_t)));
358 0 : memcpy(*aRowsArray, rowsArray.Elements(),
359 0 : *aRowsArraySize * sizeof(int32_t));
360 :
361 0 : return NS_OK;
362 : }
363 :
364 : NS_IMETHODIMP
365 0 : xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx)
366 : {
367 0 : NS_ENSURE_ARG_POINTER(aColIdx);
368 0 : *aColIdx = -1;
369 :
370 0 : if (!Intl())
371 0 : return NS_ERROR_FAILURE;
372 :
373 0 : if (aCellIdx < 0 ||
374 0 : static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
375 0 : return NS_ERROR_INVALID_ARG;
376 :
377 0 : *aColIdx = Intl()->ColIndexAt(aCellIdx);
378 0 : return NS_OK;
379 : }
380 :
381 : NS_IMETHODIMP
382 0 : xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx)
383 : {
384 0 : NS_ENSURE_ARG_POINTER(aRowIdx);
385 0 : *aRowIdx = -1;
386 :
387 0 : if (!Intl())
388 0 : return NS_ERROR_FAILURE;
389 :
390 0 : if (aCellIdx < 0 ||
391 0 : static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
392 0 : return NS_ERROR_INVALID_ARG;
393 :
394 0 : *aRowIdx = Intl()->RowIndexAt(aCellIdx);
395 0 : return NS_OK;
396 : }
397 :
398 : NS_IMETHODIMP
399 0 : xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,
400 : int32_t* aColIdx)
401 : {
402 0 : NS_ENSURE_ARG_POINTER(aRowIdx);
403 0 : *aRowIdx = -1;
404 0 : NS_ENSURE_ARG_POINTER(aColIdx);
405 0 : *aColIdx = -1;
406 :
407 0 : if (!Intl())
408 0 : return NS_ERROR_FAILURE;
409 :
410 0 : if (aCellIdx < 0 ||
411 0 : static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
412 0 : return NS_ERROR_INVALID_ARG;
413 :
414 0 : Intl()->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
415 0 : return NS_OK;
416 : }
417 :
418 : NS_IMETHODIMP
419 0 : xpcAccessibleTable::GetSummary(nsAString& aSummary)
420 : {
421 0 : if (!Intl())
422 0 : return NS_ERROR_FAILURE;
423 :
424 0 : nsAutoString summary;
425 0 : Intl()->Summary(summary);
426 0 : aSummary.Assign(summary);
427 :
428 0 : return NS_OK;
429 : }
430 :
431 : NS_IMETHODIMP
432 0 : xpcAccessibleTable::IsProbablyForLayout(bool* aResult)
433 : {
434 0 : NS_ENSURE_ARG_POINTER(aResult);
435 0 : *aResult = false;
436 0 : if (!Intl())
437 0 : return NS_ERROR_FAILURE;
438 :
439 0 : *aResult = Intl()->IsProbablyLayoutTable();
440 0 : return NS_OK;
441 : }
442 :
443 : NS_IMETHODIMP
444 0 : xpcAccessibleTable::SelectColumn(int32_t aColIdx)
445 : {
446 0 : if (!Intl())
447 0 : return NS_ERROR_FAILURE;
448 :
449 0 : if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
450 0 : return NS_ERROR_INVALID_ARG;
451 :
452 0 : Intl()->SelectCol(aColIdx);
453 0 : return NS_OK;
454 : }
455 :
456 : NS_IMETHODIMP
457 0 : xpcAccessibleTable::SelectRow(int32_t aRowIdx)
458 : {
459 0 : if (!Intl())
460 0 : return NS_ERROR_FAILURE;
461 :
462 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
463 0 : return NS_ERROR_INVALID_ARG;
464 :
465 0 : Intl()->SelectRow(aRowIdx);
466 0 : return NS_OK;
467 : }
468 :
469 : NS_IMETHODIMP
470 0 : xpcAccessibleTable::UnselectColumn(int32_t aColIdx)
471 : {
472 0 : if (!Intl())
473 0 : return NS_ERROR_FAILURE;
474 :
475 0 : if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
476 0 : return NS_ERROR_INVALID_ARG;
477 :
478 0 : Intl()->UnselectCol(aColIdx);
479 0 : return NS_OK;
480 : }
481 :
482 : NS_IMETHODIMP
483 0 : xpcAccessibleTable::UnselectRow(int32_t aRowIdx)
484 : {
485 0 : if (!Intl())
486 0 : return NS_ERROR_FAILURE;
487 :
488 0 : if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
489 0 : return NS_ERROR_INVALID_ARG;
490 :
491 0 : Intl()->UnselectRow(aRowIdx);
492 0 : return NS_OK;
493 : }
|
