accessibility/source/extended/accessibletabbarpagelist.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: accessibletabbarpagelist.cxx,v $
  10  * $Revision: 1.3 $
  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_accessibility.hxx"
  33 #include <accessibility/extended/accessibletabbarpagelist.hxx>
  34 #include <svtools/tabbar.hxx>
  35 #include <accessibility/extended/accessibletabbarpage.hxx>
  36 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  37 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39 #include <unotools/accessiblestatesethelper.hxx>
  40 #include <unotools/accessiblerelationsethelper.hxx>
  41 #include <tools/debug.hxx>
  42 #include <vcl/svapp.hxx>
  43 #include <toolkit/helper/convert.hxx>
  44
  45
  46 //.........................................................................
  47 namespace accessibility
  48 {
  49 //.........................................................................
  50
  51     using namespace ::com::sun::star::accessibility;
  52     using namespace ::com::sun::star::uno;
  53     using namespace ::com::sun::star::lang;
  54     using namespace ::com::sun::star;
  55     using namespace ::comphelper;
  56
  57     DBG_NAME( AccessibleTabBarPageList )
  58
  59     // -----------------------------------------------------------------------------
  60     // class AccessibleTabBarPageList
  61     // -----------------------------------------------------------------------------
  62
  63     AccessibleTabBarPageList::AccessibleTabBarPageList( TabBar* pTabBar, sal_Int32 nIndexInParent )
  64         :AccessibleTabBarBase( pTabBar )
  65         ,m_nIndexInParent( nIndexInParent )
  66     {
  67         DBG_CTOR( AccessibleTabBarPageList, NULL );
  68         if ( m_pTabBar )
  69             m_aAccessibleChildren.assign( m_pTabBar->GetPageCount(), Reference< XAccessible >() );
  70     }
  71
  72     // -----------------------------------------------------------------------------
  73
  74     AccessibleTabBarPageList::~AccessibleTabBarPageList()
  75     {
  76         DBG_DTOR( AccessibleTabBarPageList, NULL );
  77     }
  78
  79     // -----------------------------------------------------------------------------
  80
  81     void AccessibleTabBarPageList::UpdateEnabled( sal_Int32 i, sal_Bool bEnabled )
  82     {
  83         if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
  84         {
  85             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
  86             if ( xChild.is() )
  87             {
  88                 AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
  89                 if ( pAccessibleTabBarPage )
  90                     pAccessibleTabBarPage->SetEnabled( bEnabled );
  91             }
  92         }
  93     }
  94
  95     // -----------------------------------------------------------------------------
  96
  97     void AccessibleTabBarPageList::UpdateShowing( sal_Bool bShowing )
  98     {
  99         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 100         {
 101             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 102             if ( xChild.is() )
 103             {
 104                 AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
 105                 if ( pAccessibleTabBarPage )
 106                     pAccessibleTabBarPage->SetShowing( bShowing );
 107             }
 108         }
 109     }
 110
 111     // -----------------------------------------------------------------------------
 112
 113     void AccessibleTabBarPageList::UpdateSelected( sal_Int32 i, sal_Bool bSelected )
 114     {
 115         NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 116
 117         if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 118         {
 119             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 120             if ( xChild.is() )
 121             {
 122                 AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
 123                 if ( pAccessibleTabBarPage )
 124                     pAccessibleTabBarPage->SetSelected( bSelected );
 125             }
 126         }
 127     }
 128
 129     // -----------------------------------------------------------------------------
 130
 131     void AccessibleTabBarPageList::UpdatePageText( sal_Int32 i )
 132     {
 133         if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 134         {
 135             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 136             if ( xChild.is() )
 137             {
 138                 AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
 139                 if ( pAccessibleTabBarPage )
 140                 {
 141                     if ( m_pTabBar )
 142                     {
 143                         ::rtl::OUString sPageText = m_pTabBar->GetPageText( m_pTabBar->GetPageId( (sal_uInt16)i ) );
 144                         pAccessibleTabBarPage->SetPageText( sPageText );
 145                     }
 146                 }
 147             }
 148         }
 149     }
 150
 151     // -----------------------------------------------------------------------------
 152
 153     void AccessibleTabBarPageList::InsertChild( sal_Int32 i )
 154     {
 155         if ( i >= 0 && i <= (sal_Int32)m_aAccessibleChildren.size() )
 156         {
 157             // insert entry in child list
 158             m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
 159
 160             // send accessible child event
 161             Reference< XAccessible > xChild( getAccessibleChild( i ) );
 162             if ( xChild.is() )
 163             {
 164                 Any aOldValue, aNewValue;
 165                 aNewValue <<= xChild;
 166                 NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 167             }
 168         }
 169     }
 170
 171     // -----------------------------------------------------------------------------
 172
 173     void AccessibleTabBarPageList::RemoveChild( sal_Int32 i )
 174     {
 175         if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 176         {
 177             // get the accessible of the removed page
 178             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 179
 180             // remove entry in child list
 181             m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 182
 183             // send accessible child event
 184             if ( xChild.is() )
 185             {
 186                 Any aOldValue, aNewValue;
 187                 aOldValue <<= xChild;
 188                 NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 189
 190                 Reference< XComponent > xComponent( xChild, UNO_QUERY );
 191                 if ( xComponent.is() )
 192                     xComponent->dispose();
 193             }
 194         }
 195     }
 196
 197     // -----------------------------------------------------------------------------
 198
 199     void AccessibleTabBarPageList::MoveChild( sal_Int32 i, sal_Int32 j )
 200     {
 201         if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() &&
 202              j >= 0 && j <= (sal_Int32)m_aAccessibleChildren.size() )
 203         {
 204             if ( i < j )
 205                 --j;
 206
 207             // get the accessible of the moved page
 208             Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 209
 210             // remove entry in child list at old position
 211             m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 212
 213             // insert entry in child list at new position
 214             m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + j, xChild );
 215         }
 216     }
 217
 218     // -----------------------------------------------------------------------------
 219
 220     void AccessibleTabBarPageList::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 221     {
 222          switch ( rVclWindowEvent.GetId() )
 223          {
 224             case VCLEVENT_WINDOW_ENABLED:
 225             {
 226                Any aNewValue;
 227                 aNewValue <<= AccessibleStateType::SENSITIVE;
 228                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, Any(), aNewValue );
 229                 aNewValue <<= AccessibleStateType::ENABLED;
 230                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, Any(), aNewValue );
 231             }
 232             break;
 233             case VCLEVENT_WINDOW_DISABLED:
 234             {
 235                Any aOldValue;
 236                 aOldValue <<= AccessibleStateType::ENABLED;
 237                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, Any() );
 238                 aOldValue <<= AccessibleStateType::SENSITIVE;
 239                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, Any() );
 240             }
 241             break;
 242             case VCLEVENT_WINDOW_SHOW:
 243             {
 244                 Any aOldValue, aNewValue;
 245                 aNewValue <<= AccessibleStateType::SHOWING;
 246                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 247                 UpdateShowing( sal_True );
 248             }
 249             break;
 250             case VCLEVENT_WINDOW_HIDE:
 251             {
 252                 Any aOldValue, aNewValue;
 253                 aOldValue <<= AccessibleStateType::SHOWING;
 254                 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 255                 UpdateShowing( sal_False );
 256             }
 257             break;
 258             case VCLEVENT_TABBAR_PAGEENABLED:
 259             {
 260                 if ( m_pTabBar )
 261                 {
 262                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 263                     sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 264                     UpdateEnabled( nPagePos, sal_True );
 265                 }
 266             }
 267             break;
 268             case VCLEVENT_TABBAR_PAGEDISABLED:
 269             {
 270                 if ( m_pTabBar )
 271                 {
 272                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 273                     sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 274                     UpdateEnabled( nPagePos, sal_False );
 275                 }
 276             }
 277             break;
 278             case VCLEVENT_TABBAR_PAGESELECTED:
 279             {
 280                 // do nothing
 281             }
 282             break;
 283             case VCLEVENT_TABBAR_PAGEACTIVATED:
 284             {
 285                 if ( m_pTabBar )
 286                 {
 287                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 288                     sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 289                     UpdateSelected( nPagePos, sal_True );
 290                 }
 291             }
 292             break;
 293             case VCLEVENT_TABBAR_PAGEDEACTIVATED:
 294             {
 295                 if ( m_pTabBar )
 296                 {
 297                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 298                     sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 299                     UpdateSelected( nPagePos, sal_False );
 300                 }
 301             }
 302             break;
 303             case VCLEVENT_TABBAR_PAGEINSERTED:
 304             {
 305                 if ( m_pTabBar )
 306                 {
 307                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 308                     sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 309                     InsertChild( nPagePos );
 310                 }
 311             }
 312             break;
 313             case VCLEVENT_TABBAR_PAGEREMOVED:
 314             {
 315                 if ( m_pTabBar )
 316                 {
 317                     sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 318
 319                     if ( nPageId == TABBAR_PAGE_NOTFOUND )
 320                     {
 321                         for ( sal_Int32 i = m_aAccessibleChildren.size() - 1; i >= 0; --i )
 322                             RemoveChild( i );
 323                     }
 324                     else
 325                     {
 326                         for ( sal_Int32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 327                         {
 328                             Reference< XAccessible > xChild( getAccessibleChild( i ) );
 329                             if ( xChild.is() )
 330                             {
 331                                 AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
 332                                 if ( pAccessibleTabBarPage && pAccessibleTabBarPage->GetPageId() == nPageId )
 333                                 {
 334                                     RemoveChild( i );
 335                                     break;
 336                                 }
 337                             }
 338                         }
 339                     }
 340                 }
 341             }
 342             break;
 343             case VCLEVENT_TABBAR_PAGEMOVED:
 344             {
 345                 Pair* pPair = (Pair*) rVclWindowEvent.GetData();
 346                 if ( pPair )
 347                     MoveChild( pPair->A(), pPair->B() );
 348             }
 349             break;
 350             case VCLEVENT_TABBAR_PAGETEXTCHANGED:
 351             {
 352                 sal_uInt16 nPageId = (sal_uInt16)(sal_IntPtr) rVclWindowEvent.GetData();
 353                 sal_uInt16 nPagePos = m_pTabBar->GetPagePos( nPageId );
 354                 UpdatePageText( nPagePos );
 355             }
 356             break;
 357             default:
 358             {
 359                 AccessibleTabBarBase::ProcessWindowEvent( rVclWindowEvent );
 360             }
 361             break;
 362         }
 363     }
 364
 365     // -----------------------------------------------------------------------------
 366
 367     void AccessibleTabBarPageList::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 368     {
 369         if ( m_pTabBar )
 370         {
 371             if ( m_pTabBar->IsEnabled() )
 372             {
 373                 rStateSet.AddState( AccessibleStateType::ENABLED );
 374                 rStateSet.AddState( AccessibleStateType::SENSITIVE );
 375             }
 376
 377             rStateSet.AddState( AccessibleStateType::VISIBLE );
 378
 379             if ( m_pTabBar->IsVisible() )
 380                 rStateSet.AddState( AccessibleStateType::SHOWING );
 381         }
 382     }
 383
 384     // -----------------------------------------------------------------------------
 385     // OCommonAccessibleComponent
 386     // -----------------------------------------------------------------------------
 387
 388     awt::Rectangle AccessibleTabBarPageList::implGetBounds() throw (RuntimeException)
 389     {
 390         awt::Rectangle aBounds;
 391         if ( m_pTabBar )
 392             aBounds = AWTRectangle( m_pTabBar->GetPageArea() );
 393
 394         return aBounds;
 395     }
 396
 397     // -----------------------------------------------------------------------------
 398     // XInterface
 399     // -----------------------------------------------------------------------------
 400
 401     IMPLEMENT_FORWARD_XINTERFACE2( AccessibleTabBarPageList, AccessibleExtendedComponentHelper_BASE, AccessibleTabBarPageList_BASE )
 402
 403     // -----------------------------------------------------------------------------
 404     // XTypeProvider
 405     // -----------------------------------------------------------------------------
 406
 407     IMPLEMENT_FORWARD_XTYPEPROVIDER2( AccessibleTabBarPageList, AccessibleExtendedComponentHelper_BASE, AccessibleTabBarPageList_BASE )
 408
 409     // -----------------------------------------------------------------------------
 410     // XComponent
 411     // -----------------------------------------------------------------------------
 412
 413     void AccessibleTabBarPageList::disposing()
 414     {
 415         AccessibleTabBarBase::disposing();
 416
 417         // dispose all children
 418         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 419         {
 420             Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 421             if ( xComponent.is() )
 422                 xComponent->dispose();
 423         }
 424         m_aAccessibleChildren.clear();
 425     }
 426
 427     // -----------------------------------------------------------------------------
 428     // XServiceInfo
 429     // -----------------------------------------------------------------------------
 430
 431     ::rtl::OUString AccessibleTabBarPageList::getImplementationName() throw (RuntimeException)
 432     {
 433         return ::rtl::OUString::createFromAscii( "com.sun.star.comp.svtools.AccessibleTabBarPageList" );
 434     }
 435
 436     // -----------------------------------------------------------------------------
 437
 438     sal_Bool AccessibleTabBarPageList::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
 439     {
 440         Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
 441         const ::rtl::OUString* pNames = aNames.getConstArray();
 442         const ::rtl::OUString* pEnd = pNames + aNames.getLength();
 443         for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 444             ;
 445
 446         return pNames != pEnd;
 447     }
 448
 449     // -----------------------------------------------------------------------------
 450
 451     Sequence< ::rtl::OUString > AccessibleTabBarPageList::getSupportedServiceNames() throw (RuntimeException)
 452     {
 453         Sequence< ::rtl::OUString > aNames(1);
 454         aNames[0] = ::rtl::OUString::createFromAscii( "com.sun.star.awt.AccessibleTabBarPageList" );
 455         return aNames;
 456     }
 457
 458     // -----------------------------------------------------------------------------
 459     // XAccessible
 460     // -----------------------------------------------------------------------------
 461
 462     Reference< XAccessibleContext > AccessibleTabBarPageList::getAccessibleContext(  ) throw (RuntimeException)
 463     {
 464         OExternalLockGuard aGuard( this );
 465
 466         return this;
 467     }
 468
 469     // -----------------------------------------------------------------------------
 470     // XAccessibleContext
 471     // -----------------------------------------------------------------------------
 472
 473     sal_Int32 AccessibleTabBarPageList::getAccessibleChildCount() throw (RuntimeException)
 474     {
 475         OExternalLockGuard aGuard( this );
 476
 477         return m_aAccessibleChildren.size();
 478     }
 479
 480     // -----------------------------------------------------------------------------
 481
 482     Reference< XAccessible > AccessibleTabBarPageList::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 483     {
 484         OExternalLockGuard aGuard( this );
 485
 486         if ( i < 0 || i >= getAccessibleChildCount() )
 487             throw IndexOutOfBoundsException();
 488
 489         Reference< XAccessible > xChild = m_aAccessibleChildren[i];
 490         if ( !xChild.is() )
 491         {
 492             if ( m_pTabBar )
 493             {
 494                 sal_uInt16 nPageId = m_pTabBar->GetPageId( (USHORT)i );
 495
 496                 xChild = new AccessibleTabBarPage( m_pTabBar, nPageId, this );
 497
 498                 // insert into child list
 499                 m_aAccessibleChildren[i] = xChild;
 500             }
 501         }
 502
 503         return xChild;
 504     }
 505
 506     // -----------------------------------------------------------------------------
 507
 508     Reference< XAccessible > AccessibleTabBarPageList::getAccessibleParent(  ) throw (RuntimeException)
 509     {
 510         OExternalLockGuard aGuard( this );
 511
 512         Reference< XAccessible > xParent;
 513         if ( m_pTabBar )
 514             xParent = m_pTabBar->GetAccessible();
 515
 516         return xParent;
 517     }
 518
 519     // -----------------------------------------------------------------------------
 520
 521     sal_Int32 AccessibleTabBarPageList::getAccessibleIndexInParent(  ) throw (RuntimeException)
 522     {
 523         OExternalLockGuard aGuard( this );
 524
 525         return m_nIndexInParent;
 526     }
 527
 528     // -----------------------------------------------------------------------------
 529
 530     sal_Int16 AccessibleTabBarPageList::getAccessibleRole(  ) throw (RuntimeException)
 531     {
 532         OExternalLockGuard aGuard( this );
 533
 534         return AccessibleRole::PAGE_TAB_LIST;
 535     }
 536
 537     // -----------------------------------------------------------------------------
 538
 539     ::rtl::OUString AccessibleTabBarPageList::getAccessibleDescription( ) throw (RuntimeException)
 540     {
 541         OExternalLockGuard aGuard( this );
 542
 543         return ::rtl::OUString();
 544     }
 545
 546     // -----------------------------------------------------------------------------
 547
 548     ::rtl::OUString AccessibleTabBarPageList::getAccessibleName(  ) throw (RuntimeException)
 549     {
 550         OExternalLockGuard aGuard( this );
 551
 552         return ::rtl::OUString();
 553     }
 554
 555     // -----------------------------------------------------------------------------
 556
 557     Reference< XAccessibleRelationSet > AccessibleTabBarPageList::getAccessibleRelationSet(  ) throw (RuntimeException)
 558     {
 559         OExternalLockGuard aGuard( this );
 560
 561         utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 562         Reference< XAccessibleRelationSet > xSet = pRelationSetHelper;
 563         return xSet;
 564     }
 565
 566     // -----------------------------------------------------------------------------
 567
 568     Reference< XAccessibleStateSet > AccessibleTabBarPageList::getAccessibleStateSet(  ) throw (RuntimeException)
 569     {
 570         OExternalLockGuard aGuard( this );
 571
 572         utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 573         Reference< XAccessibleStateSet > xSet = pStateSetHelper;
 574
 575         if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 576         {
 577             FillAccessibleStateSet( *pStateSetHelper );
 578         }
 579         else
 580         {
 581             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 582         }
 583
 584         return xSet;
 585     }
 586
 587     // -----------------------------------------------------------------------------
 588
 589     Locale AccessibleTabBarPageList::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 590     {
 591         OExternalLockGuard aGuard( this );
 592
 593         return Application::GetSettings().GetLocale();
 594     }
 595
 596     // -----------------------------------------------------------------------------
 597     // XAccessibleComponent
 598     // -----------------------------------------------------------------------------
 599
 600     Reference< XAccessible > AccessibleTabBarPageList::getAccessibleAtPoint( const awt::Point& rPoint ) throw (RuntimeException)
 601     {
 602         OExternalLockGuard aGuard( this );
 603
 604         Reference< XAccessible > xChild;
 605         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 606         {
 607             Reference< XAccessible > xAcc = getAccessibleChild( i );
 608             if ( xAcc.is() )
 609             {
 610                 Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 611                 if ( xComp.is() )
 612                 {
 613                     Rectangle aRect = VCLRectangle( xComp->getBounds() );
 614                     Point aPos = VCLPoint( rPoint );
 615                     if ( aRect.IsInside( aPos ) )
 616                     {
 617                         xChild = xAcc;
 618                         break;
 619                     }
 620                 }
 621             }
 622         }
 623
 624         return xChild;
 625     }
 626
 627     // -----------------------------------------------------------------------------
 628
 629     void AccessibleTabBarPageList::grabFocus(  ) throw (RuntimeException)
 630     {
 631         // no focus
 632     }
 633
 634     // -----------------------------------------------------------------------------
 635
 636     sal_Int32 AccessibleTabBarPageList::getForeground(  ) throw (RuntimeException)
 637     {
 638         OExternalLockGuard aGuard( this );
 639
 640         sal_Int32 nColor = 0;
 641         Reference< XAccessible > xParent = getAccessibleParent();
 642         if ( xParent.is() )
 643         {
 644             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 645             if ( xParentComp.is() )
 646                 nColor = xParentComp->getForeground();
 647         }
 648
 649         return nColor;
 650     }
 651
 652     // -----------------------------------------------------------------------------
 653
 654     sal_Int32 AccessibleTabBarPageList::getBackground(  ) throw (RuntimeException)
 655     {
 656         OExternalLockGuard aGuard( this );
 657
 658         sal_Int32 nColor = 0;
 659         Reference< XAccessible > xParent = getAccessibleParent();
 660         if ( xParent.is() )
 661         {
 662             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 663             if ( xParentComp.is() )
 664                 nColor = xParentComp->getBackground();
 665         }
 666
 667         return nColor;
 668     }
 669
 670     // -----------------------------------------------------------------------------
 671     // XAccessibleExtendedComponent
 672     // -----------------------------------------------------------------------------
 673
 674     Reference< awt::XFont > AccessibleTabBarPageList::getFont(  ) throw (RuntimeException)
 675     {
 676         OExternalLockGuard aGuard( this );
 677
 678         Reference< awt::XFont > xFont;
 679         Reference< XAccessible > xParent = getAccessibleParent();
 680         if ( xParent.is() )
 681         {
 682             Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 683             if ( xParentComp.is() )
 684                 xFont = xParentComp->getFont();
 685         }
 686
 687         return xFont;
 688     }
 689
 690     // -----------------------------------------------------------------------------
 691
 692     ::rtl::OUString AccessibleTabBarPageList::getTitledBorderText(  ) throw (RuntimeException)
 693     {
 694         OExternalLockGuard aGuard( this );
 695
 696         return ::rtl::OUString();
 697     }
 698
 699     // -----------------------------------------------------------------------------
 700
 701     ::rtl::OUString AccessibleTabBarPageList::getToolTipText(  ) throw (RuntimeException)
 702     {
 703         OExternalLockGuard aGuard( this );
 704
 705         return ::rtl::OUString();
 706     }
 707
 708     // -----------------------------------------------------------------------------
 709     // XAccessibleSelection
 710     // -----------------------------------------------------------------------------
 711
 712     void AccessibleTabBarPageList::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 713     {
 714         OExternalLockGuard aGuard( this );
 715
 716         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 717             throw IndexOutOfBoundsException();
 718
 719         if ( m_pTabBar )
 720         {
 721             m_pTabBar->SetCurPageId( m_pTabBar->GetPageId( (USHORT)nChildIndex ) );
 722             m_pTabBar->Update();
 723             m_pTabBar->ActivatePage();
 724             m_pTabBar->Select();
 725         }
 726     }
 727
 728     // -----------------------------------------------------------------------------
 729
 730     sal_Bool AccessibleTabBarPageList::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 731     {
 732         OExternalLockGuard aGuard( this );
 733
 734         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 735             throw IndexOutOfBoundsException();
 736
 737         sal_Bool bSelected = sal_False;
 738         if ( m_pTabBar && m_pTabBar->GetCurPageId() == m_pTabBar->GetPageId( (USHORT)nChildIndex ) )
 739             bSelected = sal_True;
 740
 741         return bSelected;
 742     }
 743
 744     // -----------------------------------------------------------------------------
 745
 746     void AccessibleTabBarPageList::clearAccessibleSelection(  ) throw (RuntimeException)
 747     {
 748         // This method makes no sense in a TabBar, and so does nothing.
 749     }
 750
 751     // -----------------------------------------------------------------------------
 752
 753     void AccessibleTabBarPageList::selectAllAccessibleChildren(  ) throw (RuntimeException)
 754     {
 755         OExternalLockGuard aGuard( this );
 756
 757         selectAccessibleChild( 0 );
 758     }
 759
 760     // -----------------------------------------------------------------------------
 761
 762     sal_Int32 AccessibleTabBarPageList::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
 763     {
 764         OExternalLockGuard aGuard( this );
 765
 766         return 1;
 767     }
 768
 769     // -----------------------------------------------------------------------------
 770
 771     Reference< XAccessible > AccessibleTabBarPageList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 772     {
 773         OExternalLockGuard aGuard( this );
 774
 775         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 776             throw IndexOutOfBoundsException();
 777
 778         Reference< XAccessible > xChild;
 779
 780         for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; i++ )
 781         {
 782             if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
 783             {
 784                 xChild = getAccessibleChild( i );
 785                 break;
 786             }
 787         }
 788
 789         return xChild;
 790     }
 791
 792     // -----------------------------------------------------------------------------
 793
 794     void AccessibleTabBarPageList::deselectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 795     {
 796         OExternalLockGuard aGuard( this );
 797
 798         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 799             throw IndexOutOfBoundsException();
 800
 801         // This method makes no sense in a TabBar, and so does nothing.
 802     }
 803
 804     // -----------------------------------------------------------------------------
 805
 806 //.........................................................................
 807 }       // namespace accessibility
 808 //.........................................................................