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