svx/source/table/accessibletableshape.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: accessibletableshape.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 #include <com/sun/star/table/XMergeableCell.hpp>
  35 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  36 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  37
  38 #include <comphelper/accessiblewrapper.hxx>
  39 #include <vos/mutex.hxx>
  40 #include <tools/debug.hxx>
  41 #include <vcl/svapp.hxx>
  42
  43 #include <svx/AccessibleTableShape.hxx>
  44 #include "tablecontroller.hxx"
  45 #include "accessiblecell.hxx"
  46
  47 #include <algorithm>
  48
  49 #include <cppuhelper/implbase1.hxx>
  50
  51 using ::rtl::OUString;
  52
  53 using namespace ::accessibility;
  54 using namespace ::sdr::table;
  55 using namespace ::com::sun::star::accessibility;
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::beans;
  58 using namespace ::com::sun::star::util;
  59 using namespace ::com::sun::star::lang;
  60 using namespace ::com::sun::star::drawing;
  61 using namespace ::com::sun::star::table;
  62 using namespace ::com::sun::star::container;
  63
  64 #define C2U(x) OUString(RTL_CONSTASCII_USTRINGPARAM(x))
  65
  66 namespace accessibility
  67 {
  68
  69 struct hash
  70 {
  71     std::size_t operator()( const Reference< XCell >& xCell ) const
  72     {
  73         return std::size_t( xCell.get() );
  74     }
  75 };
  76
  77 typedef std::hash_map< Reference< XCell >, rtl::Reference< AccessibleCell >, hash > AccessibleCellMap;
  78
  79 //-----------------------------------------------------------------------------
  80 // AccessibleTableShapeImpl
  81 //-----------------------------------------------------------------------------
  82
  83 class AccessibleTableShapeImpl : public cppu::WeakImplHelper1< XModifyListener >
  84 {
  85 public:
  86     AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo );
  87
  88     void init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable );
  89     void dispose();
  90
  91     Reference< XAccessible > getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException);
  92     void getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException );
  93
  94     // XModifyListener
  95     virtual void SAL_CALL modified( const EventObject& aEvent ) throw (RuntimeException);
  96
  97     // XEventListener
  98     virtual void SAL_CALL disposing( const EventObject& Source ) throw (RuntimeException);
  99
 100     AccessibleShapeTreeInfo& mrShapeTreeInfo;
 101     Reference< XTable > mxTable;
 102     AccessibleCellMap maChildMap;
 103     Reference< XAccessible> mxAccessible;
 104 };
 105
 106 //-----------------------------------------------------------------------------
 107
 108 AccessibleTableShapeImpl::AccessibleTableShapeImpl( AccessibleShapeTreeInfo& rShapeTreeInfo )
 109 : mrShapeTreeInfo( rShapeTreeInfo )
 110 {
 111 }
 112
 113 //-----------------------------------------------------------------------------
 114
 115 void AccessibleTableShapeImpl::init( const Reference< XAccessible>& xAccessible, const Reference< XTable >& xTable )
 116 {
 117     mxAccessible = xAccessible;
 118     mxTable = xTable;
 119
 120     if( mxTable.is() )
 121     {
 122         Reference< XModifyListener > xListener( this );
 123         mxTable->addModifyListener( xListener );
 124     }
 125 }
 126
 127 //-----------------------------------------------------------------------------
 128
 129 void AccessibleTableShapeImpl::dispose()
 130 {
 131     if( mxTable.is() )
 132     {
 133         Reference< XModifyListener > xListener( this );
 134         mxTable->removeModifyListener( xListener );
 135         mxTable.clear();
 136     }
 137     mxAccessible.clear();
 138 }
 139
 140 //-----------------------------------------------------------------------------
 141
 142 Reference< XAccessible > AccessibleTableShapeImpl::getAccessibleChild( sal_Int32 nChildIndex ) throw(IndexOutOfBoundsException)
 143 {
 144     sal_Int32 nColumn = 0, nRow = 0;
 145     getColumnAndRow( nChildIndex, nColumn, nRow );
 146
 147     Reference< XCell > xCell( mxTable->getCellByPosition( nColumn, nRow ) );
 148     AccessibleCellMap::iterator iter( maChildMap.find( xCell ) );
 149
 150     if( iter != maChildMap.end() )
 151     {
 152         Reference< XAccessible > xChild( (*iter).second.get() );
 153         return xChild;
 154     }
 155     else
 156     {
 157         CellRef xCellRef( dynamic_cast< Cell* >( xCell.get() ) );
 158
 159         rtl::Reference< AccessibleCell > xAccessibleCell( new AccessibleCell( mxAccessible, xCellRef, nChildIndex, mrShapeTreeInfo ) );
 160
 161         maChildMap[xCell] = xAccessibleCell;
 162
 163         xAccessibleCell->Init();
 164
 165         Reference< XAccessible > xChild( xAccessibleCell.get() );
 166         return xChild;
 167     }
 168 }
 169
 170 //-----------------------------------------------------------------------------
 171
 172 void AccessibleTableShapeImpl::getColumnAndRow( sal_Int32 nChildIndex, sal_Int32& rnColumn, sal_Int32& rnRow ) throw (IndexOutOfBoundsException )
 173 {
 174     rnRow = 0;
 175     rnColumn = nChildIndex;
 176
 177     if( mxTable.is() )
 178     {
 179         const sal_Int32 nColumnCount = mxTable->getColumnCount();
 180         while( rnColumn >= nColumnCount )
 181         {
 182             rnRow++;
 183             rnColumn -= nColumnCount;
 184         }
 185
 186         if( rnRow < mxTable->getRowCount() )
 187             return;
 188     }
 189
 190     throw IndexOutOfBoundsException();
 191 }
 192
 193 // XModifyListener
 194 void SAL_CALL AccessibleTableShapeImpl::modified( const EventObject& /*aEvent*/ ) throw (RuntimeException)
 195 {
 196     if( mxTable.is() ) try
 197     {
 198         // structural changes may have happened to the table, validate all accessible cell instances
 199         AccessibleCellMap aTempChildMap;
 200         aTempChildMap.swap( maChildMap );
 201
 202         // first move all still existing cells to maChildMap again and update their index
 203
 204         const sal_Int32 nRowCount = mxTable->getRowCount();
 205         const sal_Int32 nColCount = mxTable->getColumnCount();
 206
 207         sal_Int32 nChildIndex = 0;
 208
 209         for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 210         {
 211             for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 212             {
 213                 Reference< XCell > xCell( mxTable->getCellByPosition( nCol, nRow ) );
 214                 AccessibleCellMap::iterator iter( aTempChildMap.find( xCell ) );
 215
 216                 if( iter != aTempChildMap.end() )
 217                 {
 218                     rtl::Reference< AccessibleCell > xAccessibleCell( (*iter).second );
 219                     xAccessibleCell->setIndexInParent( nChildIndex );
 220                     xAccessibleCell->CommitChange(AccessibleEventId::VISIBLE_DATA_CHANGED, Any(), Any());
 221
 222                     // move still existing cell from temporary child map to our child map
 223                     maChildMap[xCell] = xAccessibleCell;
 224                     aTempChildMap.erase( iter );
 225                 }
 226
 227                 ++nChildIndex;
 228             }
 229         }
 230
 231         // all accessible cell instances still left in aTempChildMap must be disposed
 232         // as they are no longer part of the table
 233
 234         for( AccessibleCellMap::iterator iter( aTempChildMap.begin() ); iter != aTempChildMap.end(); iter++ )
 235         {
 236             (*iter).second->dispose();
 237         }
 238     }
 239     catch( Exception& )
 240     {
 241         DBG_ERROR("svx::AccessibleTableShape::modified(), exception caught!");
 242     }
 243 }
 244
 245 // XEventListener
 246 void SAL_CALL AccessibleTableShapeImpl::disposing( const EventObject& /*Source*/ ) throw (RuntimeException)
 247 {
 248 }
 249
 250 //-----------------------------------------------------------------------------
 251 // AccessibleTableShape
 252 //-----------------------------------------------------------------------------
 253
 254 //-----------------------------------------------------------------------------
 255
 256 AccessibleTableShape::AccessibleTableShape( const AccessibleShapeInfo& rShapeInfo, const AccessibleShapeTreeInfo& rShapeTreeInfo)
 257 : AccessibleTableShape_Base(rShapeInfo, rShapeTreeInfo)
 258 , mxImpl( new AccessibleTableShapeImpl( maShapeTreeInfo ) )
 259 {
 260 }
 261
 262 //-----------------------------------------------------------------------------
 263
 264 AccessibleTableShape::~AccessibleTableShape (void)
 265 {
 266 }
 267
 268 //-----------------------------------------------------------------------------
 269
 270 void AccessibleTableShape::Init()
 271 {
 272     try
 273     {
 274
 275         Reference< XPropertySet > xSet( mxShape, UNO_QUERY_THROW );
 276         Reference< XTable > xTable( xSet->getPropertyValue(C2U("Model")), UNO_QUERY_THROW );
 277
 278         mxImpl->init( this, xTable );
 279     }
 280     catch( Exception& )
 281     {
 282         DBG_ERROR("AccessibleTableShape::init(), exception caught?");
 283     }
 284
 285     AccessibleTableShape_Base::Init();
 286 }
 287
 288 //-----------------------------------------------------------------------------
 289
 290 SvxTableController* AccessibleTableShape::getTableController()
 291 {
 292     SdrView* pView = maShapeTreeInfo.GetSdrView ();
 293     if( pView )
 294         return dynamic_cast< SvxTableController* >( pView->getSelectionController().get() );
 295     else
 296         return 0;
 297 }
 298
 299 //-----------------------------------------------------------------------------
 300 // XInterface
 301 //-----------------------------------------------------------------------------
 302
 303 Any SAL_CALL AccessibleTableShape::queryInterface( const Type& aType ) throw (RuntimeException)
 304 {
 305     return AccessibleTableShape_Base::queryInterface( aType );
 306 }
 307
 308 //-----------------------------------------------------------------------------
 309
 310 void SAL_CALL AccessibleTableShape::acquire(  ) throw ()
 311 {
 312     AccessibleTableShape_Base::acquire();
 313 }
 314
 315 //-----------------------------------------------------------------------------
 316
 317 void SAL_CALL AccessibleTableShape::release(  ) throw ()
 318 {
 319     AccessibleTableShape_Base::release();
 320 }
 321
 322 //-----------------------------------------------------------------------------
 323 // XAccessible
 324 //-----------------------------------------------------------------------------
 325
 326 Reference< XAccessibleContext > SAL_CALL AccessibleTableShape::getAccessibleContext(void) throw (RuntimeException)
 327 {
 328     return AccessibleShape::getAccessibleContext ();
 329 }
 330
 331 //-----------------------------------------------------------------------------
 332 OUString SAL_CALL AccessibleTableShape::getImplementationName(void) throw (RuntimeException)
 333 {
 334     return OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.accessibility.AccessibleTableShape" ) );
 335 }
 336
 337 //-----------------------------------------------------------------------------
 338
 339 OUString AccessibleTableShape::CreateAccessibleBaseName(void) throw (RuntimeException)
 340 {
 341     return OUString (RTL_CONSTASCII_USTRINGPARAM("TableShape"));;
 342 }
 343
 344 //--------------------------------------------------------------------
 345
 346 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleChildCount( ) throw(RuntimeException)
 347 {
 348     ::vos::OGuard aSolarGuard(::Application::GetSolarMutex());
 349     return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() * mxImpl->mxTable->getColumnCount() : 0;
 350 }
 351
 352 //--------------------------------------------------------------------
 353 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleChild( sal_Int32 i ) throw(IndexOutOfBoundsException, RuntimeException)
 354 {
 355     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 356     ThrowIfDisposed();
 357
 358     return mxImpl->getAccessibleChild( i );
 359 }
 360
 361 //--------------------------------------------------------------------
 362 Reference< XAccessibleRelationSet > SAL_CALL AccessibleTableShape::getAccessibleRelationSet(  ) throw (RuntimeException)
 363 {
 364     return AccessibleShape::getAccessibleRelationSet( );
 365 }
 366
 367 //--------------------------------------------------------------------
 368
 369 sal_Int16 SAL_CALL AccessibleTableShape::getAccessibleRole (void) throw (RuntimeException)
 370 {
 371     return AccessibleRole::TABLE;
 372 }
 373
 374 //--------------------------------------------------------------------
 375
 376 void SAL_CALL AccessibleTableShape::disposing (void)
 377 {
 378     mxImpl->dispose();
 379
 380     // let the base do it's stuff
 381     AccessibleShape::disposing();
 382 }
 383
 384 //--------------------------------------------------------------------
 385 // XAccessibleTable
 386 //--------------------------------------------------------------------
 387
 388 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowCount() throw (RuntimeException)
 389 {
 390     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 391     return mxImpl->mxTable.is() ? mxImpl->mxTable->getRowCount() : 0;
 392 }
 393
 394 //--------------------------------------------------------------------
 395
 396 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnCount(  ) throw (RuntimeException)
 397 {
 398     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 399     return mxImpl->mxTable.is() ? mxImpl->mxTable->getColumnCount() : 0;
 400 }
 401
 402 //--------------------------------------------------------------------
 403
 404 OUString SAL_CALL AccessibleTableShape::getAccessibleRowDescription( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException)
 405 {
 406     checkCellPosition( 0, nRow );
 407     return OUString();
 408 }
 409
 410 //--------------------------------------------------------------------
 411
 412 OUString SAL_CALL AccessibleTableShape::getAccessibleColumnDescription( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 413 {
 414     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 415     checkCellPosition( nColumn, 0 );
 416     return OUString();
 417 }
 418
 419 //--------------------------------------------------------------------
 420
 421 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRowExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 422 {
 423     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 424     checkCellPosition( nColumn, nRow );
 425     if( mxImpl->mxTable.is() )
 426     {
 427         Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
 428         if( xCell.is() )
 429             return xCell->getRowSpan();
 430     }
 431     return 1;
 432 }
 433
 434 //--------------------------------------------------------------------
 435
 436 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumnExtentAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 437 {
 438     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 439     checkCellPosition( nColumn, nRow );
 440     if( mxImpl->mxTable.is() )
 441     {
 442         Reference< XMergeableCell > xCell( mxImpl->mxTable->getCellByPosition( nColumn, nRow ), UNO_QUERY );
 443         if( xCell.is() )
 444             return xCell->getColumnSpan();
 445     }
 446     return 1;
 447 }
 448
 449 //--------------------------------------------------------------------
 450
 451 Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleRowHeaders(  ) throw (RuntimeException)
 452 {
 453     Reference< XAccessibleTable > xRet( this ); // todo
 454     return xRet;
 455 }
 456
 457 //--------------------------------------------------------------------
 458
 459 Reference< XAccessibleTable > SAL_CALL AccessibleTableShape::getAccessibleColumnHeaders(  ) throw (RuntimeException)
 460 {
 461     Reference< XAccessibleTable > xRet( this ); // todo
 462     return xRet;
 463 }
 464
 465 //--------------------------------------------------------------------
 466
 467 Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleRows(  ) throw (RuntimeException)
 468 {
 469     Sequence< sal_Int32 > aRet;
 470     return aRet;
 471 }
 472
 473 //--------------------------------------------------------------------
 474
 475 Sequence< sal_Int32 > SAL_CALL AccessibleTableShape::getSelectedAccessibleColumns(  ) throw (RuntimeException)
 476 {
 477     Sequence< sal_Int32 > aRet;
 478     return aRet;
 479 }
 480
 481 //--------------------------------------------------------------------
 482
 483 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleRowSelected( sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException)
 484 {
 485     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 486     checkCellPosition( 0, nRow );
 487     return sal_False;
 488 }
 489
 490 //--------------------------------------------------------------------
 491
 492 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleColumnSelected( sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 493 {
 494     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 495     checkCellPosition( nColumn, 0 );
 496     return sal_False;
 497 }
 498
 499 //--------------------------------------------------------------------
 500
 501 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCellAt( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 502 {
 503     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 504     checkCellPosition( nColumn, nRow );
 505
 506     sal_Int32 nChildIndex = 0;
 507     if( mxImpl->mxTable.is() )
 508         nChildIndex = mxImpl->mxTable->getColumnCount() * nRow + nColumn;
 509
 510     return getAccessibleChild( nChildIndex );
 511 }
 512
 513 //--------------------------------------------------------------------
 514
 515 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleCaption(  ) throw (RuntimeException)
 516 {
 517     Reference< XAccessible > xRet;
 518     return xRet;
 519 }
 520
 521 //--------------------------------------------------------------------
 522
 523 Reference< XAccessible > SAL_CALL AccessibleTableShape::getAccessibleSummary(  ) throw (RuntimeException)
 524 {
 525     Reference< XAccessible > xRet;
 526     return xRet;
 527 }
 528
 529 //--------------------------------------------------------------------
 530
 531 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleSelected( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 532 {
 533     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 534     checkCellPosition( nColumn, nRow );
 535
 536     SvxTableController* pController = getTableController();
 537     if( pController && pController->hasSelectedCells() )
 538     {
 539         CellPos aFirstPos, aLastPos;
 540         pController->getSelectedCells( aFirstPos, aLastPos );
 541         if( (aFirstPos.mnRow <= nRow) && (aFirstPos.mnCol <= nColumn) && (nRow <= aLastPos.mnRow) && (nColumn <= aLastPos.mnCol) )
 542             return sal_True;
 543     }
 544
 545     return sal_False;
 546 }
 547
 548 //--------------------------------------------------------------------
 549
 550 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleIndex( sal_Int32 nRow, sal_Int32 nColumn ) throw (IndexOutOfBoundsException, RuntimeException)
 551 {
 552     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 553     checkCellPosition( nColumn, nRow );
 554     return  mxImpl->mxTable.is() ? (nRow * mxImpl->mxTable->getColumnCount() + nColumn) : 0;
 555 }
 556
 557 //--------------------------------------------------------------------
 558
 559 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleRow( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 560 {
 561     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 562     sal_Int32 nColumn = 0, nRow = 0;
 563     mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
 564     return nRow;
 565 }
 566
 567 //--------------------------------------------------------------------
 568
 569 sal_Int32 SAL_CALL AccessibleTableShape::getAccessibleColumn( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 570 {
 571     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 572     sal_Int32 nColumn = 0, nRow = 0;
 573     mxImpl->getColumnAndRow( nChildIndex, nColumn, nRow );
 574     return nChildIndex;
 575 }
 576
 577 //--------------------------------------------------------------------
 578 // XAccessibleSelection
 579 //--------------------------------------------------------------------
 580
 581 void SAL_CALL AccessibleTableShape::selectAccessibleChild( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException )
 582 {
 583     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 584     CellPos aPos;
 585     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 586
 587     // todo, select table shape?!?
 588     SvxTableController* pController = getTableController();
 589     if( pController )
 590     {
 591         CellPos aFirstPos( aPos ), aLastPos( aPos );
 592         if( pController->hasSelectedCells() )
 593         {
 594             pController->getSelectedCells( aFirstPos, aLastPos );
 595
 596             aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow );
 597             aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol );
 598             aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow );
 599             aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol );
 600         }
 601         pController->setSelectedCells( aFirstPos, aLastPos );
 602     }
 603 }
 604
 605 //--------------------------------------------------------------------
 606
 607 sal_Bool SAL_CALL AccessibleTableShape::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException )
 608 {
 609     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 610     CellPos aPos;
 611     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 612
 613     return isAccessibleSelected(aPos.mnCol, aPos.mnRow);
 614 }
 615
 616 //--------------------------------------------------------------------
 617
 618 void SAL_CALL AccessibleTableShape::clearAccessibleSelection() throw ( RuntimeException )
 619 {
 620    ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 621
 622     SvxTableController* pController = getTableController();
 623     if( pController )
 624         pController->clearSelection();
 625 }
 626 //--------------------------------------------------------------------
 627
 628 void SAL_CALL AccessibleTableShape::selectAllAccessibleChildren() throw ( RuntimeException )
 629 {
 630    ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 631
 632    // todo: force selection of shape?
 633     SvxTableController* pController = getTableController();
 634     if( pController )
 635         pController->selectAll();
 636 }
 637
 638 //--------------------------------------------------------------------
 639
 640 sal_Int32 SAL_CALL AccessibleTableShape::getSelectedAccessibleChildCount() throw ( RuntimeException )
 641 {
 642     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 643
 644     SvxTableController* pController = getTableController();
 645     if( pController && pController->hasSelectedCells() )
 646     {
 647         CellPos aFirstPos, aLastPos;
 648         pController->getSelectedCells( aFirstPos, aLastPos );
 649
 650         const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1;
 651         const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1;
 652         return nSelectedRows * nSelectedColumns;
 653     }
 654
 655     return 0;
 656 }
 657
 658 //--------------------------------------------------------------------
 659
 660 Reference< XAccessible > SAL_CALL AccessibleTableShape::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw ( IndexOutOfBoundsException, RuntimeException)
 661 {
 662     ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 663
 664     SvxTableController* pController = getTableController();
 665     if( pController && pController->hasSelectedCells() )
 666     {
 667         CellPos aFirstPos, aLastPos;
 668         pController->getSelectedCells( aFirstPos, aLastPos );
 669
 670         const sal_Int32 nSelectedColumns = std::max( (sal_Int32)0, aLastPos.mnCol - aFirstPos.mnCol ) + 1;
 671         const sal_Int32 nSelectedRows = std::max( (sal_Int32)0, aLastPos.mnRow - aFirstPos.mnRow ) + 1;
 672
 673         if( nSelectedChildIndex < (nSelectedRows * nSelectedColumns) )
 674         {
 675             while( nSelectedChildIndex >= nSelectedColumns )
 676             {
 677                 aFirstPos.mnRow++;
 678                 nSelectedChildIndex -= nSelectedColumns;
 679             }
 680             return getAccessibleCellAt( nSelectedColumns, aFirstPos.mnRow );
 681         }
 682     }
 683
 684     throw IndexOutOfBoundsException();
 685 }
 686
 687 //--------------------------------------------------------------------
 688
 689 void SAL_CALL AccessibleTableShape::deselectAccessibleChild( sal_Int32 nChildIndex )  throw ( IndexOutOfBoundsException, RuntimeException )
 690 {
 691    ::vos::OGuard aSolarGuard (::Application::GetSolarMutex());
 692     CellPos aPos;
 693     mxImpl->getColumnAndRow( nChildIndex, aPos.mnCol, aPos.mnRow );
 694
 695     // todo, select table shape?!?
 696     SvxTableController* pController = getTableController();
 697     if( pController && pController->hasSelectedCells() )
 698     {
 699         CellPos aFirstPos, aLastPos;
 700         pController->getSelectedCells( aFirstPos, aLastPos );
 701
 702         // create a selection where aPos is not part of anymore
 703         aFirstPos.mnRow = std::min( aFirstPos.mnRow, aPos.mnRow+1 );
 704         aFirstPos.mnCol = std::min( aFirstPos.mnCol, aPos.mnCol+1 );
 705         aLastPos.mnRow = std::max( aLastPos.mnRow, aPos.mnRow-1 );
 706         aLastPos.mnCol = std::max( aLastPos.mnCol, aPos.mnCol-1 );
 707
 708         // new selection may be invalid (child to deselect is not at a border of the selection but in between)
 709         if( (aFirstPos.mnRow > aLastPos.mnRow) || (aFirstPos.mnCol > aLastPos.mnCol) )
 710             pController->clearSelection(); // if selection is invalid, clear all
 711         else
 712             pController->setSelectedCells( aFirstPos, aLastPos );
 713     }
 714 }
 715
 716 //--------------------------------------------------------------------
 717
 718 void AccessibleTableShape::checkCellPosition( sal_Int32 nCol, sal_Int32 nRow ) throw ( IndexOutOfBoundsException )
 719 {
 720     if( (nCol >= 0) && (nRow >= 0) && mxImpl->mxTable.is() && (nCol < mxImpl->mxTable->getColumnCount()) && (nRow < mxImpl->mxTable->getRowCount()) )
 721         return;
 722
 723     throw IndexOutOfBoundsException();
 724 }
 725
 726 }