accessible/xpcom/xpcAccessibleTable.cpp

   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 "mozilla/a11y/TableAccessible.h"
  10
  11 #include "nsIMutableArray.h"
  12 #include "nsComponentManagerUtils.h"
  13 #include "xpcAccessibleDocument.h"
  14
  15 using namespace mozilla::a11y;
  16
  17 static const uint32_t XPC_TABLE_DEFAULT_SIZE = 40;
  18
  19 ////////////////////////////////////////////////////////////////////////////////
  20 // nsISupports
  21
  22 NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTable, xpcAccessibleHyperText,
  23                             nsIAccessibleTable)
  24
  25 ////////////////////////////////////////////////////////////////////////////////
  26 // nsIAccessibleTable
  27
  28 NS_IMETHODIMP
  29 xpcAccessibleTable::GetCaption(nsIAccessible** aCaption) {
  30   NS_ENSURE_ARG_POINTER(aCaption);
  31   *aCaption = nullptr;
  32   if (!Intl()) return NS_ERROR_FAILURE;
  33
  34   NS_IF_ADDREF(*aCaption = ToXPC(Intl()->Caption()));
  35   return NS_OK;
  36 }
  37
  38 NS_IMETHODIMP
  39 xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount) {
  40   NS_ENSURE_ARG_POINTER(aColumnCount);
  41   *aColumnCount = 0;
  42
  43   if (!Intl()) return NS_ERROR_FAILURE;
  44
  45   *aColumnCount = Intl()->ColCount();
  46   return NS_OK;
  47 }
  48
  49 NS_IMETHODIMP
  50 xpcAccessibleTable::GetRowCount(int32_t* aRowCount) {
  51   NS_ENSURE_ARG_POINTER(aRowCount);
  52   *aRowCount = 0;
  53
  54   if (!Intl()) return NS_ERROR_FAILURE;
  55
  56   *aRowCount = Intl()->RowCount();
  57   return NS_OK;
  58 }
  59
  60 NS_IMETHODIMP
  61 xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,
  62                               nsIAccessible** aCell) {
  63   NS_ENSURE_ARG_POINTER(aCell);
  64   *aCell = nullptr;
  65
  66   if (!Intl()) return NS_ERROR_FAILURE;
  67
  68   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
  69       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
  70     return NS_ERROR_INVALID_ARG;
  71   }
  72
  73   NS_IF_ADDREF(*aCell = ToXPC(Intl()->CellAt(aRowIdx, aColIdx)));
  74   return NS_OK;
  75 }
  76
  77 NS_IMETHODIMP
  78 xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,
  79                                    int32_t* aCellIdx) {
  80   NS_ENSURE_ARG_POINTER(aCellIdx);
  81   *aCellIdx = -1;
  82
  83   if (!Intl()) return NS_ERROR_FAILURE;
  84
  85   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
  86       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
  87     return NS_ERROR_INVALID_ARG;
  88   }
  89
  90   *aCellIdx = Intl()->CellIndexAt(aRowIdx, aColIdx);
  91   return NS_OK;
  92 }
  93
  94 NS_IMETHODIMP
  95 xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,
  96                                       int32_t* aColumnExtent) {
  97   NS_ENSURE_ARG_POINTER(aColumnExtent);
  98   *aColumnExtent = -1;
  99
 100   if (!Intl()) return NS_ERROR_FAILURE;
 101
 102   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
 103       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
 104     return NS_ERROR_INVALID_ARG;
 105   }
 106
 107   *aColumnExtent = Intl()->ColExtentAt(aRowIdx, aColIdx);
 108   return NS_OK;
 109 }
 110
 111 NS_IMETHODIMP
 112 xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,
 113                                    int32_t* aRowExtent) {
 114   NS_ENSURE_ARG_POINTER(aRowExtent);
 115   *aRowExtent = -1;
 116
 117   if (!Intl()) return NS_ERROR_FAILURE;
 118
 119   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
 120       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
 121     return NS_ERROR_INVALID_ARG;
 122   }
 123
 124   *aRowExtent = Intl()->RowExtentAt(aRowIdx, aColIdx);
 125   return NS_OK;
 126 }
 127
 128 NS_IMETHODIMP
 129 xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,
 130                                          nsAString& aDescription) {
 131   if (!Intl()) return NS_ERROR_FAILURE;
 132
 133   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
 134     return NS_ERROR_INVALID_ARG;
 135   }
 136
 137   nsAutoString description;
 138   Intl()->ColDescription(aColIdx, description);
 139   aDescription.Assign(description);
 140
 141   return NS_OK;
 142 }
 143
 144 NS_IMETHODIMP
 145 xpcAccessibleTable::GetRowDescription(int32_t aRowIdx,
 146                                       nsAString& aDescription) {
 147   if (!Intl()) return NS_ERROR_FAILURE;
 148
 149   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->ColCount()) {
 150     return NS_ERROR_INVALID_ARG;
 151   }
 152
 153   nsAutoString description;
 154   Intl()->RowDescription(aRowIdx, description);
 155   aDescription.Assign(description);
 156
 157   return NS_OK;
 158 }
 159
 160 NS_IMETHODIMP
 161 xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected) {
 162   NS_ENSURE_ARG_POINTER(aIsSelected);
 163   *aIsSelected = false;
 164
 165   if (!Intl()) return NS_ERROR_FAILURE;
 166
 167   if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
 168     return NS_ERROR_INVALID_ARG;
 169   }
 170
 171   *aIsSelected = Intl()->IsColSelected(aColIdx);
 172   return NS_OK;
 173 }
 174
 175 NS_IMETHODIMP
 176 xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected) {
 177   NS_ENSURE_ARG_POINTER(aIsSelected);
 178   *aIsSelected = false;
 179
 180   if (!Intl()) return NS_ERROR_FAILURE;
 181
 182   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount()) {
 183     return NS_ERROR_INVALID_ARG;
 184   }
 185
 186   *aIsSelected = Intl()->IsRowSelected(aRowIdx);
 187   return NS_OK;
 188 }
 189
 190 NS_IMETHODIMP
 191 xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,
 192                                    bool* aIsSelected) {
 193   NS_ENSURE_ARG_POINTER(aIsSelected);
 194   *aIsSelected = false;
 195
 196   if (!Intl()) return NS_ERROR_FAILURE;
 197
 198   if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
 199       aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount()) {
 200     return NS_ERROR_INVALID_ARG;
 201   }
 202
 203   *aIsSelected = Intl()->IsCellSelected(aRowIdx, aColIdx);
 204   return NS_OK;
 205 }
 206
 207 NS_IMETHODIMP
 208 xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount) {
 209   NS_ENSURE_ARG_POINTER(aSelectedCellCount);
 210   *aSelectedCellCount = 0;
 211
 212   if (!Intl()) return NS_ERROR_FAILURE;
 213
 214   *aSelectedCellCount = Intl()->SelectedCellCount();
 215   return NS_OK;
 216 }
 217
 218 NS_IMETHODIMP
 219 xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount) {
 220   NS_ENSURE_ARG_POINTER(aSelectedColumnCount);
 221   *aSelectedColumnCount = 0;
 222
 223   if (!Intl()) return NS_ERROR_FAILURE;
 224
 225   *aSelectedColumnCount = Intl()->SelectedColCount();
 226   return NS_OK;
 227 }
 228
 229 NS_IMETHODIMP
 230 xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount) {
 231   NS_ENSURE_ARG_POINTER(aSelectedRowCount);
 232   *aSelectedRowCount = 0;
 233
 234   if (!Intl()) return NS_ERROR_FAILURE;
 235
 236   *aSelectedRowCount = Intl()->SelectedRowCount();
 237   return NS_OK;
 238 }
 239
 240 NS_IMETHODIMP
 241 xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells) {
 242   NS_ENSURE_ARG_POINTER(aSelectedCells);
 243   *aSelectedCells = nullptr;
 244
 245   if (!Intl()) return NS_ERROR_FAILURE;
 246
 247   nsresult rv = NS_OK;
 248   nsCOMPtr<nsIMutableArray> selCells =
 249       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 250   NS_ENSURE_SUCCESS(rv, rv);
 251
 252   AutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;
 253   Intl()->SelectedCells(&cellsArray);
 254
 255   uint32_t totalCount = cellsArray.Length();
 256   for (uint32_t idx = 0; idx < totalCount; idx++) {
 257     Accessible* cell = cellsArray.ElementAt(idx);
 258     selCells->AppendElement(static_cast<nsIAccessible*>(ToXPC(cell)));
 259   }
 260
 261   NS_ADDREF(*aSelectedCells = selCells);
 262   return NS_OK;
 263 }
 264
 265 NS_IMETHODIMP
 266 xpcAccessibleTable::GetSelectedCellIndices(nsTArray<uint32_t>& aCellsArray) {
 267   if (!Intl()) return NS_ERROR_FAILURE;
 268
 269   Intl()->SelectedCellIndices(&aCellsArray);
 270
 271   return NS_OK;
 272 }
 273
 274 NS_IMETHODIMP
 275 xpcAccessibleTable::GetSelectedColumnIndices(nsTArray<uint32_t>& aColsArray) {
 276   if (!Intl()) return NS_ERROR_FAILURE;
 277
 278   Intl()->SelectedColIndices(&aColsArray);
 279
 280   return NS_OK;
 281 }
 282
 283 NS_IMETHODIMP
 284 xpcAccessibleTable::GetSelectedRowIndices(nsTArray<uint32_t>& aRowsArray) {
 285   if (!Intl()) return NS_ERROR_FAILURE;
 286
 287   Intl()->SelectedRowIndices(&aRowsArray);
 288
 289   return NS_OK;
 290 }
 291
 292 NS_IMETHODIMP
 293 xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx) {
 294   NS_ENSURE_ARG_POINTER(aColIdx);
 295   *aColIdx = -1;
 296
 297   if (!Intl()) return NS_ERROR_FAILURE;
 298
 299   if (aCellIdx < 0 || static_cast<uint32_t>(aCellIdx) >=
 300                           Intl()->RowCount() * Intl()->ColCount()) {
 301     return NS_ERROR_INVALID_ARG;
 302   }
 303
 304   *aColIdx = Intl()->ColIndexAt(aCellIdx);
 305   return NS_OK;
 306 }
 307
 308 NS_IMETHODIMP
 309 xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx) {
 310   NS_ENSURE_ARG_POINTER(aRowIdx);
 311   *aRowIdx = -1;
 312
 313   if (!Intl()) return NS_ERROR_FAILURE;
 314
 315   if (aCellIdx < 0 || static_cast<uint32_t>(aCellIdx) >=
 316                           Intl()->RowCount() * Intl()->ColCount()) {
 317     return NS_ERROR_INVALID_ARG;
 318   }
 319
 320   *aRowIdx = Intl()->RowIndexAt(aCellIdx);
 321   return NS_OK;
 322 }
 323
 324 NS_IMETHODIMP
 325 xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,
 326                                              int32_t* aColIdx) {
 327   NS_ENSURE_ARG_POINTER(aRowIdx);
 328   *aRowIdx = -1;
 329   NS_ENSURE_ARG_POINTER(aColIdx);
 330   *aColIdx = -1;
 331
 332   if (!Intl()) return NS_ERROR_FAILURE;
 333
 334   if (aCellIdx < 0 || static_cast<uint32_t>(aCellIdx) >=
 335                           Intl()->RowCount() * Intl()->ColCount()) {
 336     return NS_ERROR_INVALID_ARG;
 337   }
 338
 339   Intl()->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
 340   return NS_OK;
 341 }
 342
 343 NS_IMETHODIMP
 344 xpcAccessibleTable::GetSummary(nsAString& aSummary) {
 345   if (!Intl()) return NS_ERROR_FAILURE;
 346
 347   nsAutoString summary;
 348   Intl()->Summary(summary);
 349   aSummary.Assign(summary);
 350
 351   return NS_OK;
 352 }
 353
 354 NS_IMETHODIMP
 355 xpcAccessibleTable::IsProbablyForLayout(bool* aResult) {
 356   NS_ENSURE_ARG_POINTER(aResult);
 357   *aResult = false;
 358   if (!Intl()) return NS_ERROR_FAILURE;
 359
 360   *aResult = Intl()->IsProbablyLayoutTable();
 361   return NS_OK;
 362 }