/src/mozilla-central/accessible/xpcom/xpcAccessibleTable.cpp

Source (jump to first uncovered line)
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "xpcAccessibleTable.h"

#include "Accessible.h"
#include "TableAccessible.h"
#include "xpcAccessibleDocument.h"

#include "nsIMutableArray.h"
#include "nsComponentManagerUtils.h"

using namespace mozilla::a11y;

static const uint32_t XPC_TABLE_DEFAULT_SIZE = 40;

////////////////////////////////////////////////////////////////////////////////
// nsISupports

NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTable,
                            xpcAccessibleGeneric,
                            nsIAccessibleTable)

////////////////////////////////////////////////////////////////////////////////
// nsIAccessibleTable

NS_IMETHODIMP
xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)
{
  NS_ENSURE_ARG_POINTER(aCaption);
  *aCaption = nullptr;
  if (!Intl())
    return NS_ERROR_FAILURE;

  NS_IF_ADDREF(*aCaption = ToXPC(Intl()->Caption()));
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount)
{
  NS_ENSURE_ARG_POINTER(aColumnCount);
  *aColumnCount = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  *aColumnCount = Intl()->ColCount();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetRowCount(int32_t* aRowCount)
{
  NS_ENSURE_ARG_POINTER(aRowCount);
  *aRowCount = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  *aRowCount = Intl()->RowCount();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,
                              nsIAccessible** aCell)
{
  NS_ENSURE_ARG_POINTER(aCell);
  *aCell = nullptr;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  NS_IF_ADDREF(*aCell = ToXPC(Intl()->CellAt(aRowIdx, aColIdx)));
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,
                                   int32_t* aCellIdx)
{
  NS_ENSURE_ARG_POINTER(aCellIdx);
  *aCellIdx = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aCellIdx = Intl()->CellIndexAt(aRowIdx, aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,
                                      int32_t* aColumnExtent)
{
  NS_ENSURE_ARG_POINTER(aColumnExtent);
  *aColumnExtent = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aColumnExtent = Intl()->ColExtentAt(aRowIdx, aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,
                                   int32_t* aRowExtent)
{
  NS_ENSURE_ARG_POINTER(aRowExtent);
  *aRowExtent = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aRowExtent = Intl()->RowExtentAt(aRowIdx, aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,
                                         nsAString& aDescription)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  nsAutoString description;
  Intl()->ColDescription(aColIdx, description);
  aDescription.Assign(description);

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetRowDescription(int32_t aRowIdx, nsAString& aDescription)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  nsAutoString description;
  Intl()->RowDescription(aRowIdx, description);
  aDescription.Assign(description);

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected)
{
  NS_ENSURE_ARG_POINTER(aIsSelected);
  *aIsSelected = false;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aIsSelected = Intl()->IsColSelected(aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected)
{
  NS_ENSURE_ARG_POINTER(aIsSelected);
  *aIsSelected = false;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
    return NS_ERROR_INVALID_ARG;

  *aIsSelected = Intl()->IsRowSelected(aRowIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,
                                   bool* aIsSelected)
{
  NS_ENSURE_ARG_POINTER(aIsSelected);
  *aIsSelected = false;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aIsSelected = Intl()->IsCellSelected(aRowIdx, aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount)
{
  NS_ENSURE_ARG_POINTER(aSelectedCellCount);
  *aSelectedCellCount = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  *aSelectedCellCount = Intl()->SelectedCellCount();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount)
{
  NS_ENSURE_ARG_POINTER(aSelectedColumnCount);
  *aSelectedColumnCount = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  *aSelectedColumnCount = Intl()->SelectedColCount();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount)
{
  NS_ENSURE_ARG_POINTER(aSelectedRowCount);
  *aSelectedRowCount = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  *aSelectedRowCount = Intl()->SelectedRowCount();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells)
{
  NS_ENSURE_ARG_POINTER(aSelectedCells);
  *aSelectedCells = nullptr;

  if (!Intl())
    return NS_ERROR_FAILURE;

  nsresult rv = NS_OK;
  nsCOMPtr<nsIMutableArray> selCells =
    do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  AutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;
  Intl()->SelectedCells(&cellsArray);

  uint32_t totalCount = cellsArray.Length();
  for (uint32_t idx = 0; idx < totalCount; idx++) {
    Accessible* cell = cellsArray.ElementAt(idx);
    selCells->AppendElement(static_cast<nsIAccessible*>(ToXPC(cell)));
  }

  NS_ADDREF(*aSelectedCells = selCells);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedCellIndices(uint32_t* aCellsArraySize,
                                           int32_t** aCellsArray)
{
  NS_ENSURE_ARG_POINTER(aCellsArraySize);
  *aCellsArraySize = 0;

  NS_ENSURE_ARG_POINTER(aCellsArray);
  *aCellsArray = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> cellsArray;
  Intl()->SelectedCellIndices(&cellsArray);

  *aCellsArraySize = cellsArray.Length();
  *aCellsArray = static_cast<int32_t*>
    (moz_xmalloc(*aCellsArraySize * sizeof(int32_t)));
  memcpy(*aCellsArray, cellsArray.Elements(),
    *aCellsArraySize * sizeof(int32_t));

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedColumnIndices(uint32_t* aColsArraySize,
                                             int32_t** aColsArray)
{
  NS_ENSURE_ARG_POINTER(aColsArraySize);
  *aColsArraySize = 0;

  NS_ENSURE_ARG_POINTER(aColsArray);
  *aColsArray = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> colsArray;
  Intl()->SelectedColIndices(&colsArray);

  *aColsArraySize = colsArray.Length();
  *aColsArray = static_cast<int32_t*>
    (moz_xmalloc(*aColsArraySize * sizeof(int32_t)));
  memcpy(*aColsArray, colsArray.Elements(),
    *aColsArraySize * sizeof(int32_t));

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSelectedRowIndices(uint32_t* aRowsArraySize,
                                          int32_t** aRowsArray)
{
  NS_ENSURE_ARG_POINTER(aRowsArraySize);
  *aRowsArraySize = 0;

  NS_ENSURE_ARG_POINTER(aRowsArray);
  *aRowsArray = 0;

  if (!Intl())
    return NS_ERROR_FAILURE;

  AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> rowsArray;
  Intl()->SelectedRowIndices(&rowsArray);

  *aRowsArraySize = rowsArray.Length();
  *aRowsArray = static_cast<int32_t*>
    (moz_xmalloc(*aRowsArraySize * sizeof(int32_t)));
  memcpy(*aRowsArray, rowsArray.Elements(),
    *aRowsArraySize * sizeof(int32_t));

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx)
{
  NS_ENSURE_ARG_POINTER(aColIdx);
  *aColIdx = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aCellIdx < 0 ||
      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aColIdx = Intl()->ColIndexAt(aCellIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx)
{
  NS_ENSURE_ARG_POINTER(aRowIdx);
  *aRowIdx = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aCellIdx < 0 ||
      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  *aRowIdx = Intl()->RowIndexAt(aCellIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,
                                             int32_t* aColIdx)
{
  NS_ENSURE_ARG_POINTER(aRowIdx);
  *aRowIdx = -1;
  NS_ENSURE_ARG_POINTER(aColIdx);
  *aColIdx = -1;

  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aCellIdx < 0 ||
      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  Intl()->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::GetSummary(nsAString& aSummary)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  nsAutoString summary;
  Intl()->Summary(summary);
  aSummary.Assign(summary);

  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::IsProbablyForLayout(bool* aResult)
{
  NS_ENSURE_ARG_POINTER(aResult);
  *aResult = false;
  if (!Intl())
    return NS_ERROR_FAILURE;

  *aResult = Intl()->IsProbablyLayoutTable();
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::SelectColumn(int32_t aColIdx)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  Intl()->SelectCol(aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::SelectRow(int32_t aRowIdx)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
    return NS_ERROR_INVALID_ARG;

  Intl()->SelectRow(aRowIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::UnselectColumn(int32_t aColIdx)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
    return NS_ERROR_INVALID_ARG;

  Intl()->UnselectCol(aColIdx);
  return NS_OK;
}

NS_IMETHODIMP
xpcAccessibleTable::UnselectRow(int32_t aRowIdx)
{
  if (!Intl())
    return NS_ERROR_FAILURE;

  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
    return NS_ERROR_INVALID_ARG;

  Intl()->UnselectRow(aRowIdx);
  return NS_OK;
}

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
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		NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTable,
24		xpcAccessibleGeneric,
25		nsIAccessibleTable)
26
27		////////////////////////////////////////////////////////////////////////////////
28		// nsIAccessibleTable
29
30		NS_IMETHODIMP
31		xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)
32	0	{
33	0	NS_ENSURE_ARG_POINTER(aCaption);
34	0	*aCaption = nullptr;
35	0	if (!Intl())
36	0	return NS_ERROR_FAILURE;
37	0
38	0	NS_IF_ADDREF(*aCaption = ToXPC(Intl()->Caption()));
39	0	return NS_OK;
40	0	}
41
42		NS_IMETHODIMP
43		xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount)
44	0	{
45	0	NS_ENSURE_ARG_POINTER(aColumnCount);
46	0	*aColumnCount = 0;
47	0
48	0	if (!Intl())
49	0	return NS_ERROR_FAILURE;
50	0
51	0	*aColumnCount = Intl()->ColCount();
52	0	return NS_OK;
53	0	}
54
55		NS_IMETHODIMP
56		xpcAccessibleTable::GetRowCount(int32_t* aRowCount)
57	0	{
58	0	NS_ENSURE_ARG_POINTER(aRowCount);
59	0	*aRowCount = 0;
60	0
61	0	if (!Intl())
62	0	return NS_ERROR_FAILURE;
63	0
64	0	*aRowCount = Intl()->RowCount();
65	0	return NS_OK;
66	0	}
67
68		NS_IMETHODIMP
69		xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,
70		nsIAccessible** aCell)
71	0	{
72	0	NS_ENSURE_ARG_POINTER(aCell);
73	0	*aCell = nullptr;
74	0
75	0	if (!Intl())
76	0	return NS_ERROR_FAILURE;
77	0
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	0
82	0	NS_IF_ADDREF(*aCell = ToXPC(Intl()->CellAt(aRowIdx, aColIdx)));
83	0	return NS_OK;
84	0	}
85
86		NS_IMETHODIMP
87		xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,
88		int32_t* aCellIdx)
89	0	{
90	0	NS_ENSURE_ARG_POINTER(aCellIdx);
91	0	*aCellIdx = -1;
92	0
93	0	if (!Intl())
94	0	return NS_ERROR_FAILURE;
95	0
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	0
100	0	*aCellIdx = Intl()->CellIndexAt(aRowIdx, aColIdx);
101	0	return NS_OK;
102	0	}
103
104		NS_IMETHODIMP
105		xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,
106		int32_t* aColumnExtent)
107	0	{
108	0	NS_ENSURE_ARG_POINTER(aColumnExtent);
109	0	*aColumnExtent = -1;
110	0
111	0	if (!Intl())
112	0	return NS_ERROR_FAILURE;
113	0
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	0
118	0	*aColumnExtent = Intl()->ColExtentAt(aRowIdx, aColIdx);
119	0	return NS_OK;
120	0	}
121
122		NS_IMETHODIMP
123		xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,
124		int32_t* aRowExtent)
125	0	{
126	0	NS_ENSURE_ARG_POINTER(aRowExtent);
127	0	*aRowExtent = -1;
128	0
129	0	if (!Intl())
130	0	return NS_ERROR_FAILURE;
131	0
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	0
136	0	*aRowExtent = Intl()->RowExtentAt(aRowIdx, aColIdx);
137	0	return NS_OK;
138	0	}
139
140		NS_IMETHODIMP
141		xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,
142		nsAString& aDescription)
143	0	{
144	0	if (!Intl())
145	0	return NS_ERROR_FAILURE;
146	0
147	0	if (aColIdx < 0 \|\| static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
148	0	return NS_ERROR_INVALID_ARG;
149	0
150	0	nsAutoString description;
151	0	Intl()->ColDescription(aColIdx, description);
152	0	aDescription.Assign(description);
153	0
154	0	return NS_OK;
155	0	}
156
157		NS_IMETHODIMP
158		xpcAccessibleTable::GetRowDescription(int32_t aRowIdx, nsAString& aDescription)
159	0	{
160	0	if (!Intl())
161	0	return NS_ERROR_FAILURE;
162	0
163	0	if (aRowIdx < 0 \|\| static_cast<uint32_t>(aRowIdx) >= Intl()->ColCount())
164	0	return NS_ERROR_INVALID_ARG;
165	0
166	0	nsAutoString description;
167	0	Intl()->RowDescription(aRowIdx, description);
168	0	aDescription.Assign(description);
169	0
170	0	return NS_OK;
171	0	}
172
173		NS_IMETHODIMP
174		xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected)
175	0	{
176	0	NS_ENSURE_ARG_POINTER(aIsSelected);
177	0	*aIsSelected = false;
178	0
179	0	if (!Intl())
180	0	return NS_ERROR_FAILURE;
181	0
182	0	if (aColIdx < 0 \|\| static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
183	0	return NS_ERROR_INVALID_ARG;
184	0
185	0	*aIsSelected = Intl()->IsColSelected(aColIdx);
186	0	return NS_OK;
187	0	}
188
189		NS_IMETHODIMP
190		xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected)
191	0	{
192	0	NS_ENSURE_ARG_POINTER(aIsSelected);
193	0	*aIsSelected = false;
194	0
195	0	if (!Intl())
196	0	return NS_ERROR_FAILURE;
197	0
198	0	if (aRowIdx < 0 \|\| static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
199	0	return NS_ERROR_INVALID_ARG;
200	0
201	0	*aIsSelected = Intl()->IsRowSelected(aRowIdx);
202	0	return NS_OK;
203	0	}
204
205		NS_IMETHODIMP
206		xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,
207		bool* aIsSelected)
208	0	{
209	0	NS_ENSURE_ARG_POINTER(aIsSelected);
210	0	*aIsSelected = false;
211	0
212	0	if (!Intl())
213	0	return NS_ERROR_FAILURE;
214	0
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	0
219	0	*aIsSelected = Intl()->IsCellSelected(aRowIdx, aColIdx);
220	0	return NS_OK;
221	0	}
222
223		NS_IMETHODIMP
224		xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount)
225	0	{
226	0	NS_ENSURE_ARG_POINTER(aSelectedCellCount);
227	0	*aSelectedCellCount = 0;
228	0
229	0	if (!Intl())
230	0	return NS_ERROR_FAILURE;
231	0
232	0	*aSelectedCellCount = Intl()->SelectedCellCount();
233	0	return NS_OK;
234	0	}
235
236		NS_IMETHODIMP
237		xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount)
238	0	{
239	0	NS_ENSURE_ARG_POINTER(aSelectedColumnCount);
240	0	*aSelectedColumnCount = 0;
241	0
242	0	if (!Intl())
243	0	return NS_ERROR_FAILURE;
244	0
245	0	*aSelectedColumnCount = Intl()->SelectedColCount();
246	0	return NS_OK;
247	0	}
248
249		NS_IMETHODIMP
250		xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount)
251	0	{
252	0	NS_ENSURE_ARG_POINTER(aSelectedRowCount);
253	0	*aSelectedRowCount = 0;
254	0
255	0	if (!Intl())
256	0	return NS_ERROR_FAILURE;
257	0
258	0	*aSelectedRowCount = Intl()->SelectedRowCount();
259	0	return NS_OK;
260	0	}
261
262		NS_IMETHODIMP
263		xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells)
264	0	{
265	0	NS_ENSURE_ARG_POINTER(aSelectedCells);
266	0	*aSelectedCells = nullptr;
267	0
268	0	if (!Intl())
269	0	return NS_ERROR_FAILURE;
270	0
271	0	nsresult rv = NS_OK;
272	0	nsCOMPtr<nsIMutableArray> selCells =
273	0	do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
274	0	NS_ENSURE_SUCCESS(rv, rv);
275	0
276	0	AutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;
277	0	Intl()->SelectedCells(&cellsArray);
278	0
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)));
283	0	}
284	0
285	0	NS_ADDREF(*aSelectedCells = selCells);
286	0	return NS_OK;
287	0	}
288
289		NS_IMETHODIMP
290		xpcAccessibleTable::GetSelectedCellIndices(uint32_t* aCellsArraySize,
291		int32_t** aCellsArray)
292	0	{
293	0	NS_ENSURE_ARG_POINTER(aCellsArraySize);
294	0	*aCellsArraySize = 0;
295	0
296	0	NS_ENSURE_ARG_POINTER(aCellsArray);
297	0	*aCellsArray = 0;
298	0
299	0	if (!Intl())
300	0	return NS_ERROR_FAILURE;
301	0
302	0	AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> cellsArray;
303	0	Intl()->SelectedCellIndices(&cellsArray);
304	0
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	0
311	0	return NS_OK;
312	0	}
313
314		NS_IMETHODIMP
315		xpcAccessibleTable::GetSelectedColumnIndices(uint32_t* aColsArraySize,
316		int32_t** aColsArray)
317	0	{
318	0	NS_ENSURE_ARG_POINTER(aColsArraySize);
319	0	*aColsArraySize = 0;
320	0
321	0	NS_ENSURE_ARG_POINTER(aColsArray);
322	0	*aColsArray = 0;
323	0
324	0	if (!Intl())
325	0	return NS_ERROR_FAILURE;
326	0
327	0	AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> colsArray;
328	0	Intl()->SelectedColIndices(&colsArray);
329	0
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	0
336	0	return NS_OK;
337	0	}
338
339		NS_IMETHODIMP
340		xpcAccessibleTable::GetSelectedRowIndices(uint32_t* aRowsArraySize,
341		int32_t** aRowsArray)
342	0	{
343	0	NS_ENSURE_ARG_POINTER(aRowsArraySize);
344	0	*aRowsArraySize = 0;
345	0
346	0	NS_ENSURE_ARG_POINTER(aRowsArray);
347	0	*aRowsArray = 0;
348	0
349	0	if (!Intl())
350	0	return NS_ERROR_FAILURE;
351	0
352	0	AutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> rowsArray;
353	0	Intl()->SelectedRowIndices(&rowsArray);
354	0
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	0
361	0	return NS_OK;
362	0	}
363
364		NS_IMETHODIMP
365		xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx)
366	0	{
367	0	NS_ENSURE_ARG_POINTER(aColIdx);
368	0	*aColIdx = -1;
369	0
370	0	if (!Intl())
371	0	return NS_ERROR_FAILURE;
372	0
373	0	if (aCellIdx < 0 \|\|
374	0	static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
375	0	return NS_ERROR_INVALID_ARG;
376	0
377	0	*aColIdx = Intl()->ColIndexAt(aCellIdx);
378	0	return NS_OK;
379	0	}
380
381		NS_IMETHODIMP
382		xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx)
383	0	{
384	0	NS_ENSURE_ARG_POINTER(aRowIdx);
385	0	*aRowIdx = -1;
386	0
387	0	if (!Intl())
388	0	return NS_ERROR_FAILURE;
389	0
390	0	if (aCellIdx < 0 \|\|
391	0	static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
392	0	return NS_ERROR_INVALID_ARG;
393	0
394	0	*aRowIdx = Intl()->RowIndexAt(aCellIdx);
395	0	return NS_OK;
396	0	}
397
398		NS_IMETHODIMP
399		xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,
400		int32_t* aColIdx)
401	0	{
402	0	NS_ENSURE_ARG_POINTER(aRowIdx);
403	0	*aRowIdx = -1;
404	0	NS_ENSURE_ARG_POINTER(aColIdx);
405	0	*aColIdx = -1;
406	0
407	0	if (!Intl())
408	0	return NS_ERROR_FAILURE;
409	0
410	0	if (aCellIdx < 0 \|\|
411	0	static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
412	0	return NS_ERROR_INVALID_ARG;
413	0
414	0	Intl()->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
415	0	return NS_OK;
416	0	}
417
418		NS_IMETHODIMP
419		xpcAccessibleTable::GetSummary(nsAString& aSummary)
420	0	{
421	0	if (!Intl())
422	0	return NS_ERROR_FAILURE;
423	0
424	0	nsAutoString summary;
425	0	Intl()->Summary(summary);
426	0	aSummary.Assign(summary);
427	0
428	0	return NS_OK;
429	0	}
430
431		NS_IMETHODIMP
432		xpcAccessibleTable::IsProbablyForLayout(bool* aResult)
433	0	{
434	0	NS_ENSURE_ARG_POINTER(aResult);
435	0	*aResult = false;
436	0	if (!Intl())
437	0	return NS_ERROR_FAILURE;
438	0
439	0	*aResult = Intl()->IsProbablyLayoutTable();
440	0	return NS_OK;
441	0	}
442
443		NS_IMETHODIMP
444		xpcAccessibleTable::SelectColumn(int32_t aColIdx)
445	0	{
446	0	if (!Intl())
447	0	return NS_ERROR_FAILURE;
448	0
449	0	if (aColIdx < 0 \|\| static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
450	0	return NS_ERROR_INVALID_ARG;
451	0
452	0	Intl()->SelectCol(aColIdx);
453	0	return NS_OK;
454	0	}
455
456		NS_IMETHODIMP
457		xpcAccessibleTable::SelectRow(int32_t aRowIdx)
458	0	{
459	0	if (!Intl())
460	0	return NS_ERROR_FAILURE;
461	0
462	0	if (aRowIdx < 0 \|\| static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
463	0	return NS_ERROR_INVALID_ARG;
464	0
465	0	Intl()->SelectRow(aRowIdx);
466	0	return NS_OK;
467	0	}
468
469		NS_IMETHODIMP
470		xpcAccessibleTable::UnselectColumn(int32_t aColIdx)
471	0	{
472	0	if (!Intl())
473	0	return NS_ERROR_FAILURE;
474	0
475	0	if (aColIdx < 0 \|\| static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
476	0	return NS_ERROR_INVALID_ARG;
477	0
478	0	Intl()->UnselectCol(aColIdx);
479	0	return NS_OK;
480	0	}
481
482		NS_IMETHODIMP
483		xpcAccessibleTable::UnselectRow(int32_t aRowIdx)
484	0	{
485	0	if (!Intl())
486	0	return NS_ERROR_FAILURE;
487	0
488	0	if (aRowIdx < 0 \|\| static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
489	0	return NS_ERROR_INVALID_ARG;
490	0
491	0	Intl()->UnselectRow(aRowIdx);
492	0	return NS_OK;
493	0	}