svx/source/table/accessibletableshape.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 #include <com/sun/star/table/XMergeableCell.hpp>
  22 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  23 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  24
  25 #include <comphelper/accessiblewrapper.hxx>
  26 #include <osl/mutex.hxx>
  27 #include <vcl/svapp.hxx>
  28
  29 #include <AccessibleTableShape.hxx>
  30 #include <svx/sdr/table/tablecontroller.hxx>
  31 #include "accessiblecell.hxx"
  32
  33 #include <algorithm>
  34
  35 #include <cppuhelper/implbase1.hxx>
  36 #include <svx/svdotable.hxx>
  37 #include <com/sun/star/view/XSelectionSupplier.hpp>
  38
  39
  40 using namespace ::accessibility;
  41 using namespace sdr::table;
  42 using namespace ::com::sun::star::accessibility;
  43 using namespace ::com::sun::star::uno;
  44 using namespace ::com::sun::star::beans;
  45 using namespace ::com::sun::star::util;
  46 using namespace ::com::sun::star::lang;
  47 using namespace ::com::sun::star::drawing;
  48 using namespace ::com::sun::star::table;
  49 using namespace ::com::sun::star::container;
  50
  51 namespace accessibility
  52 {
  53
  54 struct hash
  55 {
  56     std::size_t operator()( const Reference< XCell >& xCell ) const
  57     {
  58         return std::size_t( xCell.get() );
  59     }
  60 };
  61
  62 typedef std::unordered_map< Reference< XCell >, rtl::Reference< AccessibleCell >, hash > AccessibleCellMap;
  63
  64 class AccessibleTableShapeImpl : public cppu::WeakImplHelper1< XModifyListener >
  65 {
  66 public:
  67     AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo );
  68
  69     void init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable );
  70     void dispose();
  71
  72     Reference< XAccessible > getAccessibleChild(sal_Int32 i) throw (IndexOutOfBoundsException, RuntimeException);
  73     void getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException );
  74
  75     // XModifyListener
  76     virtual void SAL_CALL modified( const EventObject& aEvent ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
  77
  78     // XEventListener
  79     virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
  80
  81     AccessibleShapeTreeInfo& mrShapeTreeInfo;
  82     Reference< XTable > mxTable;
  83     AccessibleCellMap maChildMap;
  84     Reference< XAccessible> mxAccessible;
  85     sal_Int32 mRowCount, mColCount;
  86     //get the cached AccessibleCell from XCell
  87     Reference< AccessibleCell > getAccessibleCell (Reference< XCell > xCell);
  88 };
  89
  90
  91
  92 AccessibleTableShapeImpl::AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo )
  93 : mrShapeTreeInfo( rShapeTreeInfo )
  94 , mRowCount(0)
  95 , mColCount(0)
  96 {
  97 }
  98
  99
 100
 101 void AccessibleTableShapeImpl::init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable )
 102 {
 103     mxAccessible = xAccessible;
 104     mxTable = xTable;
 105
 106     if( mxTable.is() )
 107     {
 108         Reference< XModifyListener > xListener( this );
 109         mxTable->addModifyListener( xListener );
 110         //register the listener with table model
 111         Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(xTable, UNO_QUERY);
 112         Reference< ::com::sun::star::view::XSelectionChangeListener > xSelListener( xAccessible, UNO_QUERY );
 113         if (xSelSupplier.is())
 114             xSelSupplier->addSelectionChangeListener(xSelListener);
 115         mRowCount = mxTable->getRowCount();
 116         mColCount = mxTable->getColumnCount();
 117     }
 118 }
 119
 120
 121
 122 void AccessibleTableShapeImpl::dispose()
 123 {
 124     if( mxTable.is() )
 125     {
 126         //remove all the cell's acc object in table's dispose.
 127         for( AccessibleCellMap::iterator iter( maChildMap.begin() ); iter != maChildMap.end(); ++iter )
 128         {
 129             (*iter).second->dispose();
 130         }
 131         maChildMap.clear();
 132         Reference< XModifyListener > xListener( this );
 133         mxTable->removeModifyListener( xListener );
 134         mxTable.clear();
 135     }
 136     mxAccessible.clear();
 137 }
 138
 139
 140 //get the cached AccessibleCell from XCell
 141 Reference< AccessibleCell > AccessibleTableShapeImpl::getAccessibleCell (Reference< XCell > xCell)
 142 {
 143     AccessibleCellMap::iterator iter( maChildMap.find( xCell ) );
 144
 145     if( iter != maChildMap.end() )
 146     {
 147         Reference< AccessibleCell > xChild( (*iter).second.get() );
 148         return xChild;
 149     }
 150     return Reference< AccessibleCell >();
 151 }
 152
 153
 154 Reference< XAccessible > AccessibleTableShapeImpl::getAccessibleChild(sal_Int32 nChildIndex)
 155     throw (IndexOutOfBoundsException, RuntimeException)
 156 {
 157     sal_Int32 nColumn = 0, nRow = 0;
 158     getColumnAndRow( nChildIndex, nColumn, nRow );
 159
 160     Reference< XCell > xCell( mxTable->getCellByPosition( nColumn, nRow ) );
 161     AccessibleCellMap::iterator iter( maChildMap.find( xCell ) );
 162
 163     if( iter != maChildMap.end() )
 164     {
 165         Reference< XAccessible > xChild( (*iter).second.get() );
 166         return xChild;
 167     }
 168     else
 169     {
 170         CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) );
 171
 172         rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) );
 173
 174         xAccessibleCell->Init();
 175         maChildMap[xCell] = xAccessibleCell;
 176
 177         Reference< XAccessible > xChild( xAccessibleCell.get() );
 178         return xChild;
 179     }
 180 }
 181
 182
 183
 184 void AccessibleTableShapeImpl::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException )
 185 {
 186     rnRow = 0;
 187     rnColumn = nChildIndex;
 188
 189     if( mxTable.is() )
 190     {
 191         const sal_Int32 nColumnCount = mxTable->getColumnCount();
 192         while( rnColumn >= nColumnCount )
 193         {
 194             rnRow++;
 195             rnColumn -= nColumnCount;
 196         }
 197
 198         if( rnRow < mxTable->getRowCount() )
 199             return;
 200     }
 201
 202     throw IndexOutOfBoundsException();
 203 }
 204
 205 // XModifyListener
 206 void SAL_CALL AccessibleTableShapeImpl::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException, std::exception)
 207 {
 208     if( mxTable.is() ) try
 209     {
 210         // structural changes may have happened to the table, validate all accessible cell instances
 211         AccessibleCellMap aTempChildMap;
 212         aTempChildMap.swap( maChildMap );
 213
 214         // first move all still existing cells to maChildMap again and update their index
 215
 216         const sal_Int32 nRowCount = mxTable->getRowCount();
 217         const sal_Int32 nColCount = mxTable->getColumnCount();
 218
 219         bool bRowOrColumnChanged = false;
 220         if (mRowCount != nRowCount || mColCount != nColCount )
 221         {
 222             bRowOrColumnChanged = true;
 223             mRowCount = nRowCount;
 224             mColCount = nColCount;
 225         }
 226         sal_Int32 nChildIndex = 0;
 227
 228         for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 229         {
 230             for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 231             {
 232                 Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
 233                 AccessibleCellMap::iterator iter( aTempChildMap.find( xCell ) );
 234
 235                 if( iter != aTempChildMap.end() )
 236                 {
 237                     rtl::Reference< AccessibleCell > xAccessibleCell( (*iter).second );
 238                     xAccessibleCell->setIndexInParent( nChildIndex );
 239                     xAccessibleCell->UpdateChildren();
 240                     // If row or column count is changed, there is split or merge, so all cell's acc name should be updated
 241                     if (bRowOrColumnChanged)
 242                     {
 243                         xAccessibleCell->SetAccessibleName(xAccessibleCell->getAccessibleName(), AccessibleContextBase::ManuallySet);
 244                     }
 245                     // For merged cell, add invisible & disabled state.
 246                     Reference< XMergeableCell > xMergedCell( mxTable->getCellByPosition( nCol, nRow ),  UNO_QUERY );
 247                     if (xMergedCell.is() && xMergedCell->isMerged())
 248                     {
 249                         xAccessibleCell->ResetState(AccessibleStateType::VISIBLE);
 250                         xAccessibleCell->ResetState(AccessibleStateType::ENABLED);
 251                         // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent
 252                         // xAccessibleCell->SetState(AccessibleStateType::OFFSCREEN);
 253                         xAccessibleCell->ResetState(AccessibleStateType::SHOWING);
 254                     }
 255                     else
 256                     {
 257                         xAccessibleCell->SetState(AccessibleStateType::VISIBLE);
 258                         xAccessibleCell->SetState(AccessibleStateType::ENABLED);
 259                         // IA2 CWS. MT: OFFSCREEN == !SHOWING, should stay consistent
 260                         // xAccessibleCell->ResetState(AccessibleStateType::OFFSCREEN);
 261                         xAccessibleCell->SetState(AccessibleStateType::SHOWING);
 262                     }
 263
 264                     // move still existing cell from temporary child map to our child map
 265                     maChildMap[xCell] = xAccessibleCell;
 266                     aTempChildMap.erase( iter );
 267                 }
 268                 else
 269                 {
 270                     CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) );
 271
 272                     rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) );
 273
 274                     xAccessibleCell->Init();
 275                     maChildMap[xCell] = xAccessibleCell;
 276                 }
 277
 278                 ++nChildIndex;
 279             }
 280         }
 281
 282         // all accessible cell instances still left in aTempChildMap must be disposed
 283         // as they are no longer part of the table
 284
 285         for( AccessibleCellMap::iterator iter( aTempChildMap.begin() ); iter != aTempChildMap.end(); ++iter )
 286         {
 287             (*iter).second->dispose();
 288         }
 289         //notify bridge to update the acc cache.
 290         AccessibleTableShape *pAccTable = dynamic_cast <AccessibleTableShape *> (mxAccessible.get());
 291         if (pAccTable)
 292             pAccTable->CommitChange(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any());
 293     }
 294     catch( const Exception& )
 295     {
 296         OSL_FAIL("svx::AccessibleTableShape::modified(), exception caught!");
 297     }
 298 }
 299
 300 // XEventListener
 301 void SAL_CALL AccessibleTableShapeImpl::disposing( const EventObject& /*Source*/ ) throw (RuntimeException, std::exception)
 302 {
 303 }
 304
 305 AccessibleTableShape::AccessibleTableShape( const AccessibleShapeInfo& rShapeInfo, const AccessibleShapeTreeInfo& rShapeTreeInfo)
 306 : AccessibleTableShape_Base(rShapeInfo, rShapeTreeInfo)
 307 , mnPreviousSelectionCount(0)
 308 , mxImpl( new AccessibleTableShapeImpl( maShapeTreeInfo ) )
 309 {
 310 }
 311
 312
 313
 314 AccessibleTableShape::~AccessibleTableShape()
 315 {
 316 }
 317
 318
 319
 320 void AccessibleTableShape::Init()
 321 {
 322     try
 323     {
 324         Reference< XPropertySet > xSet( mxShape, UNO_QUERY_THROW );
 325         Reference< XTable > xTable( xSet->getPropertyValue("Model"), UNO_QUERY_THROW );
 326
 327         mxImpl->init( this, xTable );
 328     }
 329     catch( Exception& )
 330     {
 331         OSL_FAIL("AccessibleTableShape::init(), exception caught?");
 332     }
 333
 334     AccessibleTableShape_Base::Init();
 335 }
 336
 337
 338
 339 SvxTableController* AccessibleTableShape::getTableController()
 340 {
 341     SdrView* pView = maShapeTreeInfo.GetSdrView ();
 342     if( pView )
 343         return dynamic_cast< SvxTableController* >( pView->getSelectionController().get() );
 344     else
 345         return 0;
 346 }
 347
 348
 349 // XInterface
 350
 351
 352 Any SAL_CALL AccessibleTableShape::queryInterface( const Type& aType ) throw (RuntimeException, std::exception)
 353 {
 354     if ( aType == cppu::UnoType<XAccessibleTableSelection>::get())
 355     {
 356         Reference<XAccessibleTableSelection> xThis( this );
 357         Any aRet;
 358         aRet <<= xThis;
 359         return aRet;
 360     }
 361     else
 362         return AccessibleTableShape_Base::queryInterface( aType );
 363 }
 364
 365
 366
 367 void SAL_CALL AccessibleTableShape::acquire(  ) throw ()
 368 {
 369     AccessibleTableShape_Base::acquire();
 370 }
 371
 372
 373
 374 void SAL_CALL AccessibleTableShape::release(  ) throw ()
 375 {
 376     AccessibleTableShape_Base::release();
 377 }
 378
 379
 380 // XAccessible
 381
 382
 383 Reference< XAccessibleContext > SAL_CALL AccessibleTableShape::getAccessibleContext() throw (RuntimeException, std::exception)
 384 {
 385     return AccessibleShape::getAccessibleContext ();
 386 }
 387
 388
 389 OUString SAL_CALL AccessibleTableShape::getImplementationName() throw (RuntimeException, std::exception)
 390 {
 391     return OUString( "com.sun.star.comp.accessibility.AccessibleTableShape" );
 392 }
 393
 394
 395
 396 OUString AccessibleTableShape::CreateAccessibleBaseName() throw (RuntimeException)
 397 {
 398     return OUString("TableShape");
 399 }
 400
 401
 402
 403 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleChildCount( ) throw(RuntimeException, std::exception)
 404 {
 405     SolarMutexGuard aSolarGuard;
 406     return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() * mxImpl->mxTable->getColumnCount() : 0;
 407 }
 408
 409
 410 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException, std::exception)
 411 {
 412     SolarMutexGuard aSolarGuard;
 413     ThrowIfDisposed();
 414
 415     return mxImpl->getAccessibleChild( i );
 416 }
 417
 418
 419 Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableShape::getAccessibleRelationSet(  ) throw (RuntimeException, std::exception)
 420 {
 421     return AccessibleShape::getAccessibleRelationSet( );
 422 }
 423
 424
 425
 426 sal_Int16 SAL_CALL AccessibleTableShape::getAccessibleRole() throw (RuntimeException, std::exception)
 427 {
 428     return AccessibleRole::TABLE;
 429 }
 430
 431
 432
 433 void SAL_CALL AccessibleTableShape::disposing()
 434 {
 435     mxImpl->dispose();
 436
 437     // let the base do it's stuff
 438     AccessibleShape::disposing();
 439 }
 440
 441
 442 // XAccessibleTable
 443
 444
 445 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowCount() throw (RuntimeException, std::exception)
 446 {
 447     SolarMutexGuard aSolarGuard;
 448     return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() : 0;
 449 }
 450
 451
 452
 453 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnCount(  ) throw (RuntimeException, std::exception)
 454 {
 455     SolarMutexGuard aSolarGuard;
 456     return mxImpl->mxTable.is() ? mxImpl->mxTable->getColumnCount() : 0;
 457 }
 458
 459
 460
 461 OUString SAL_CALL AccessibleTableShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 462 {
 463     checkCellPosition( 0, nRow );
 464     return OUString();
 465 }
 466
 467
 468
 469 OUString SAL_CALL AccessibleTableShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 470 {
 471     SolarMutexGuard aSolarGuard;
 472     checkCellPosition( nColumn, 0 );
 473     return OUString();
 474 }
 475
 476
 477
 478 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 479 {
 480     SolarMutexGuard aSolarGuard;
 481     checkCellPosition( nColumn, nRow );
 482     if( mxImpl->mxTable.is() )
 483     {
 484         Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
 485         if( xCell.is() )
 486             return xCell->getRowSpan();
 487     }
 488     return 1;
 489 }
 490
 491
 492
 493 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 494 {
 495     SolarMutexGuard aSolarGuard;
 496     checkCellPosition( nColumn, nRow );
 497     if( mxImpl->mxTable.is() )
 498     {
 499         Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
 500         if( xCell.is() )
 501             return xCell->getColumnSpan();
 502     }
 503     return 1;
 504 }
 505
 506
 507
 508 Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleRowHeaders(  ) throw (RuntimeException, std::exception)
 509 {
 510     Reference< XAccessibleTable > xRet;
 511     SvxTableController* pController = getTableController();
 512     if( pController )
 513     {
 514         if( pController->isRowHeader() )
 515         {
 516             AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, true );
 517             xRet.set( pTableHeader );
 518         }
 519     }
 520     return xRet;
 521 }
 522
 523
 524
 525 Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleColumnHeaders(  ) throw (RuntimeException, std::exception)
 526 {
 527     Reference< XAccessibleTable > xRet;
 528     SvxTableController* pController = getTableController();
 529     if( pController )
 530     {
 531         if( pController->isColumnHeader() )
 532         {
 533             AccessibleTableHeaderShape* pTableHeader = new AccessibleTableHeaderShape( this, false );
 534             xRet.set( pTableHeader );
 535         }
 536     }
 537     return xRet;
 538 }
 539
 540
 541
 542 Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleRows(  ) throw (RuntimeException, std::exception)
 543 {
 544     sal_Int32 nRow = getAccessibleRowCount();
 545     ::std::vector< sal_Bool > aSelected( nRow, sal_True );
 546     sal_Int32 nCount = nRow;
 547     for( sal_Int32 i = 0; i < nRow; i++ )
 548     {
 549         try
 550         {
 551             aSelected[i] = isAccessibleRowSelected( i );
 552         }
 553         catch( ... )
 554         {
 555             return Sequence< sal_Int32 >();
 556         }
 557
 558         if( !aSelected[i] )
 559             nCount--;
 560     }
 561     Sequence < sal_Int32 > aRet( nCount );
 562     sal_Int32 *pRet = aRet.getArray();
 563     sal_Int32 nPos = 0;
 564     size_t nSize = aSelected.size();
 565     for( size_t i=0; i < nSize && nPos < nCount; i++ )
 566     {
 567         if( aSelected[i] )
 568         {
 569             *pRet++ = i;
 570             nPos++;
 571         }
 572     }
 573
 574     return aRet;
 575 }
 576
 577
 578
 579 Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleColumns(  ) throw (RuntimeException, std::exception)
 580 {
 581     sal_Int32 nColumn = getAccessibleColumnCount();
 582     ::std::vector< sal_Bool > aSelected( nColumn, sal_True );
 583     sal_Int32 nCount = nColumn;
 584     for( sal_Int32 i = 0; i < nColumn; i++ )
 585     {
 586         try
 587         {
 588             aSelected[i] = isAccessibleColumnSelected( i );
 589         }
 590         catch( ... )
 591         {
 592             return Sequence< sal_Int32 >();
 593         }
 594
 595         if( !aSelected[i] )
 596             nCount--;
 597     }
 598     Sequence < sal_Int32 > aRet( nCount );
 599     sal_Int32 *pRet = aRet.getArray();
 600     sal_Int32 nPos = 0;
 601     size_t nSize = aSelected.size();
 602     for( size_t i=0; i < nSize && nPos < nCount; i++ )
 603     {
 604         if( aSelected[i] )
 605         {
 606             *pRet++ = i;
 607             nPos++;
 608         }
 609     }
 610
 611     return aRet;
 612 }
 613
 614
 615
 616 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 617 {
 618     SolarMutexGuard aSolarGuard;
 619     checkCellPosition( 0, nRow );
 620     SvxTableController* pController = getTableController();
 621     if( pController )
 622     {
 623         return pController->isRowSelected( nRow );
 624     }
 625     return sal_False;
 626 }
 627
 628
 629
 630 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 631 {
 632     SolarMutexGuard aSolarGuard;
 633     checkCellPosition( nColumn, 0 );
 634     SvxTableController* pController = getTableController();
 635     if( pController )
 636     {
 637         return pController->isColumnSelected( nColumn );
 638     }
 639     return sal_False;
 640 }
 641
 642
 643
 644 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 645 {
 646     SolarMutexGuard aSolarGuard;
 647     checkCellPosition( nColumn, nRow );
 648
 649     sal_Int32 nChildIndex = 0;
 650     if( mxImpl->mxTable.is() )
 651         nChildIndex = mxImpl->mxTable->getColumnCount() * nRow + nColumn;
 652
 653     return getAccessibleChild( nChildIndex );
 654 }
 655
 656
 657
 658 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCaption(  ) throw (RuntimeException, std::exception)
 659 {
 660     Reference< XAccessible > xRet;
 661     return xRet;
 662 }
 663
 664
 665
 666 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleSummary(  ) throw (RuntimeException, std::exception)
 667 {
 668     Reference< XAccessible > xRet;
 669     return xRet;
 670 }
 671
 672
 673
 674 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 675 {
 676     SolarMutexGuard aSolarGuard;
 677     checkCellPosition( nColumn, nRow );
 678
 679     SvxTableController* pController = getTableController();
 680     if( pController && pController->hasSelectedCells() )
 681     {
 682         CellPos aFirstPos, aLastPos;
 683         pController->getSelectedCells( aFirstPos, aLastPos );
 684         if( (aFirstPos.mnRow <= nRow) && (aFirstPos.mnCol <= nColumn) && (nRow <= aLastPos.mnRow) && (nColumn <= aLastPos.mnCol) )
 685             return sal_True;
 686     }
 687
 688     return sal_False;
 689 }
 690
 691
 692
 693 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 694 {
 695     SolarMutexGuard aSolarGuard;
 696     checkCellPosition( nColumn, nRow );
 697     return  mxImpl->mxTable.is() ? (nRow * mxImpl->mxTable->getColumnCount() + nColumn) : 0;
 698 }
 699
 700
 701
 702 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 703 {
 704     SolarMutexGuard aSolarGuard;
 705     sal_Int32 nColumn = 0, nRow = 0;
 706     mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
 707     return nRow;
 708 }
 709
 710
 711
 712 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 713 {
 714     SolarMutexGuard aSolarGuard;
 715     sal_Int32 nColumn = 0, nRow = 0;
 716     mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
 717     return nColumn;
 718 }
 719
 720
 721 // XAccessibleSelection
 722
 723
 724 void SAL_CALL AccessibleTableShape::selectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
 725 {
 726     SolarMutexGuard aSolarGuard;
 727     CellPos aPos;
 728     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 729
 730     // todo, select table shape?!?
 731     SvxTableController* pController = getTableController();
 732     if( pController )
 733     {
 734         CellPos aFirstPos( aPos ), aLastPos( aPos );
 735         if( pController->hasSelectedCells() )
 736         {
 737             pController->getSelectedCells( aFirstPos, aLastPos );
 738
 739             aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow );
 740             aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol );
 741             aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow );
 742             aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol );
 743         }
 744         pController->setSelectedCells( aFirstPos, aLastPos );
 745     }
 746 }
 747
 748
 749
 750 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
 751 {
 752     SolarMutexGuard aSolarGuard;
 753     CellPos aPos;
 754     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 755
 756     return isAccessibleSelected(aPos.mnRow, aPos.mnCol);
 757 }
 758
 759
 760
 761 void SAL_CALL AccessibleTableShape::clearAccessibleSelection() throw ( RuntimeException, std::exception )
 762 {
 763    SolarMutexGuard aSolarGuard;
 764
 765     SvxTableController* pController = getTableController();
 766     if( pController )
 767         pController->clearSelection();
 768 }
 769
 770
 771 void SAL_CALL AccessibleTableShape::selectAllAccessibleChildren() throw ( RuntimeException, std::exception )
 772 {
 773    SolarMutexGuard aSolarGuard;
 774
 775    // todo: force selection of shape?
 776     SvxTableController* pController = getTableController();
 777     if( pController )
 778         pController->selectAll();
 779 }
 780
 781
 782
 783 sal_Int32 SAL_CALL AccessibleTableShape::getSelectedAccessibleChildCount() throw ( RuntimeException, std::exception )
 784 {
 785     SolarMutexGuard aSolarGuard;
 786
 787     SvxTableController* pController = getTableController();
 788     if( pController && pController->hasSelectedCells() )
 789     {
 790         CellPos aFirstPos, aLastPos;
 791         pController->getSelectedCells( aFirstPos, aLastPos );
 792
 793         const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1;
 794         const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1;
 795         return nSelectedRows * nSelectedColumns;
 796     }
 797
 798     return 0;
 799 }
 800
 801
 802
 803 Reference< XAccessible > SAL_CALL AccessibleTableShape::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException, std::exception)
 804 {
 805     SolarMutexGuard aSolarGuard;
 806
 807     if( nSelectedChildIndex < 0 )
 808         throw IndexOutOfBoundsException();
 809
 810     sal_Int32 nChildIndex = GetIndexOfSelectedChild( nSelectedChildIndex );
 811
 812     if( nChildIndex < 0 )
 813         throw IndexOutOfBoundsException();
 814
 815     if ( nChildIndex >= getAccessibleChildCount() )
 816     {
 817         throw IndexOutOfBoundsException();
 818     }
 819
 820     return getAccessibleChild( nChildIndex );
 821 }
 822
 823
 824
 825 void SAL_CALL AccessibleTableShape::deselectAccessibleChild( sal_Int32 nChildIndex )  throw ( IndexOutOfBoundsException, RuntimeException, std::exception )
 826 {
 827    SolarMutexGuard aSolarGuard;
 828     CellPos aPos;
 829     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 830
 831     // todo, select table shape?!?
 832     SvxTableController* pController = getTableController();
 833     if( pController && pController->hasSelectedCells() )
 834     {
 835         CellPos aFirstPos, aLastPos;
 836         pController->getSelectedCells( aFirstPos, aLastPos );
 837
 838         // create a selection where aPos is not part of anymore
 839         aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow+1 );
 840         aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol+1 );
 841         aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow-1 );
 842         aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol-1 );
 843
 844         // new selection may be invalid (child to deselect is not at a border of the selection but in between)
 845         if( (aFirstPos.mnRow > aLastPos.mnRow) || (aFirstPos.mnCol > aLastPos.mnCol) )
 846             pController->clearSelection(); // if selection is invalid, clear all
 847         else
 848             pController->setSelectedCells( aFirstPos, aLastPos );
 849     }
 850 }
 851
 852 // XAccessibleTableSelection
 853 sal_Bool SAL_CALL AccessibleTableShape::selectRow( sal_Int32 row )
 854 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 855 {
 856     SolarMutexGuard aSolarGuard;
 857     SvxTableController* pController = getTableController();
 858     if( !pController )
 859         return sal_False;
 860     return pController->selectRow( row );
 861 }
 862
 863 sal_Bool SAL_CALL AccessibleTableShape::selectColumn( sal_Int32 column )
 864     throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 865 {
 866     SolarMutexGuard aSolarGuard;
 867     SvxTableController* pController = getTableController();
 868     if( !pController )
 869         return sal_False;
 870     return pController->selectColumn( column );
 871 }
 872
 873 sal_Bool SAL_CALL AccessibleTableShape::unselectRow( sal_Int32 row )
 874 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 875 {
 876     SolarMutexGuard aSolarGuard;
 877     SvxTableController* pController = getTableController();
 878     if( !pController )
 879         return sal_False;
 880     return pController->deselectRow( row );
 881 }
 882
 883 sal_Bool SAL_CALL AccessibleTableShape::unselectColumn( sal_Int32 column )
 884 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
 885 {
 886     SolarMutexGuard aSolarGuard;
 887     SvxTableController* pController = getTableController();
 888     if( !pController )
 889         return sal_False;
 890     return pController->deselectColumn( column );
 891 }
 892
 893 sal_Int32 AccessibleTableShape::GetIndexOfSelectedChild(
 894                 sal_Int32 nSelectedChildIndex ) const
 895 {
 896     sal_Int32 nChildren = const_cast<AccessibleTableShape*>(this)->getAccessibleChildCount();
 897
 898     if( nSelectedChildIndex >= nChildren )
 899         return -1L;
 900
 901     sal_Int32 n = 0;
 902     while( n < nChildren )
 903     {
 904         if( const_cast<AccessibleTableShape*>(this)->isAccessibleChildSelected( n ) )
 905         {
 906             if( 0 == nSelectedChildIndex )
 907                 break;
 908             else
 909                 --nSelectedChildIndex;
 910         }
 911         ++n;
 912     }
 913
 914     return n < nChildren ? n : -1L;
 915 }
 916 void AccessibleTableShape::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException )
 917 {
 918     mxImpl->getColumnAndRow(nChildIndex, rnColumn, rnRow);
 919 }
 920
 921 // XSelectionChangeListener
 922 void SAL_CALL
 923     AccessibleTableShape::disposing (const EventObject& aEvent)
 924     throw (RuntimeException, std::exception)
 925 {
 926     AccessibleShape::disposing(aEvent);
 927 }
 928 void  SAL_CALL AccessibleTableShape::selectionChanged (const EventObject& rEvent)
 929         throw (RuntimeException, std::exception)
 930 {
 931     //sdr::table::CellRef xCellRef = static_cast< sdr::table::CellRef > (rEvent.Source);
 932     Reference< XCell > xCell(rEvent.Source, UNO_QUERY);
 933     if (xCell.is())
 934     {
 935         Reference< AccessibleCell > xAccCell = mxImpl->getAccessibleCell( xCell );
 936         if (xAccCell.is())
 937         {
 938             sal_Int32 nIndex = xAccCell->getAccessibleIndexInParent(),
 939                 nCount = getSelectedAccessibleChildCount();
 940             bool bSelected = isAccessibleChildSelected(nIndex);
 941             if (mnPreviousSelectionCount == 0 && nCount > 0 && bSelected)
 942             {
 943                 xAccCell->SetState(AccessibleStateType::SELECTED);
 944                 xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED, Any(), Any());
 945             }
 946             else if (bSelected)
 947             {
 948                 xAccCell->SetState(AccessibleStateType::SELECTED);
 949                 xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_ADD, Any(), Any());
 950             }
 951             else
 952             {
 953                 xAccCell->ResetState(AccessibleStateType::SELECTED);
 954                 xAccCell->CommitChange(AccessibleEventId::SELECTION_CHANGED_REMOVE, Any(), Any());
 955             }
 956             mnPreviousSelectionCount = nCount;
 957         }
 958     }
 959 }
 960 // Get the currently active cell which is text editing
 961 AccessibleCell* AccessibleTableShape::GetActiveAccessibleCell()
 962 {
 963     Reference< AccessibleCell > xAccCell;
 964     AccessibleCell* pAccCell = NULL;
 965     SvxTableController* pController = getTableController();
 966     if (pController)
 967     {
 968         sdr::table::SdrTableObj* pTableObj = pController->GetTableObj();
 969         if ( pTableObj )
 970         {
 971             sdr::table::CellRef xCellRef (pTableObj->getActiveCell());
 972             if ( xCellRef.is() )
 973             {
 974                 const bool bCellEditing = xCellRef->IsTextEditActive();
 975                 if (bCellEditing)
 976                 {
 977                     //Reference< XCell > xCell(xCellRef.get(), UNO_QUERY);
 978                     xAccCell = mxImpl->getAccessibleCell(Reference< XCell >( xCellRef.get() ));
 979                     if (xAccCell.is())
 980                         pAccCell = xAccCell.get();
 981                 }
 982             }
 983         }
 984     }
 985     return pAccCell;
 986 }
 987
 988 //If current active cell is in editing, the focus state should be set to internal text
 989 bool AccessibleTableShape::SetState (sal_Int16 aState)
 990 {
 991     AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell();
 992     bool bStateHasChanged = false;
 993     if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL)
 994     {
 995         return pActiveAccessibleCell->SetState(aState);
 996     }
 997     else
 998         bStateHasChanged = AccessibleShape::SetState (aState);
 999     return bStateHasChanged;
