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