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