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
  37 #include <com/sun/star/accessibility/XAccessible.hpp>
  38 #include "MAccessible.h"
  39
  40 #include <com/sun/star/accessibility/XAccessibleTableSelection.hpp>
  41
  42 using namespace com::sun::star::accessibility;
  43 using namespace com::sun::star::uno;
  44 /**
  45   * Gets accessible table cell.
  46   *
  47   * @param    row        the row of the specified cell.
  48   * @param    column     the column of the specified cell.
  49   * @param    accessible the accessible object of the cell.
  50   */
  51
  52 STDMETHODIMP CAccTable::get_accessibleAt(long row, long column, IUnknown * * accessible)
  53 {
  54     SolarMutexGuard g;
  55
  56     ENTER_PROTECTED_BLOCK
  57
  58     // #CHECK#
  59     if(accessible == NULL)
  60         return E_INVALIDARG;
  61     // #CHECK XInterface#
  62     if(!pRXTable.is())
  63         return E_FAIL;
  64
  65     Reference<XAccessible> pRAcc = GetXInterface()->getAccessibleCellAt(row,column);
  66
  67     if(!pRAcc.is())
  68     {
  69         *accessible = NULL;
  70         return E_FAIL;
  71     }
  72
  73     IAccessible* pRet = NULL;
  74
  75     BOOL isTRUE = CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
  76     if(isTRUE)
  77     {
  78         *accessible = (IAccessible2 *)pRet;
  79         pRet->AddRef();
  80         return S_OK;
  81     }
  82     else if(pRAcc.is())
  83     {
  84         Reference<XAccessible> pxTable(GetXInterface(),UNO_QUERY);
  85
  86         CMAccessible::g_pAgent->InsertAccObj(pRAcc.get(),pxTable.get());
  87         isTRUE = CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
  88
  89         if(isTRUE)
  90         {
  91             *accessible = (IAccessible2 *)pRet;
  92             pRet->AddRef();
  93             return S_OK;
  94         }
  95     }
  96     return E_FAIL;
  97
  98     LEAVE_PROTECTED_BLOCK
  99 }
 100
 101 /**
 102   * Gets accessible table caption.
 103   *
 104   * @param    accessible    the accessible object of table caption.
 105   */
 106 STDMETHODIMP CAccTable::get_caption(IUnknown * *)
 107 {
 108     return E_NOTIMPL;
 109 }
 110
 111 /**
 112   * Gets accessible column description (as string).
 113   *
 114   * @param    column        the column index.
 115   * @param    description   the description of the specified column.
 116   */
 117 STDMETHODIMP CAccTable::get_columnDescription(long column, BSTR * description)
 118 {
 119     SolarMutexGuard g;
 120
 121     ENTER_PROTECTED_BLOCK
 122
 123     // #CHECK#
 124     if(description == NULL)
 125         return E_INVALIDARG;
 126
 127     // #CHECK XInterface#
 128     if(!pRXTable.is())
 129         return E_FAIL;
 130
 131     const ::rtl::OUString& ouStr = GetXInterface()->getAccessibleColumnDescription(column);
 132     // #CHECK#
 133
 134     SAFE_SYSFREESTRING(*description);//??
 135     *description = SysAllocString((OLECHAR*)ouStr.getStr());
 136     if(description==NULL)
 137         return E_FAIL;
 138     return S_OK;
 139
 140     LEAVE_PROTECTED_BLOCK
 141 }
 142
 143 /**
 144   * Gets number of columns spanned by table cell.
 145   *
 146   * @param    row            the row of the specified cell.
 147   * @param    column         the column of the specified cell.
 148   * @param    spanColumns    the column span of the specified cell.
 149   */
 150 STDMETHODIMP CAccTable::get_columnExtentAt(long row, long column, long * nColumnsSpanned)
 151 {
 152     SolarMutexGuard g;
 153
 154     ENTER_PROTECTED_BLOCK
 155
 156     XAccessibleTable    *pXAccTable = GetXInterface();
 157
 158     // Check pointer.
 159     if(nColumnsSpanned == NULL)
 160         return E_INVALIDARG;
 161
 162     // Get Extent.
 163     if(pXAccTable)
 164     {
 165         long lExt = pXAccTable->getAccessibleColumnExtentAt(row,column);
 166
 167         // Fill Extent struct.
 168         *nColumnsSpanned = lExt;
 169         return S_OK;
 170     }
 171
 172     return E_FAIL;
 173
 174     LEAVE_PROTECTED_BLOCK
 175 }
 176
 177 /**
 178   * Gets accessible column header.
 179   *
 180   * @param    column        the column index.
 181   * @param    accessible    the accessible object of the specified column.
 182   */
 183 STDMETHODIMP CAccTable::get_columnHeader(IAccessibleTable __RPC_FAR *__RPC_FAR *accessibleTable, long *startingRowIndex)
 184 {
 185     SolarMutexGuard g;
 186
 187     ENTER_PROTECTED_BLOCK
 188
 189     // #CHECK#
 190     if(accessibleTable == NULL || startingRowIndex == NULL)
 191         return E_INVALIDARG;
 192
 193     // #CHECK XInterface#
 194     if(!pRXTable.is())
 195         return E_FAIL;
 196
 197     Reference<XAccessibleTable> pRColumnHeaderTable = GetXInterface()->getAccessibleColumnHeaders();
 198     if(!pRColumnHeaderTable.is())
 199     {
 200         *accessibleTable = NULL;
 201         return E_FAIL;
 202     }
 203
 204     Reference<XAccessible> pRXColumnHeader(pRColumnHeaderTable,UNO_QUERY);
 205
 206     if(!pRXColumnHeader.is())
 207     {
 208         *accessibleTable = NULL;
 209         return E_FAIL;
 210     }
 211     *startingRowIndex = 0 ;
 212
 213     IMAccessible* pIMacc = NULL;
 214     HRESULT hr = createInstance<CMAccessible>(IID_IMAccessible, &pIMacc);
 215     if (!SUCCEEDED(hr))
 216     {
 217         return E_FAIL;
 218     }
 219     pIMacc->SetXAccessible(
 220         reinterpret_cast<hyper>(pRXColumnHeader.get()));
 221     pIMacc->QueryInterface(IID_IAccessibleTable,(void **)accessibleTable);
 222
 223     return S_OK;
 224
 225     LEAVE_PROTECTED_BLOCK
 226 }
 227
 228 /**
 229   * Gets total number of columns in table.
 230   *
 231   * @param    columnCount    the number of columns in table.
 232   */
 233 STDMETHODIMP CAccTable::get_nColumns(long * columnCount)
 234 {
 235     SolarMutexGuard g;
 236
 237     ENTER_PROTECTED_BLOCK
 238
 239     // #CHECK#
 240     if(columnCount == NULL)
 241         return E_INVALIDARG;
 242
 243     // #CHECK XInterface#
 244     if(!pRXTable.is())
 245         return E_FAIL;
 246
 247     *columnCount = GetXInterface()->getAccessibleColumnCount();
 248     return S_OK;
 249
 250     LEAVE_PROTECTED_BLOCK
 251 }
 252
 253 /**
 254   * Gets total number of rows in table.
 255   *
 256   * @param    rowCount    the number of rows in table.
 257   */
 258 STDMETHODIMP CAccTable::get_nRows(long * rowCount)
 259 {
 260     SolarMutexGuard g;
 261
 262     ENTER_PROTECTED_BLOCK
 263
 264     // #CHECK#
 265     if(rowCount == NULL)
 266         return E_INVALIDARG;
 267
 268     // #CHECK XInterface#
 269     if(!pRXTable.is())
 270         return E_FAIL;
 271
 272     *rowCount = GetXInterface()->getAccessibleRowCount();
 273     return S_OK;
 274
 275     LEAVE_PROTECTED_BLOCK
 276 }
 277
 278 /**
 279   * Gets total number of selected columns.
 280   *
 281   * @param    columnCount    the number of selected columns.
 282   */
 283 STDMETHODIMP CAccTable::get_nSelectedColumns(long * columnCount)
 284 {
 285     SolarMutexGuard g;
 286
 287     ENTER_PROTECTED_BLOCK
 288
 289     // #CHECK#
 290     if(columnCount == NULL)
 291         return E_INVALIDARG;
 292
 293     // #CHECK XInterface#
 294     if(!pRXTable.is())
 295         return E_FAIL;
 296
 297     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleColumns();
 298     *columnCount = pSelected.getLength();
 299     return S_OK;
 300
 301     LEAVE_PROTECTED_BLOCK
 302 }
 303
 304 /**
 305   * Gets total number of selected rows.
 306   *
 307   * @param    rowCount    the number of selected rows.
 308   */
 309 STDMETHODIMP CAccTable::get_nSelectedRows(long * rowCount)
 310 {
 311     SolarMutexGuard g;
 312
 313     ENTER_PROTECTED_BLOCK
 314
 315     // #CHECK#
 316     if(rowCount == NULL)
 317         return E_INVALIDARG;
 318
 319     // #CHECK XInterface#
 320     if(!pRXTable.is())
 321         return E_FAIL;
 322
 323     Sequence<long> pSelected = GetXInterface()->getSelectedAccessibleRows();
 324     *rowCount = pSelected.getLength();
 325     return S_OK;
 326
 327     LEAVE_PROTECTED_BLOCK
 328 }
 329
 330 /**
 331   * Gets accessible row description (as string).
 332   *
 333   * @param    row            the row index.
 334   * @param    description    the description of the specified row.
 335   */
 336 STDMETHODIMP CAccTable::get_rowDescription(long row, BSTR * description)
 337 {
 338     SolarMutexGuard g;
 339
 340     ENTER_PROTECTED_BLOCK
 341
 342     // #CHECK#
 343     if(description == NULL)
 344         return E_INVALIDARG;
 345
 346     // #CHECK XInterface#
 347     if(!pRXTable.is())
 348         return E_FAIL;
 349
 350     const ::rtl::OUString& ouStr = GetXInterface()->getAccessibleRowDescription(row);
 351     // #CHECK#
 352
 353     SAFE_SYSFREESTRING(*description);
 354     *description = SysAllocString((OLECHAR*)ouStr.getStr());
 355     if(description==NULL)
 356         return E_FAIL;
 357
 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 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 == NULL)
 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 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 == NULL || startingColumnIndex == NULL)
 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 = NULL;
 422         return E_FAIL;
 423     }
 424
 425     Reference<XAccessible> pRXRowHeader(pRRowHeaderTable,UNO_QUERY);
 426
 427     if(!pRXRowHeader.is())
 428     {
 429         *accessibleTable = NULL;
 430         return E_FAIL;
 431     }
 432     *startingColumnIndex = 0 ;
 433
 434     IMAccessible* pIMacc = NULL;
 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,(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 STDMETHODIMP CAccTable::get_selectedRows(long, long ** rows, long * nRows)
 457 {
 458     SolarMutexGuard g;
 459
 460     ENTER_PROTECTED_BLOCK
 461
 462     // #CHECK#
 463     if(rows == NULL || nRows == NULL)
 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 = reinterpret_cast<long*>(CoTaskMemAlloc((count) * sizeof(long)));
 475     // #CHECK Memory Allocation#
 476     if(*rows == NULL)
 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 STDMETHODIMP CAccTable::get_selectedColumns(long, long ** columns, long * numColumns)
 496 {
 497     SolarMutexGuard g;
 498
 499     ENTER_PROTECTED_BLOCK
 500
 501     // #CHECK#
 502     if(columns == NULL || numColumns == NULL)
 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 = reinterpret_cast<long*>(CoTaskMemAlloc((count) * sizeof(long)));
 514     // #CHECK Memory Allocation#
 515     if(*columns == NULL)
 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 STDMETHODIMP CAccTable::get_summary(IUnknown * * accessible)
 533 {
 534     SolarMutexGuard g;
 535
 536     ENTER_PROTECTED_BLOCK
 537
 538     // #CHECK#
 539     if(accessible == NULL)
 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 = NULL;
 550     CMAccessible::get_IAccessibleFromXAccessible(pRAcc.get(), &pRet);
 551
 552     if(pRet)
 553     {
 554         *accessible = (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 STDMETHODIMP CAccTable::get_isColumnSelected(long column, unsigned char * isSelected)
 571 {
 572     SolarMutexGuard g;
 573
 574     ENTER_PROTECTED_BLOCK
 575
 576     // #CHECK#
 577     if(isSelected == NULL)
 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 STDMETHODIMP CAccTable::get_isRowSelected(long row, unsigned char * isSelected)
 597 {
 598     SolarMutexGuard g;
 599
 600     ENTER_PROTECTED_BLOCK
 601
 602     // #CHECK#
 603     if(isSelected == NULL)
 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 STDMETHODIMP CAccTable::get_isSelected(long row, long column, unsigned char * isSelected)
 625 {
 626     SolarMutexGuard g;
 627
 628     ENTER_PROTECTED_BLOCK
 629
 630     // #CHECK#
 631     if(isSelected == NULL)
 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 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.get()->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.get()->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 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.get()->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.get()->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 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.get()->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.get()->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 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.get()->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.get()->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 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 == NULL)
 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 = NULL;
 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 STDMETHODIMP CAccTable::get_columnIndex(long childIndex, long * columnIndex)
 862 {
 863     SolarMutexGuard g;
 864
 865     ENTER_PROTECTED_BLOCK
 866
 867     // #CHECK#
 868     if(columnIndex == NULL)
 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 STDMETHODIMP CAccTable::get_rowIndex(long childIndex, long * rowIndex)
 886 {
 887     SolarMutexGuard g;
 888
 889     ENTER_PROTECTED_BLOCK
 890
 891     // #CHECK#
 892     if(rowIndex == NULL)
 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 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 == NULL)
 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 STDMETHODIMP CAccTable::get_rowColumnExtentsAtIndex(long,
 930         long  *,
 931         long  *,
 932         long  *,
 933         long  *,
 934         boolean  *)
 935 {
 936     return E_NOTIMPL;
 937 }
 938
 939 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 STDMETHODIMP CAccTable::get_nSelectedChildren(long *childCount)
 948 {
 949     SolarMutexGuard g;
 950
 951     ENTER_PROTECTED_BLOCK
 952
 953     // #CHECK#
 954     if(childCount == NULL)
 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 STDMETHODIMP CAccTable::get_selectedChildren(long, long **children, long *nChildren)
 979 {
 980     SolarMutexGuard g;
 981
 982     ENTER_PROTECTED_BLOCK
 983
 984     // #CHECK#
 985     if(children == NULL || nChildren == NULL)
 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 = reinterpret_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: */