winaccessibility/source/UAccCOM/AccTable.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /**
  21  * AccTable.cpp : Implementation of CAccTable.
  22  */
  23 #include "stdafx.h"
  24 #include "AccTable.h"
  25
  26 #if defined __clang__
  27 #pragma clang diagnostic push
  28 #pragma clang diagnostic ignored "-Wnon-virtual-dtor"
  29 #endif
  30 #include  <UAccCOM.h>
  31 #if defined __clang__
  32 #pragma clang diagnostic pop
  33 #endif
  34
  35 #include <vcl/svapp.hxx>
  36 #include <o3tl/char16_t2wchar_t.hxx>
  37
  38 #include <com/sun/star/accessibility/XAccessible.hpp>
  39 #include "MAccessible.h"
  40
  41 #include <com/sun/star/accessibility/XAccessibleTableSelection.hpp>
  42
  43 using namespace com::sun::star::accessibility;
  44 using namespace com::sun::star::uno;
  45 /**
  46   * Gets accessible table cell.
  47   *
  48   * @param    row        the row of the specified cell.
  49   * @param    column     the column of the specified cell.
  50   * @param    accessible the accessible object of the cell.
  51   */
  52
  53 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_accessibleAt(long row, long column, IUnknown * * accessible)
  54 {
  55     SolarMutexGuard g;
  56
  57     ENTER_PROTECTED_BLOCK
  58
  59     // #CHECK#
  60     if(accessible == nullptr)
  61         return E_INVALIDARG;
  62     // #CHECK XInterface#
  63     if(!pRXTable.is())
  64         return E_FAIL;
  65
  66     Reference<XAccessible> pRAcc = GetXInterface()->getAccessibleCellAt(row,column);
  67
  68     if(!pRAcc.is())
  69     {
  70         *accessible = nullptr;
  71         return E_FAIL;
  72     }
  73
  74     IAccessible* pRet = nullptr;
  75
  76     bool isTRUE = CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
  77     if(isTRUE)
  78     {
  79         *accessible = static_cast<IAccessible2 *>(pRet);
  80         pRet->AddRef();
  81         return S_OK;
  82     }
  83     else if(pRAcc.is())
  84     {
  85         Reference<XAccessible> pxTable(GetXInterface(),UNO_QUERY);
  86
  87         CMAccessible::g_pAgent->InsertAccObj(pRAcc.get(),pxTable.get());
  88         isTRUE = CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
  89
  90         if(isTRUE)
  91         {
  92             *accessible = static_cast<IAccessible2 *>(pRet);
  93             pRet->AddRef();
  94             return S_OK;
  95         }
  96     }
  97     return E_FAIL;
  98
  99     LEAVE_PROTECTED_BLOCK
 100 }
 101
 102 /**
 103   * Gets accessible table caption.
 104   *
 105   * @param    accessible    the accessible object of table caption.
 106   */
 107 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_caption(IUnknown * *)
 108 {
 109     return E_NOTIMPL;
 110 }
 111
 112 /**
 113   * Gets accessible column description (as string).
 114   *
 115   * @param    column        the column index.
 116   * @param    description   the description of the specified column.
 117   */
 118 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_columnDescription(long column, BSTR * description)
 119 {
 120     SolarMutexGuard g;
 121
 122     ENTER_PROTECTED_BLOCK
 123
 124     // #CHECK#
 125     if(description == nullptr)
 126         return E_INVALIDARG;
 127
 128     // #CHECK XInterface#
 129     if(!pRXTable.is())
 130         return E_FAIL;
 131
 132     const OUString& ouStr = GetXInterface()->getAccessibleColumnDescription(column);
 133     // #CHECK#
 134
 135     SAFE_SYSFREESTRING(*description);
 136     *description = SysAllocString(o3tl::toW(ouStr.getStr()));
 137     if (*description==nullptr)
 138         return E_FAIL;
 139     return S_OK;
 140
 141     LEAVE_PROTECTED_BLOCK
 142 }
 143
 144 /**
 145   * Gets number of columns spanned by table cell.
 146   *
 147   * @param    row            the row of the specified cell.
 148   * @param    column         the column of the specified cell.
 149   * @param    spanColumns    the column span of the specified cell.
 150   */
 151 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_columnExtentAt(long row, long column, long * nColumnsSpanned)
 152 {
 153     SolarMutexGuard g;
 154
 155     ENTER_PROTECTED_BLOCK
 156
 157     XAccessibleTable    *pXAccTable = GetXInterface();
 158
 159     // Check pointer.
 160     if(nColumnsSpanned == nullptr)
 161         return E_INVALIDARG;
 162
 163     // Get Extent.
 164     if(pXAccTable)
 165     {
 166         long lExt = pXAccTable->getAccessibleColumnExtentAt(row,column);
 167
 168         // Fill Extent struct.
 169         *nColumnsSpanned = lExt;
 170         return S_OK;
 171     }
 172
 173     return E_FAIL;
 174
 175     LEAVE_PROTECTED_BLOCK
 176 }
 177
 178 /**
 179   * Gets accessible column header.
 180   *
 181   * @param    column        the column index.
 182   * @param    accessible    the accessible object of the specified column.
 183   */
 184 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_columnHeader(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingRowIndex)
 185 {
 186     SolarMutexGuard g;
 187
 188     ENTER_PROTECTED_BLOCK
 189
 190     // #CHECK#
 191     if(accessibleTable == nullptr || startingRowIndex == nullptr)
 192         return E_INVALIDARG;
 193
 194     // #CHECK XInterface#
 195     if(!pRXTable.is())
 196         return E_FAIL;
 197
 198     Reference<XAccessibleTable> pRColumnHeaderTable = GetXInterface()->getAccessibleColumnHeaders();
 199     if(!pRColumnHeaderTable.is())
 200     {
 201         *accessibleTable = nullptr;
 202         return E_FAIL;
 203     }
 204
 205     Reference<XAccessible> pRXColumnHeader(pRColumnHeaderTable,UNO_QUERY);
 206
 207     if(!pRXColumnHeader.is())
 208     {
 209         *accessibleTable = nullptr;
 210         return E_FAIL;
 211     }
 212     *startingRowIndex = 0 ;
 213
 214     IMAccessible* pIMacc = nullptr;
 215     HRESULT hr = createInstance<CMAccessible>(IID_IMAccessible, &pIMacc);
 216     if (!SUCCEEDED(hr))
 217     {
 218         return E_FAIL;
 219     }
 220     pIMacc->SetXAccessible(
 221         reinterpret_cast<hyper>(pRXColumnHeader.get()));
 222     pIMacc->QueryInterface(IID_IAccessibleTable,reinterpret_cast<void **>(accessibleTable));
 223
 224     return S_OK;
 225
 226     LEAVE_PROTECTED_BLOCK
 227 }
 228
 229 /**
 230   * Gets total number of columns in table.
 231   *
 232   * @param    columnCount    the number of columns in table.
 233   */
 234 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_nColumns(long * columnCount)
 235 {
 236     SolarMutexGuard g;
 237
 238     ENTER_PROTECTED_BLOCK
 239
 240     // #CHECK#
 241     if(columnCount == nullptr)
 242         return E_INVALIDARG;
 243
 244     // #CHECK XInterface#
 245     if(!pRXTable.is())
 246         return E_FAIL;
 247
 248     *columnCount = GetXInterface()->getAccessibleColumnCount();
 249     return S_OK;
 250
 251     LEAVE_PROTECTED_BLOCK
 252 }
 253
 254 /**
 255   * Gets total number of rows in table.
 256   *
 257   * @param    rowCount    the number of rows in table.
 258   */
 259 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_nRows(long * rowCount)
 260 {
 261     SolarMutexGuard g;
 262
 263     ENTER_PROTECTED_BLOCK
 264
 265     // #CHECK#
 266     if(rowCount == nullptr)
 267         return E_INVALIDARG;
 268
 269     // #CHECK XInterface#
 270     if(!pRXTable.is())
 271         return E_FAIL;
 272
 273     *rowCount = GetXInterface()->getAccessibleRowCount();
 274     return S_OK;
 275
 276     LEAVE_PROTECTED_BLOCK
 277 }
 278
 279 /**
 280   * Gets total number of selected columns.
 281   *
 282   * @param    columnCount    the number of selected columns.
 283   */
 284 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_nSelectedColumns(long * columnCount)
 285 {
 286     SolarMutexGuard g;
 287
 288     ENTER_PROTECTED_BLOCK
 289
 290     // #CHECK#
 291     if(columnCount == nullptr)
 292         return E_INVALIDARG;
 293
 294     // #CHECK XInterface#
 295     if(!pRXTable.is())
 296         return E_FAIL;
 297
 298     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleColumns();
 299     *columnCount = pSelected.getLength();
 300     return S_OK;
 301
 302     LEAVE_PROTECTED_BLOCK
 303 }
 304
 305 /**
 306   * Gets total number of selected rows.
 307   *
 308   * @param    rowCount    the number of selected rows.
 309   */
 310 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_nSelectedRows(long * rowCount)
 311 {
 312     SolarMutexGuard g;
 313
 314     ENTER_PROTECTED_BLOCK
 315
 316     // #CHECK#
 317     if(rowCount == nullptr)
 318         return E_INVALIDARG;
 319
 320     // #CHECK XInterface#
 321     if(!pRXTable.is())
 322         return E_FAIL;
 323
 324     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleRows();
 325     *rowCount = pSelected.getLength();
 326     return S_OK;
 327
 328     LEAVE_PROTECTED_BLOCK
 329 }
 330
 331 /**
 332   * Gets accessible row description (as string).
 333   *
 334   * @param    row            the row index.
 335   * @param    description    the description of the specified row.
 336   */
 337 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_rowDescription(long row, BSTR * description)
 338 {
 339     SolarMutexGuard g;
 340
 341     ENTER_PROTECTED_BLOCK
 342
 343     // #CHECK#
 344     if(description == nullptr)
 345         return E_INVALIDARG;
 346
 347     // #CHECK XInterface#
 348     if(!pRXTable.is())
 349         return E_FAIL;
 350
 351     const OUString& ouStr = GetXInterface()->getAccessibleRowDescription(row);
 352     // #CHECK#
 353
 354     SAFE_SYSFREESTRING(*description);
 355     *description = SysAllocString(o3tl::toW(ouStr.getStr()));
 356     if (*description==nullptr)
 357         return E_FAIL;
 358     return S_OK;
 359
 360     LEAVE_PROTECTED_BLOCK
 361 }
 362
 363 /**
 364   * Gets number of rows spanned by a table cell.
 365   *
 366   * @param    row            the row of the specified cell.
 367   * @param    column         the column of the specified cell.
 368   * @param    spanRows       the row span of the specified cell.
 369   */
 370 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_rowExtentAt(long row, long column, long * nRowsSpanned)
 371 {
 372     SolarMutexGuard g;
 373
 374     ENTER_PROTECTED_BLOCK
 375
 376     XAccessibleTable    *pXAccTable = GetXInterface();
 377
 378     // Check pointer.
 379     if(nRowsSpanned == nullptr)
 380         return E_INVALIDARG;
 381
 382     // Get Extent.
 383     if(pXAccTable)
 384     {
 385         long lExt = GetXInterface()->getAccessibleRowExtentAt(row,column);
 386
 387         // Fill Extent struct.
 388         *nRowsSpanned= lExt;
 389
 390         return S_OK;
 391     }
 392
 393     return E_FAIL;
 394
 395     LEAVE_PROTECTED_BLOCK
 396 }
 397
 398 /**
 399   * Gets accessible row header.
 400   *
 401   * @param    row        the row index.
 402   * @param    accessible the accessible object of the row header.
 403   */
 404 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_rowHeader(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingColumnIndex)
 405 {
 406     SolarMutexGuard g;
 407
 408     ENTER_PROTECTED_BLOCK
 409
 410     // #CHECK#
 411     if(accessibleTable == nullptr || startingColumnIndex == nullptr)
 412         return E_INVALIDARG;
 413
 414     // #CHECK XInterface#
 415     if(!pRXTable.is())
 416         return E_FAIL;
 417
 418     Reference<XAccessibleTable> pRRowHeaderTable = GetXInterface()->getAccessibleRowHeaders();
 419     if(!pRRowHeaderTable.is())
 420     {
 421         *accessibleTable = nullptr;
 422         return E_FAIL;
 423     }
 424
 425     Reference<XAccessible> pRXRowHeader(pRRowHeaderTable,UNO_QUERY);
 426
 427     if(!pRXRowHeader.is())
 428     {
 429         *accessibleTable = nullptr;
 430         return E_FAIL;
 431     }
 432     *startingColumnIndex = 0 ;
 433
 434     IMAccessible* pIMacc = nullptr;
 435     HRESULT hr = createInstance<CMAccessible>(IID_IMAccessible, &pIMacc);
 436     if (!SUCCEEDED(hr))
 437     {
 438         return E_FAIL;
 439     }
 440     pIMacc->SetXAccessible(
 441         reinterpret_cast<hyper>(pRXRowHeader.get()));
 442     pIMacc->QueryInterface(IID_IAccessibleTable,reinterpret_cast<void **>(accessibleTable));
 443
 444     return S_OK;
 445
 446     LEAVE_PROTECTED_BLOCK
 447 }
 448
 449 /**
 450   * Gets list of row indexes currently selected (0-based).
 451   *
 452   * @param    maxRows        the max number of the rows.
 453   * @param    accessible     the accessible object array of the selected rows.
 454   * @param    nRows          the actual size of the accessible object array.
 455   */
 456 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_selectedRows(long, long ** rows, long * nRows)
 457 {
 458     SolarMutexGuard g;
 459
 460     ENTER_PROTECTED_BLOCK
 461
 462     // #CHECK#
 463     if(rows == nullptr || nRows == nullptr)
 464         return E_INVALIDARG;
 465
 466     // #CHECK XInterface#
 467     if(!pRXTable.is())
 468         return E_FAIL;
 469
 470     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleRows();
 471     long count = pSelected.getLength() ;
 472     *nRows = count;
 473
 474     *rows = static_cast<long*>(CoTaskMemAlloc(count * sizeof(long)));
 475     // #CHECK Memory Allocation#
 476     if(*rows == nullptr)
 477     {
 478         return E_FAIL;
 479     }
 480     for(int i=0; i<count; i++)
 481         (*rows)[i] = pSelected[i];
 482
 483     return S_OK;
 484
 485     LEAVE_PROTECTED_BLOCK
 486 }
 487
 488 /**
 489   * Gets list of column indexes currently selected (0-based).
 490   *
 491   * @param    maxColumns    the max number of the columns.
 492   * @param    accessible    the accessible object array of the selected columns.
 493   * @param    numColumns    the actual size of accessible object array.
 494   */
 495 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_selectedColumns(long, long ** columns, long * numColumns)
 496 {
 497     SolarMutexGuard g;
 498
 499     ENTER_PROTECTED_BLOCK
 500
 501     // #CHECK#
 502     if(columns == nullptr || numColumns == nullptr)
 503         return E_INVALIDARG;
 504
 505     // #CHECK XInterface#
 506     if(!pRXTable.is())
 507         return E_FAIL;
 508
 509     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleColumns();
 510     long count = pSelected.getLength() ;
 511     *numColumns = count;
 512
 513     *columns = static_cast<long*>(CoTaskMemAlloc(count * sizeof(long)));
 514     // #CHECK Memory Allocation#
 515     if(*columns == nullptr)
 516     {
 517         return E_FAIL;
 518     }
 519     for(int i=0; i<count; i++)
 520         (*columns)[i] = pSelected[i];
 521
 522     return S_OK;
 523
 524     LEAVE_PROTECTED_BLOCK
 525 }
 526
 527 /**
 528   * Gets accessible table summary.
 529   *
 530   * @param    accessible   the accessible object of the summary.
 531   */
 532 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_summary(IUnknown * * accessible)
 533 {
 534     SolarMutexGuard g;
 535
 536     ENTER_PROTECTED_BLOCK
 537
 538     // #CHECK#
 539     if(accessible == nullptr)
 540         return E_INVALIDARG;
 541
 542     // #CHECK XInterface#
 543     if(!pRXTable.is())
 544     {
 545         return E_FAIL;
 546     }
 547     Reference<XAccessible> pRAcc = GetXInterface()->getAccessibleSummary();
 548
 549     IAccessible* pRet = nullptr;
 550     CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
 551
 552     if(pRet)
 553     {
 554         *accessible = static_cast<IAccessible2 *>(pRet);
 555         pRet->AddRef();
 556         return S_OK;
 557     }
 558
 559     return E_FAIL;
 560
 561     LEAVE_PROTECTED_BLOCK
 562 }
 563
 564 /**
 565   * Determines if table column is selected.
 566   *
 567   * @param    column        the column index.
 568   * @param    isSelected    the result.
 569   */
 570 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_isColumnSelected(long column, boolean * isSelected)
 571 {
 572     SolarMutexGuard g;
 573
 574     ENTER_PROTECTED_BLOCK
 575
 576     // #CHECK#
 577     if(isSelected == nullptr)
 578         return E_INVALIDARG;
 579
 580     // #CHECK XInterface#
 581     if(!pRXTable.is())
 582         return E_FAIL;
 583
 584     *isSelected = GetXInterface()->isAccessibleColumnSelected(column);
 585     return S_OK;
 586
 587     LEAVE_PROTECTED_BLOCK
 588 }
 589
 590 /**
 591   * Determines if table row is selected.
 592   *
 593   * @param    row           the row index.
 594   * @param    isSelected    the result.
 595   */
 596 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_isRowSelected(long row, boolean * isSelected)
 597 {
 598     SolarMutexGuard g;
 599
 600     ENTER_PROTECTED_BLOCK
 601
 602     // #CHECK#
 603     if(isSelected == nullptr)
 604         return E_INVALIDARG;
 605
 606     // #CHECK XInterface#
 607     if(!pRXTable.is())
 608     {
 609         return E_FAIL;
 610     }
 611     *isSelected = GetXInterface()->isAccessibleRowSelected(row);
 612     return S_OK;
 613
 614     LEAVE_PROTECTED_BLOCK
 615 }
 616
 617 /**
 618   * Determines if table cell is selected.
 619   *
 620   * @param    row            the row index.
 621   * @param    column         the column index.
 622   * @param    isSelected     the result.
 623   */
 624 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_isSelected(long row, long column, boolean * isSelected)
 625 {
 626     SolarMutexGuard g;
 627
 628     ENTER_PROTECTED_BLOCK
 629
 630     // #CHECK#
 631     if(isSelected == nullptr)
 632         return E_INVALIDARG;
 633
 634     // #CHECK XInterface#
 635     if(!pRXTable.is())
 636         return E_FAIL;
 637
 638     *isSelected = GetXInterface()->isAccessibleSelected(row,column);
 639     return S_OK;
 640
 641     LEAVE_PROTECTED_BLOCK
 642 }
 643
 644 /**
 645   * Selects a row and unselect all previously selected rows.
 646   *
 647   * @param    row        the row index.
 648   * @param    success    the result.
 649   */
 650 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::selectRow(long row)
 651 {
 652     SolarMutexGuard g;
 653
 654     ENTER_PROTECTED_BLOCK
 655
 656     // Check XAccessibleTable reference.
 657     if(!pRXTable.is())
 658         return E_FAIL;
 659
 660     Reference<XAccessibleTableSelection>        pRTableExtent(pRXTable, UNO_QUERY);
 661     if(pRTableExtent.is())
 662     {
 663         pRTableExtent->selectRow(row);
 664         return S_OK;
 665     }
 666     else
 667     {
 668         // Get XAccessibleSelection.
 669         Reference<XAccessibleSelection>     pRSelection(GetXInterface(), UNO_QUERY);
 670         if(!pRSelection.is())
 671             return E_FAIL;
 672
 673         // Select row.
 674         long            lCol, lColumnCount;
 675         lColumnCount = GetXInterface()->getAccessibleColumnCount();
 676         for(lCol = 0; lCol < lColumnCount; lCol ++)
 677         {
 678             long lChildIndex = GetXInterface()->getAccessibleIndex(row, lCol);
 679             pRSelection->selectAccessibleChild(lChildIndex);
 680         }
 681
 682         return S_OK;
 683     }
 684
 685     LEAVE_PROTECTED_BLOCK
 686 }
 687
 688 /**
 689   * Selects a column and unselect all previously selected columns.
 690   *
 691   * @param    column    the column index.
 692   * @param    success   the result.
 693   */
 694 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::selectColumn(long column)
 695 {
 696     SolarMutexGuard g;
 697
 698     ENTER_PROTECTED_BLOCK
 699
 700     // Check XAccessibleTable reference.
 701     if(!pRXTable.is())
 702         return E_FAIL;
 703
 704     Reference<XAccessibleTableSelection>        pRTableExtent(GetXInterface(), UNO_QUERY);
 705     if(pRTableExtent.is())
 706     {
 707         pRTableExtent->selectColumn(column);
 708         return S_OK;
 709     }
 710     else
 711     {
 712         // Get XAccessibleSelection.
 713         Reference<XAccessibleSelection>     pRSelection(pRXTable, UNO_QUERY);
 714         if(!pRSelection.is())
 715             return E_FAIL;
 716
 717         // Select column.
 718         long            lRow, lRowCount;
 719         lRowCount = GetXInterface()->getAccessibleRowCount();
 720         for(lRow = 0; lRow < lRowCount; lRow ++)
 721         {
 722             long lChildIndex = GetXInterface()->getAccessibleIndex(lRow, column);
 723             pRSelection->selectAccessibleChild(lChildIndex);
 724         }
 725
 726         return S_OK;
 727     }
 728     // End of added.
 729
 730     LEAVE_PROTECTED_BLOCK
 731 }
 732
 733 /**
 734   * Unselects one row, leaving other selected rows selected (if any).
 735   *
 736   * @param    row        the row index.
 737   * @param    success    the result.
 738   */
 739 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::unselectRow(long row)
 740 {
 741     SolarMutexGuard g;
 742
 743     ENTER_PROTECTED_BLOCK
 744
 745     // Check XAccessibleTable reference.
 746     if(!pRXTable.is())
 747         return E_FAIL;
 748
 749     Reference<XAccessibleTableSelection>        pRTableExtent(GetXInterface(), UNO_QUERY);
 750     if(pRTableExtent.is())
 751     {
 752         if(pRTableExtent->unselectRow(row))
 753             return S_OK;
 754         else
 755             return E_FAIL;
 756     }
 757     else
 758     {
 759         // Get XAccessibleSelection.
 760         Reference<XAccessibleSelection>     pRSelection(pRXTable, UNO_QUERY);
 761         if(!pRSelection.is())
 762             return E_FAIL;
 763
 764         // Select column.
 765         long            lColumn, lColumnCount;
 766         lColumnCount = GetXInterface()->getAccessibleColumnCount();
 767         for(lColumn = 0; lColumn < lColumnCount; lColumn ++)
 768         {
 769             long lChildIndex = GetXInterface()->getAccessibleIndex(row,lColumn);
 770             pRSelection->deselectAccessibleChild(lChildIndex);
 771         }
 772
 773         return S_OK;
 774     }
 775     // End of added.
 776
 777     LEAVE_PROTECTED_BLOCK
 778 }
 779
 780 /**
 781   * Unselects one column, leaving other selected columns selected (if any).
 782   *
 783   * @param    column    the column index.
 784   * @param    success   the result.
 785   */
 786 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::unselectColumn(long column)
 787 {
 788     SolarMutexGuard g;
 789
 790     ENTER_PROTECTED_BLOCK
 791
 792     // Check XAccessibleTable reference.
 793     if(!pRXTable.is())
 794         return E_FAIL;
 795
 796     Reference<XAccessibleTableSelection>        pRTableExtent(GetXInterface(), UNO_QUERY);
 797     if(pRTableExtent.is())
 798     {
 799         if(pRTableExtent->unselectColumn(column))
 800             return S_OK;
 801         else
 802             return E_FAIL;
 803     }
 804     else
 805     {
 806         // Get XAccessibleSelection.
 807         Reference<XAccessibleSelection>     pRSelection(pRXTable, UNO_QUERY);
 808         if(!pRSelection.is())
 809             return E_FAIL;
 810
 811         // Unselect columns.
 812         long            lRow, lRowCount;
 813         lRowCount = GetXInterface()->getAccessibleRowCount();
 814
 815         for(lRow = 0; lRow < lRowCount; lRow ++)
 816         {
 817             long lChildIndex = GetXInterface()->getAccessibleIndex(lRow, column);
 818             pRSelection->deselectAccessibleChild(lChildIndex);
 819         }
 820         return S_OK;
 821     }
 822
 823     LEAVE_PROTECTED_BLOCK
 824 }
 825
 826 /**
 827  * Override of IUNOXWrapper.
 828  *
 829  * @param    pXInterface    the pointer of UNO interface.
 830  */
 831 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::put_XInterface(hyper pXInterface)
 832 {
 833     // internal IUNOXWrapper - no mutex meeded
 834
 835     ENTER_PROTECTED_BLOCK
 836
 837     CUNOXWrapper::put_XInterface(pXInterface);
 838     //special query.
 839     if(pUNOInterface == nullptr)
 840         return E_INVALIDARG;
 841
 842     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 843     if( !pRContext.is() )
 844         return E_FAIL;
 845
 846     Reference<XAccessibleTable> pRXI(pRContext,UNO_QUERY);
 847     if( !pRXI.is() )
 848         pRXTable = nullptr;
 849     else
 850         pRXTable = pRXI.get();
 851     return S_OK;
 852
 853     LEAVE_PROTECTED_BLOCK
 854 }
 855
 856 /**
 857   * Gets columnIndex of childIndex.
 858   *
 859   * @param    childIndex    childIndex
 860   */
 861 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_columnIndex(long childIndex, long * columnIndex)
 862 {
 863     SolarMutexGuard g;
 864
 865     ENTER_PROTECTED_BLOCK
 866
 867     // #CHECK#
 868     if(columnIndex == nullptr)
 869         return E_INVALIDARG;
 870
 871     // #CHECK XInterface#
 872     if(!pRXTable.is())
 873         return E_FAIL;
 874
 875     *columnIndex = GetXInterface()->getAccessibleColumn(childIndex);
 876     return S_OK;
 877
 878     LEAVE_PROTECTED_BLOCK
 879 }
 880 /**
 881   * Gets rowIndex of childIndex.
 882   *
 883   * @param    childIndex    childIndex
 884   */
 885 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_rowIndex(long childIndex, long * rowIndex)
 886 {
 887     SolarMutexGuard g;
 888
 889     ENTER_PROTECTED_BLOCK
 890
 891     // #CHECK#
 892     if(rowIndex == nullptr)
 893         return E_INVALIDARG;
 894
 895     // #CHECK XInterface#
 896     if(!pRXTable.is())
 897         return E_FAIL;
 898
 899     *rowIndex = GetXInterface()->getAccessibleRow(childIndex);
 900     return S_OK;
 901
 902     LEAVE_PROTECTED_BLOCK
 903 }
 904 /**
 905   * Gets childIndex of childIndex.
 906   *
 907   * @param    childIndex    childIndex
 908   */
 909 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_childIndex(long RowIndex , long columnIndex, long * childIndex )
 910 {
 911     SolarMutexGuard g;
 912
 913     ENTER_PROTECTED_BLOCK
 914
 915     // #CHECK#
 916     if(childIndex == nullptr)
 917         return E_INVALIDARG;
 918
 919     // #CHECK XInterface#
 920     if(!pRXTable.is())
 921         return E_FAIL;
 922
 923     *childIndex = GetXInterface()->getAccessibleIndex(RowIndex, columnIndex);
 924     return S_OK;
 925
 926     LEAVE_PROTECTED_BLOCK
 927 }
 928
 929 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_rowColumnExtentsAtIndex(long,
 930         long  *,
 931         long  *,
 932         long  *,
 933         long  *,
 934         boolean  *)
 935 {
 936     return E_NOTIMPL;
 937 }
 938
 939 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_modelChange(IA2TableModelChange  *)
 940 {
 941     return E_NOTIMPL;
 942 }
 943
 944 // @brief Returns the total number of selected children
 945 //   @param [out] childCount
 946 //    Number of children currently selected
 947 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_nSelectedChildren(long *childCount)
 948 {
 949     SolarMutexGuard g;
 950
 951     ENTER_PROTECTED_BLOCK
 952
 953     // #CHECK#
 954     if(childCount == nullptr)
 955         return E_INVALIDARG;
 956
 957     // #CHECK XInterface#
 958     if(!pRXTable.is())
 959         return E_FAIL;
 960
 961     Reference<XAccessibleSelection>     pRSelection(GetXInterface(), UNO_QUERY);
 962     if(!pRSelection.is())
 963         return E_FAIL;
 964
 965     *childCount = pRSelection->getSelectedAccessibleChildCount();
 966     return S_OK;
 967
 968     LEAVE_PROTECTED_BLOCK
 969 }
 970
 971 // @brief Returns a list of child indexes currently selected (0-based).
 972 //   @param [in] maxChildren
 973 //    Max children requested (possibly from IAccessibleTable::nSelectedChildren)
 974 //   @param [out] children
 975 //    array of indexes of selected children (each index is 0-based)
 976 //   @param [out] nChildren
 977 //    Length of array (not more than maxChildren)
 978 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccTable::get_selectedChildren(long, long **children, long *nChildren)
 979 {
 980     SolarMutexGuard g;
 981
 982     ENTER_PROTECTED_BLOCK
 983
 984     // #CHECK#
 985     if(children == nullptr || nChildren == nullptr)
 986         return E_INVALIDARG;
 987
 988     // #CHECK XInterface#
 989     if(!pRXTable.is())
 990         return E_FAIL;
 991
 992     Reference<XAccessibleSelection>     pRSelection(GetXInterface(), UNO_QUERY);
 993     if(!pRSelection.is())
 994         return E_FAIL;
 995
 996     long childCount = pRSelection->getSelectedAccessibleChildCount() ;
 997
 998     *nChildren = childCount;
 999
1000     *children = static_cast<long*>(CoTaskMemAlloc(childCount * sizeof(long)));
1001
1002     for( long i = 0; i< childCount; i++)
1003     {
1004         Reference<XAccessible> pRAcc = pRSelection->getSelectedAccessibleChild(i);
1005         if(pRAcc.is())
1006         {
1007             Reference<XAccessibleContext> pRContext(pRAcc, UNO_QUERY);
1008             if( !pRContext.is() )
1009                 return E_FAIL;
1010
1011             long childIndex = pRContext->getAccessibleIndexInParent();
1012             (*children)[i] = childIndex;
1013         }
1014     }
1015
1016     return S_OK;
1017
1018     LEAVE_PROTECTED_BLOCK
1019
1020 }
1021
1022 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */