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