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