accessible/src/msaa/CAccessibleTable.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:expandtab:shiftwidth=2:tabstop=2:
   3  */
   4 /* ***** BEGIN LICENSE BLOCK *****
   5  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version
   8  * 1.1 (the "License"); you may not use this file except in compliance with
   9  * the License. You may obtain a copy of the License at
  10  * http://www.mozilla.org/MPL/
  11  *
  12  * Software distributed under the License is distributed on an "AS IS" basis,
  13  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14  * for the specific language governing rights and limitations under the
  15  * License.
  16  *
  17  * The Original Code is mozilla.org code.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Mozilla Foundation.
  21  * Portions created by the Initial Developer are Copyright (C) 2007
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *   Alexander Surkov <surkov.alexander@gmail.com> (original author)
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #include "CAccessibleTable.h"
  42
  43 #include "Accessible2.h"
  44 #include "AccessibleTable_i.c"
  45
  46 #include "nsIAccessible.h"
  47 #include "nsIAccessibleTable.h"
  48 #include "nsIWinAccessNode.h"
  49 #include "nsAccessNodeWrap.h"
  50
  51 #include "nsCOMPtr.h"
  52 #include "nsString.h"
  53
  54 #define CANT_QUERY_ASSERTION_MSG \
  55 "Subclass of CAccessibleTable doesn't implement nsIAccessibleTable"\
  56
  57 // IUnknown
  58
  59 STDMETHODIMP
  60 CAccessibleTable::QueryInterface(REFIID iid, void** ppv)
  61 {
  62   *ppv = NULL;
  63
  64   if (IID_IAccessibleTable == iid) {
  65     *ppv = static_cast<IAccessibleTable*>(this);
  66     (reinterpret_cast<IUnknown*>(*ppv))->AddRef();
  67     return S_OK;
  68   }
  69
  70   return E_NOINTERFACE;
  71 }
  72
  73 // IAccessibleTable
  74
  75 STDMETHODIMP
  76 CAccessibleTable::get_accessibleAt(long aRow, long aColumn,
  77                                    IUnknown **aAccessible)
  78 {
  79 __try {
  80   *aAccessible = NULL;
  81
  82   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
  83   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
  84   if (!tableAcc)
  85     return E_FAIL;
  86
  87   nsCOMPtr<nsIAccessible> cell;
  88   nsresult rv = tableAcc->CellRefAt(aRow, aColumn, getter_AddRefs(cell));
  89   if (NS_FAILED(rv))
  90     return GetHRESULT(rv);
  91
  92   nsCOMPtr<nsIWinAccessNode> winAccessNode(do_QueryInterface(cell));
  93   if (!winAccessNode)
  94     return E_FAIL;
  95
  96   void *instancePtr = NULL;
  97   rv = winAccessNode->QueryNativeInterface(IID_IAccessible2, &instancePtr);
  98   if (NS_FAILED(rv))
  99     return E_FAIL;
 100
 101   *aAccessible = static_cast<IUnknown*>(instancePtr);
 102   return S_OK;
 103
 104 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 105   return E_FAIL;
 106 }
 107
 108 STDMETHODIMP
 109 CAccessibleTable::get_caption(IUnknown **aAccessible)
 110 {
 111 __try {
 112   *aAccessible = NULL;
 113
 114   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 115   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 116   if (!tableAcc)
 117     return E_FAIL;
 118
 119   nsCOMPtr<nsIAccessible> caption;
 120   nsresult rv = tableAcc->GetCaption(getter_AddRefs(caption));
 121   if (NS_FAILED(rv))
 122     return GetHRESULT(rv);
 123
 124   if (!caption)
 125     return S_FALSE;
 126
 127   nsCOMPtr<nsIWinAccessNode> winAccessNode(do_QueryInterface(caption));
 128   if (!winAccessNode)
 129     return E_FAIL;
 130
 131   void *instancePtr = NULL;
 132   rv = winAccessNode->QueryNativeInterface(IID_IAccessible2, &instancePtr);
 133   if (NS_FAILED(rv))
 134     return E_FAIL;
 135
 136   *aAccessible = static_cast<IUnknown*>(instancePtr);
 137   return S_OK;
 138
 139 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 140   return E_FAIL;
 141 }
 142
 143 STDMETHODIMP
 144 CAccessibleTable::get_childIndex(long aRowIndex, long aColumnIndex,
 145                                  long *aChildIndex)
 146 {
 147 __try {
 148   *aChildIndex = 0;
 149
 150   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 151   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 152   if (!tableAcc)
 153     return E_FAIL;
 154
 155   PRInt32 childIndex = 0;
 156   nsresult rv = tableAcc->GetIndexAt(aRowIndex, aColumnIndex, &childIndex);
 157   if (NS_FAILED(rv))
 158     return GetHRESULT(rv);
 159
 160   *aChildIndex = childIndex;
 161   return S_OK;
 162
 163 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 164   return E_FAIL;
 165 }
 166
 167 STDMETHODIMP
 168 CAccessibleTable::get_columnDescription(long aColumn, BSTR *aDescription)
 169 {
 170 __try {
 171   *aDescription = NULL;
 172
 173   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 174   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 175   if (!tableAcc)
 176     return E_FAIL;
 177
 178   nsAutoString descr;
 179   nsresult rv = tableAcc->GetColumnDescription (aColumn, descr);
 180   if (NS_FAILED(rv))
 181     return GetHRESULT(rv);
 182
 183   if (descr.IsEmpty())
 184     return S_FALSE;
 185
 186   *aDescription = ::SysAllocStringLen(descr.get(), descr.Length());
 187   return *aDescription ? S_OK : E_OUTOFMEMORY;
 188
 189 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 190   return E_FAIL;
 191 }
 192
 193 STDMETHODIMP
 194 CAccessibleTable::get_columnExtentAt(long aRow, long aColumn,
 195                                      long *nColumnsSpanned)
 196 {
 197 __try {
 198   *nColumnsSpanned = 0;
 199
 200   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 201   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 202   if (!tableAcc)
 203     return E_FAIL;
 204
 205   PRInt32 columnsSpanned = 0;
 206   nsresult rv = tableAcc->GetColumnExtentAt(aRow, aColumn, &columnsSpanned);
 207   if (NS_FAILED(rv))
 208     return GetHRESULT(rv);
 209
 210   *nColumnsSpanned = columnsSpanned;
 211   return S_OK;
 212
 213 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 214   return E_FAIL;
 215 }
 216
 217 STDMETHODIMP
 218 CAccessibleTable::get_columnHeader(IAccessibleTable **aAccessibleTable,
 219                                    long *aStartingRowIndex)
 220 {
 221 __try {
 222   *aAccessibleTable = NULL;
 223
 224   // XXX: starting row index is always 0.
 225   *aStartingRowIndex = 0;
 226
 227   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 228   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 229   if (!tableAcc)
 230     return E_FAIL;
 231
 232   nsCOMPtr<nsIAccessibleTable> header;
 233   nsresult rv = tableAcc->GetColumnHeader(getter_AddRefs(header));
 234   if (NS_FAILED(rv))
 235     return GetHRESULT(rv);
 236
 237   if (!header)
 238     return S_FALSE;
 239
 240   nsCOMPtr<nsIWinAccessNode> winAccessNode(do_QueryInterface(header));
 241   if (!winAccessNode)
 242     return E_FAIL;
 243
 244   void *instancePtr = NULL;
 245   rv = winAccessNode->QueryNativeInterface(IID_IAccessibleTable, &instancePtr);
 246   if (NS_FAILED(rv))
 247     return GetHRESULT(rv);
 248
 249   *aAccessibleTable = static_cast<IAccessibleTable*>(instancePtr);
 250   return S_OK;
 251
 252 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 253   return E_FAIL;
 254 }
 255
 256 STDMETHODIMP
 257 CAccessibleTable::get_columnIndex(long aChildIndex, long *aColumnIndex)
 258 {
 259 __try {
 260   *aColumnIndex = 0;
 261
 262   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 263   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 264   if (!tableAcc)
 265     return E_FAIL;
 266
 267   PRInt32 columnIndex = 0;
 268   nsresult rv = tableAcc->GetColumnAtIndex(aChildIndex, &columnIndex);
 269   if (NS_FAILED(rv))
 270     return GetHRESULT(rv);
 271
 272   *aColumnIndex = columnIndex;
 273   return S_OK;
 274
 275 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 276   return E_FAIL;
 277 }
 278
 279 STDMETHODIMP
 280 CAccessibleTable::get_nColumns(long *aColumnCount)
 281 {
 282 __try {
 283   *aColumnCount = 0;
 284
 285   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 286   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 287   if (!tableAcc)
 288     return E_FAIL;
 289
 290   PRInt32 columnCount = 0;
 291   nsresult rv = tableAcc->GetColumns(&columnCount);
 292   if (NS_FAILED(rv))
 293     return GetHRESULT(rv);
 294
 295   *aColumnCount = columnCount;
 296   return S_OK;
 297
 298 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 299   return E_FAIL;
 300 }
 301
 302 STDMETHODIMP
 303 CAccessibleTable::get_nRows(long *aRowCount)
 304 {
 305 __try {
 306   *aRowCount = 0;
 307
 308   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 309   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 310   if (!tableAcc)
 311     return E_FAIL;
 312
 313   PRInt32 rowCount = 0;
 314   nsresult rv = tableAcc->GetRows(&rowCount);
 315   if (NS_FAILED(rv))
 316     return GetHRESULT(rv);
 317
 318   *aRowCount = rowCount;
 319   return S_OK;
 320
 321 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 322   return E_FAIL;
 323 }
 324
 325 STDMETHODIMP
 326 CAccessibleTable::get_nSelectedChildren(long *aChildCount)
 327 {
 328 __try {
 329   *aChildCount = 0;
 330
 331   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 332   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 333   if (!tableAcc)
 334     return E_FAIL;
 335
 336   PRUint32 count = 0;
 337   nsresult rv = tableAcc->GetSelectedCellsCount(&count);
 338   if (NS_FAILED(rv))
 339     return GetHRESULT(rv);
 340
 341   *aChildCount = count;
 342   return S_OK;
 343
 344 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 345   return E_FAIL;
 346 }
 347
 348 STDMETHODIMP
 349 CAccessibleTable::get_nSelectedColumns(long *aColumnCount)
 350 {
 351 __try {
 352   *aColumnCount = 0;
 353
 354   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 355   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 356   if (!tableAcc)
 357     return E_FAIL;
 358
 359   PRUint32 count = 0;
 360   nsresult rv = tableAcc->GetSelectedColumnsCount(&count);
 361   if (NS_FAILED(rv))
 362     return GetHRESULT(rv);
 363
 364   *aColumnCount = count;
 365   return S_OK;
 366
 367 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 368   return E_FAIL;
 369 }
 370
 371 STDMETHODIMP
 372 CAccessibleTable::get_nSelectedRows(long *aRowCount)
 373 {
 374 __try {
 375   *aRowCount = 0;
 376
 377   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 378   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 379   if (!tableAcc)
 380     return E_FAIL;
 381
 382   PRUint32 count = 0;
 383   nsresult rv = tableAcc->GetSelectedRowsCount(&count);
 384   if (NS_FAILED(rv))
 385     return GetHRESULT(rv);
 386
 387   *aRowCount = count;
 388   return S_OK;
 389
 390 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 391   return E_FAIL;
 392 }
 393
 394 STDMETHODIMP
 395 CAccessibleTable::get_rowDescription(long aRow, BSTR *aDescription)
 396 {
 397 __try {
 398   *aDescription = NULL;
 399
 400   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 401   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 402   if (!tableAcc)
 403     return E_FAIL;
 404
 405   nsAutoString descr;
 406   nsresult rv = tableAcc->GetRowDescription (aRow, descr);
 407   if (NS_FAILED(rv))
 408     return GetHRESULT(rv);
 409
 410   if (descr.IsEmpty())
 411     return S_FALSE;
 412
 413   *aDescription = ::SysAllocStringLen(descr.get(), descr.Length());
 414   return *aDescription ? S_OK : E_OUTOFMEMORY;
 415
 416 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 417   return E_FAIL;
 418 }
 419
 420 STDMETHODIMP
 421 CAccessibleTable::get_rowExtentAt(long aRow, long aColumn, long *aNRowsSpanned)
 422 {
 423 __try {
 424   *aNRowsSpanned = 0;
 425
 426   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 427   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 428   if (!tableAcc)
 429     return E_FAIL;
 430
 431   PRInt32 rowsSpanned = 0;
 432   nsresult rv = tableAcc->GetRowExtentAt(aRow, aColumn, &rowsSpanned);
 433   if (NS_FAILED(rv))
 434     return GetHRESULT(rv);
 435
 436   *aNRowsSpanned = rowsSpanned;
 437   return S_OK;
 438
 439 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 440   return E_FAIL;
 441 }
 442
 443 STDMETHODIMP
 444 CAccessibleTable::get_rowHeader(IAccessibleTable **aAccessibleTable,
 445                                 long *aStartingColumnIndex)
 446 {
 447 __try {
 448   *aAccessibleTable = NULL;
 449
 450   // XXX: starting column index is always 0.
 451   *aStartingColumnIndex = 0;
 452
 453   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 454   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 455   if (!tableAcc)
 456     return E_FAIL;
 457
 458   nsCOMPtr<nsIAccessibleTable> header;
 459   nsresult rv = tableAcc->GetRowHeader(getter_AddRefs(header));
 460   if (NS_FAILED(rv))
 461     return GetHRESULT(rv);
 462
 463   if (!header)
 464     return S_FALSE;
 465
 466   nsCOMPtr<nsIWinAccessNode> winAccessNode(do_QueryInterface(header));
 467   if (!winAccessNode)
 468     return E_FAIL;
 469
 470   void *instancePtr = NULL;
 471   rv = winAccessNode->QueryNativeInterface(IID_IAccessibleTable,
 472                                            &instancePtr);
 473   if (NS_FAILED(rv))
 474     return GetHRESULT(rv);
 475
 476   *aAccessibleTable = static_cast<IAccessibleTable*>(instancePtr);
 477   return S_OK;
 478
 479 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 480   return E_FAIL;
 481 }
 482
 483 STDMETHODIMP
 484 CAccessibleTable::get_rowIndex(long aChildIndex, long *aRowIndex)
 485 {
 486 __try {
 487   *aRowIndex = 0;
 488
 489   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 490   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 491   if (!tableAcc)
 492     return E_FAIL;
 493
 494   PRInt32 rowIndex = 0;
 495   nsresult rv = tableAcc->GetRowAtIndex(aChildIndex, &rowIndex);
 496   if (NS_FAILED(rv))
 497     return GetHRESULT(rv);
 498
 499   *aRowIndex = rowIndex;
 500   return S_OK;
 501
 502 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 503   return E_FAIL;
 504 }
 505
 506 STDMETHODIMP
 507 CAccessibleTable::get_selectedChildren(long aMaxChildren, long **aChildren,
 508                                        long *aNChildren)
 509 {
 510 __try {
 511   return GetSelectedItems(aMaxChildren, aChildren, aNChildren, ITEMSTYPE_CELLS);
 512 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 513   return E_FAIL;
 514 }
 515
 516 STDMETHODIMP
 517 CAccessibleTable::get_selectedColumns(long aMaxColumns, long **aColumns,
 518                                       long *aNColumns)
 519 {
 520 __try {
 521   return GetSelectedItems(aMaxColumns, aColumns, aNColumns, ITEMSTYPE_COLUMNS);
 522 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 523   return E_FAIL;
 524 }
 525
 526 STDMETHODIMP
 527 CAccessibleTable::get_selectedRows(long aMaxRows, long **aRows, long *aNRows)
 528 {
 529 __try {
 530   return GetSelectedItems(aMaxRows, aRows, aNRows, ITEMSTYPE_ROWS);
 531 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 532   return E_FAIL;
 533 }
 534
 535 STDMETHODIMP
 536 CAccessibleTable::get_summary(IUnknown **aAccessible)
 537 {
 538 __try {
 539   *aAccessible = NULL;
 540
 541   // Neither html:table nor xul:tree nor ARIA grid/tree have an ability to
 542   // link an accessible object to specify a summary. There is closes method
 543   // in nsIAccessibleTable::summary to get a summary as a string which is not
 544   // mapped directly to IAccessible2.
 545
 546 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 547   return S_FALSE;
 548 }
 549
 550 STDMETHODIMP
 551 CAccessibleTable::get_isColumnSelected(long aColumn, boolean *aIsSelected)
 552 {
 553 __try {
 554   *aIsSelected = false;
 555
 556   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 557   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 558   if (!tableAcc)
 559     return E_FAIL;
 560
 561   PRBool isSelected = PR_FALSE;
 562   nsresult rv = tableAcc->IsColumnSelected(aColumn, &isSelected);
 563   if (NS_FAILED(rv))
 564     return GetHRESULT(rv);
 565
 566   *aIsSelected = isSelected;
 567   return S_OK;
 568
 569 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 570   return E_FAIL;
 571 }
 572
 573 STDMETHODIMP
 574 CAccessibleTable::get_isRowSelected(long aRow, boolean *aIsSelected)
 575 {
 576 __try {
 577   *aIsSelected = false;
 578
 579   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 580   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 581   if (!tableAcc)
 582     return E_FAIL;
 583
 584   PRBool isSelected = PR_FALSE;
 585   nsresult rv = tableAcc->IsRowSelected(aRow, &isSelected);
 586   if (NS_FAILED(rv))
 587     return GetHRESULT(rv);
 588
 589   *aIsSelected = isSelected;
 590   return S_OK;
 591
 592 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 593   return E_FAIL;
 594 }
 595
 596 STDMETHODIMP
 597 CAccessibleTable::get_isSelected(long aRow, long aColumn, boolean *aIsSelected)
 598 {
 599 __try {
 600   *aIsSelected = false;
 601
 602   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 603   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 604   if (!tableAcc)
 605     return E_FAIL;
 606
 607   PRBool isSelected = PR_FALSE;
 608   nsresult rv = tableAcc->IsCellSelected(aRow, aColumn, &isSelected);
 609   if (NS_FAILED(rv))
 610     return GetHRESULT(rv);
 611
 612   *aIsSelected = isSelected;
 613   return S_OK;
 614
 615 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 616   return E_FAIL;
 617 }
 618
 619 STDMETHODIMP
 620 CAccessibleTable::selectRow(long aRow)
 621 {
 622 __try {
 623   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 624   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 625   if (!tableAcc)
 626     return E_FAIL;
 627
 628   nsresult rv = tableAcc->SelectRow(aRow);
 629   return GetHRESULT(rv);
 630
 631 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 632   return E_FAIL;
 633 }
 634
 635 STDMETHODIMP
 636 CAccessibleTable::selectColumn(long aColumn)
 637 {
 638 __try {
 639   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 640   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 641   if (!tableAcc)
 642     return E_FAIL;
 643
 644   nsresult rv = tableAcc->SelectColumn(aColumn);
 645   return GetHRESULT(rv);
 646
 647 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 648   return E_FAIL;
 649 }
 650
 651 STDMETHODIMP
 652 CAccessibleTable::unselectRow(long aRow)
 653 {
 654 __try {
 655   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 656   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 657   if (!tableAcc)
 658     return E_FAIL;
 659
 660   nsresult rv = tableAcc->UnselectRow(aRow);
 661   return GetHRESULT(rv);
 662
 663 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 664   return E_FAIL;
 665 }
 666
 667 STDMETHODIMP
 668 CAccessibleTable::unselectColumn(long aColumn)
 669 {
 670 __try {
 671   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 672   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 673   if (!tableAcc)
 674     return E_FAIL;
 675
 676   nsresult rv = tableAcc->UnselectColumn(aColumn);
 677   return GetHRESULT(rv);
 678
 679 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 680   return E_FAIL;
 681 }
 682
 683 STDMETHODIMP
 684 CAccessibleTable::get_rowColumnExtentsAtIndex(long aIndex, long *aRow,
 685                                               long *aColumn,
 686                                               long *aRowExtents,
 687                                               long *aColumnExtents,
 688                                               boolean *aIsSelected)
 689 {
 690 __try {
 691   *aRow = 0;
 692   *aColumn = 0;
 693   *aRowExtents = 0;
 694   *aColumnExtents = 0;
 695   *aIsSelected = false;
 696
 697   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 698   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 699   if (!tableAcc)
 700     return E_FAIL;
 701
 702   PRInt32 row = -1;
 703   nsresult rv = tableAcc->GetRowAtIndex(aIndex, &row);
 704   if (NS_FAILED(rv))
 705     return GetHRESULT(rv);
 706
 707   PRInt32 column = -1;
 708   rv = tableAcc->GetColumnAtIndex(aIndex, &column);
 709   if (NS_FAILED(rv))
 710     return GetHRESULT(rv);
 711
 712   PRInt32 rowExtents = 0;
 713   rv = tableAcc->GetRowExtentAt(row, column, &rowExtents);
 714   if (NS_FAILED(rv))
 715     return GetHRESULT(rv);
 716
 717   PRInt32 columnExtents = 0;
 718   rv = tableAcc->GetColumnExtentAt(row, column, &columnExtents);
 719   if (NS_FAILED(rv))
 720     return GetHRESULT(rv);
 721
 722   PRBool isSelected = PR_FALSE;
 723   rv = tableAcc->IsCellSelected(row, column, &isSelected);
 724   if (NS_FAILED(rv))
 725     return GetHRESULT(rv);
 726
 727   *aRow = row;
 728   *aColumn = column;
 729   *aRowExtents = rowExtents;
 730   *aColumnExtents = columnExtents;
 731   *aIsSelected = isSelected;
 732   return S_OK;
 733
 734 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 735   return E_FAIL;
 736 }
 737
 738 STDMETHODIMP
 739 CAccessibleTable::get_modelChange(IA2TableModelChange *aModelChange)
 740 {
 741 __try {
 742
 743 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
 744   return E_NOTIMPL;
 745 }
 746
 747 // CAccessibleTable
 748
 749 HRESULT
 750 CAccessibleTable::GetSelectedItems(long aMaxItems, long **aItems,
 751                                    long *aItemsCount, eItemsType aType)
 752 {
 753   *aItemsCount = 0;
 754
 755   nsCOMPtr<nsIAccessibleTable> tableAcc(do_QueryInterface(this));
 756   NS_ASSERTION(tableAcc, CANT_QUERY_ASSERTION_MSG);
 757   if (!tableAcc)
 758     return E_FAIL;
 759
 760   PRUint32 size = 0;
 761   PRInt32 *items = nsnull;
 762
 763   nsresult rv = NS_OK;
 764   switch (aType) {
 765     case ITEMSTYPE_CELLS:
 766       rv = tableAcc->GetSelectedCells(&size, &items);
 767       break;
 768     case ITEMSTYPE_COLUMNS:
 769       rv = tableAcc->GetSelectedColumns(&size, &items);
 770       break;
 771     case ITEMSTYPE_ROWS:
 772       rv = tableAcc->GetSelectedRows(&size, &items);
 773       break;
 774     default:
 775       return E_FAIL;
 776   }
 777
 778   if (NS_FAILED(rv))
 779     return GetHRESULT(rv);
 780
 781   if (size == 0 || !items)
 782     return S_FALSE;
 783
 784   PRUint32 maxSize = size < static_cast<PRUint32>(aMaxItems) ? size : aMaxItems;
 785   *aItemsCount = maxSize;
 786
 787   *aItems = static_cast<long*>(nsMemory::Alloc((maxSize) * sizeof(long)));
 788   if (!*aItems)
 789     return E_OUTOFMEMORY;
 790
 791   for (PRUint32 index = 0; index < maxSize; ++index)
 792     (*aItems)[index] = items[index];
 793
 794   nsMemory::Free(items);
 795   return S_OK;
 796 }
 797