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