1000 }
1001
1002 //If current active cell is in editing, the focus state should be reset to internal text
1003 bool AccessibleTableShape::ResetState (sal_Int16 aState)
1004 {
1005     AccessibleCell* pActiveAccessibleCell = GetActiveAccessibleCell();
1006     bool bStateHasChanged = false;
1007     if (aState == AccessibleStateType::FOCUSED && pActiveAccessibleCell != NULL)
1008     {
1009         return pActiveAccessibleCell->ResetState(aState);
1010     }
1011     else
1012         bStateHasChanged = AccessibleShape::ResetState (aState);
1013     return bStateHasChanged;
1014 }
1015
1016 bool AccessibleTableShape::SetStateDirectly (sal_Int16 aState)
1017 {
1018     return AccessibleContextBase::SetState (aState);
1019 }
1020
1021 bool AccessibleTableShape::ResetStateDirectly (sal_Int16 aState)
1022 {
1023     return AccessibleContextBase::ResetState (aState);
1024 }
1025
1026 void AccessibleTableShape::checkCellPosition( sal_Int32 nCol, sal_Int32 nRow ) throw ( IndexOutOfBoundsException )
1027 {
1028     if( (nCol >= 0) && (nRow >= 0) && mxImpl->mxTable.is() && (nCol < mxImpl->mxTable->getColumnCount()) && (nRow < mxImpl->mxTable->getRowCount()) )
1029         return;
1030
1031     throw IndexOutOfBoundsException();
1032 }
1033
1034 AccessibleTableHeaderShape::AccessibleTableHeaderShape( AccessibleTableShape* pTable, bool bRow )
1035 {
1036     mpTable = pTable;
1037     mbRow = bRow;
1038 }
1039
1040 AccessibleTableHeaderShape::~AccessibleTableHeaderShape()
1041 {
1042     mpTable = NULL;
1043 }
1044
1045 // XAccessible
1046 Reference< XAccessibleContext > SAL_CALL AccessibleTableHeaderShape::getAccessibleContext() throw (RuntimeException, std::exception)
1047 {
1048     return this;
1049 }
1050
1051 // XAccessibleContext
1052 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleChildCount( ) throw(RuntimeException, std::exception)
1053 {
1054     return getAccessibleRowCount() * getAccessibleColumnCount();
1055 }
1056
1057 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException, std::exception)
1058 {
1059     return mpTable->getAccessibleChild( i );
1060 }
1061
1062 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleParent() throw (RuntimeException, std::exception)
1063 {
1064     Reference< XAccessible > XParent;
1065     return XParent;
1066 }
1067
1068 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndexInParent() throw (RuntimeException, std::exception)
1069 {
1070     return -1;
1071 }
1072
1073 sal_Int16 SAL_CALL AccessibleTableHeaderShape::getAccessibleRole() throw (RuntimeException, std::exception)
1074 {
1075     return mpTable->getAccessibleRole();
1076 }
1077
1078 OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleDescription() throw (RuntimeException, std::exception)
1079 {
1080     return mpTable->getAccessibleDescription();
1081 }
1082
1083 OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleName() throw (RuntimeException, std::exception)
1084 {
1085     return mpTable->getAccessibleName();
1086 }
1087
1088 Reference< XAccessibleStateSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleStateSet() throw (RuntimeException, std::exception)
1089 {
1090     return mpTable->getAccessibleStateSet();
1091 }
1092
1093 Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableHeaderShape::getAccessibleRelationSet() throw (RuntimeException, std::exception)
1094 {
1095     return mpTable->getAccessibleRelationSet();
1096 }
1097
1098 Locale SAL_CALL AccessibleTableHeaderShape::getLocale() throw (IllegalAccessibleComponentStateException, RuntimeException, std::exception)
1099 {
1100     return mpTable->getLocale();
1101 }
1102
1103 //XAccessibleComponent
1104 sal_Bool SAL_CALL AccessibleTableHeaderShape::containsPoint ( const ::com::sun::star::awt::Point& aPoint ) throw (RuntimeException, std::exception)
1105 {
1106     return mpTable->containsPoint( aPoint );
1107 }
1108
1109 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleAtPoint ( const ::com::sun::star::awt::Point& aPoint) throw (RuntimeException, std::exception)
1110 {
1111     return mpTable->getAccessibleAtPoint( aPoint );
1112 }
1113
1114 ::com::sun::star::awt::Rectangle SAL_CALL AccessibleTableHeaderShape::getBounds() throw (RuntimeException, std::exception)
1115 {
1116     return mpTable->getBounds();
1117 }
1118
1119 ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocation() throw (RuntimeException, std::exception)
1120 {
1121     return mpTable->getLocation();
1122 }
1123
1124 ::com::sun::star::awt::Point SAL_CALL AccessibleTableHeaderShape::getLocationOnScreen() throw (RuntimeException, std::exception)
1125 {
1126     return mpTable->getLocationOnScreen();
1127 }
1128
1129 ::com::sun::star::awt::Size SAL_CALL AccessibleTableHeaderShape::getSize() throw (RuntimeException, std::exception)
1130 {
1131     return mpTable->getSize();
1132 }
1133
1134 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getForeground() throw (RuntimeException, std::exception)
1135 {
1136     return mpTable->getForeground();
1137 }
1138
1139 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getBackground() throw (RuntimeException, std::exception)
1140 {
1141     return mpTable->getBackground();
1142 }
1143
1144 void SAL_CALL AccessibleTableHeaderShape::grabFocus() throw (RuntimeException, std::exception)
1145 {
1146     mpTable->grabFocus();
1147 }
1148 // XAccessibleTable
1149 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowCount() throw (RuntimeException, std::exception)
1150 {
1151     return mbRow ? 1 : mpTable->getAccessibleRowCount();
1152 }
1153
1154 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnCount() throw (RuntimeException, std::exception)
1155 {
1156     return !mbRow ? 1 : mpTable->getAccessibleColumnCount();
1157 }
1158
1159 OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1160 {
1161     return mpTable->getAccessibleRowDescription( nRow );
1162 }
1163
1164 OUString SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1165 {
1166     return mpTable->getAccessibleColumnDescription( nColumn );
1167 }
1168
1169 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1170 {
1171     return mpTable->getAccessibleRowExtentAt( nRow, nColumn );
1172 }
1173
1174 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1175 {
1176     return mpTable->getAccessibleColumnExtentAt( nRow, nColumn );
1177 }
1178
1179 Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleRowHeaders(  ) throw (RuntimeException, std::exception)
1180 {
1181     Reference< XAccessibleTable > xRet;
1182     return xRet;
1183 }
1184
1185 Reference< XAccessibleTable > SAL_CALL AccessibleTableHeaderShape::getAccessibleColumnHeaders(  ) throw (RuntimeException, std::exception)
1186 {
1187     Reference< XAccessibleTable > xRet;
1188     return xRet;
1189 }
1190
1191 Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleRows(  ) throw (RuntimeException, std::exception)
1192 {
1193     sal_Int32 nRow = getAccessibleRowCount();
1194     ::std::vector< sal_Bool > aSelected( nRow, sal_True );
1195     sal_Int32 nCount = nRow;
1196     for( sal_Int32 i = 0; i < nRow; i++ )
1197     {
1198         try
1199         {
1200             aSelected[i] = isAccessibleRowSelected( i );
1201         }
1202         catch( ... )
1203         {
1204             return Sequence< sal_Int32 >();
1205         }
1206
1207         if( !aSelected[i] )
1208             nCount--;
1209     }
1210     Sequence < sal_Int32 > aRet( nCount );
1211     sal_Int32 *pRet = aRet.getArray();
1212     sal_Int32 nPos = 0;
1213     size_t nSize = aSelected.size();
1214     for( size_t i=0; i < nSize && nPos < nCount; i++ )
1215     {
1216         if( aSelected[i] )
1217         {
1218             *pRet++ = i;
1219             nPos++;
1220         }
1221     }
1222
1223     return aRet;
1224 }
1225
1226 Sequence< sal_Int32 > SAL_CALL AccessibleTableHeaderShape::getSelectedAccessibleColumns(  ) throw (RuntimeException, std::exception)
1227 {
1228     sal_Int32 nColumn = getAccessibleColumnCount();
1229     ::std::vector< sal_Bool > aSelected( nColumn, sal_True );
1230     sal_Int32 nCount = nColumn;
1231     for( sal_Int32 i = 0; i < nColumn; i++ )
1232     {
1233         try
1234         {
1235             aSelected[i] = isAccessibleColumnSelected( i );
1236         }
1237         catch( ... )
1238         {
1239             return Sequence< sal_Int32 >();
1240         }
1241
1242         if( !aSelected[i] )
1243             nCount--;
1244     }
1245     Sequence < sal_Int32 > aRet( nCount );
1246     sal_Int32 *pRet = aRet.getArray();
1247     sal_Int32 nPos = 0;
1248     size_t nSize = aSelected.size();
1249     for( size_t i=0; i < nSize && nPos < nCount; i++ )
1250     {
1251         if( aSelected[i] )
1252         {
1253             *pRet++ = i;
1254             nPos++;
1255         }
1256     }
1257
1258     return aRet;
1259 }
1260
1261 sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1262 {
1263     return mpTable->isAccessibleRowSelected( nRow );
1264 }
1265
1266 sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1267 {
1268     return mpTable->isAccessibleColumnSelected( nColumn );
1269 }
1270
1271 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1272 {
1273     return mpTable->getAccessibleCellAt( nRow, nColumn );
1274 }
1275
1276 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleCaption(  ) throw (RuntimeException, std::exception)
1277 {
1278     return mpTable->getAccessibleCaption();
1279 }
1280
1281 Reference< XAccessible > SAL_CALL AccessibleTableHeaderShape::getAccessibleSummary(  ) throw (RuntimeException, std::exception)
1282 {
1283     return mpTable->getAccessibleSummary();
1284 }
1285
1286 sal_Bool SAL_CALL AccessibleTableHeaderShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1287 {
1288     return mpTable->isAccessibleSelected( nRow, nColumn );
1289 }
1290
1291 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1292 {
1293     return mpTable->getAccessibleIndex( nRow, nColumn );
1294 }
1295
1296 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1297 {
1298     return mpTable->getAccessibleRow( nChildIndex );
1299 }
1300
1301 sal_Int32 SAL_CALL AccessibleTableHeaderShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1302 {
1303     return mpTable->getAccessibleColumn( nChildIndex );
1304 }
1305
1306 // XAccessibleTableSelection
1307 sal_Bool SAL_CALL AccessibleTableHeaderShape::selectRow( sal_Int32 row )
1308 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1309 {
1310     if( mbRow )
1311         return mpTable->selectRow( row );
1312     else
1313     {
1314         mpTable->clearAccessibleSelection();
1315         sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 );
1316         mpTable->selectAccessibleChild( nIndex );
1317         return sal_True;
1318     }
1319 }
1320
1321 sal_Bool SAL_CALL AccessibleTableHeaderShape::selectColumn( sal_Int32 column )
1322 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1323 {
1324     if( !mbRow )
1325         return mpTable->selectColumn( column );
1326     else
1327     {
1328         mpTable->clearAccessibleSelection();
1329         sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column );
1330         mpTable->selectAccessibleChild( nIndex );
1331         return sal_True;
1332     }
1333 }
1334
1335 sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectRow( sal_Int32 row )
1336 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1337 {
1338     if( mbRow )
1339         return mpTable->unselectRow( row );
1340     else
1341     {
1342         sal_Int32 nIndex = mpTable->getAccessibleIndex( row, 0 );
1343         mpTable->deselectAccessibleChild( nIndex );
1344         return sal_True;
1345     }
1346 }
1347
1348 sal_Bool SAL_CALL AccessibleTableHeaderShape::unselectColumn( sal_Int32 column )
1349 throw (IndexOutOfBoundsException, RuntimeException, std::exception)
1350 {
1351     if( !mbRow )
1352         return mpTable->unselectColumn( column );
1353     else
1354     {
1355         sal_Int32 nIndex = mpTable->getAccessibleIndex( 0, column );
1356         mpTable->deselectAccessibleChild( nIndex );
1357         return sal_True;
1358     }
1359 }
1360 }
1361
1362 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */