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