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 #include <i18nlangtag/languagetag.hxx>
  34
  35
  36 namespace accessibility
  37 {
  38
  39
  40     using namespace ::com::sun::star::accessibility;
  41     using namespace ::com::sun::star::uno;
  42     using namespace ::com::sun::star::lang;
  43     using namespace ::com::sun::star;
  44     using namespace ::comphelper;
  45
  46
  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 (const 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             return;
  93
  94         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
  95         if ( xChild.is() )
  96         {
  97             AccessibleTabBarPage* pAccessibleTabBarPage = static_cast< AccessibleTabBarPage* >( xChild.get() );
  98             if ( pAccessibleTabBarPage && m_pTabBar )
  99             {
 100                 OUString sPageText = m_pTabBar->GetPageText( m_pTabBar->GetPageId( static_cast<sal_uInt16>(i) ) );
 101                 pAccessibleTabBarPage->SetPageText( sPageText );
 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             return;
 111
 112         // insert entry in child list
 113         m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
 114
 115         // send accessible child event
 116         Reference< XAccessible > xChild( getAccessibleChild( i ) );
 117         if ( xChild.is() )
 118         {
 119             Any aOldValue, aNewValue;
 120             aNewValue <<= xChild;
 121             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 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             return;
 130
 131         // get the accessible of the removed page
 132         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 133
 134         // remove entry in child list
 135         m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 136
 137         // send accessible child event
 138         if ( xChild.is() )
 139         {
 140             Any aOldValue, aNewValue;
 141             aOldValue <<= xChild;
 142             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 143
 144             Reference< XComponent > xComponent( xChild, UNO_QUERY );
 145             if ( xComponent.is() )
 146                 xComponent->dispose();
 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             return;
 156
 157         if ( i < j )
 158             --j;
 159
 160         // get the accessible of the moved page
 161         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 162
 163         // remove entry in child list at old position
 164         m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 165
 166         // insert entry in child list at new position
 167         m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + j, xChild );
 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             return;
 301
 302         if ( m_pTabBar->IsEnabled() )
 303         {
 304             rStateSet.AddState( AccessibleStateType::ENABLED );
 305             rStateSet.AddState( AccessibleStateType::SENSITIVE );
 306         }
 307
 308         rStateSet.AddState( AccessibleStateType::VISIBLE );
 309
 310         if ( m_pTabBar->IsVisible() )
 311             rStateSet.AddState( AccessibleStateType::SHOWING );
 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 (const 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 "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         return new utl::AccessibleRelationSetHelper;
 469     }
 470
 471
 472     Reference< XAccessibleStateSet > AccessibleTabBarPageList::getAccessibleStateSet(  )
 473     {
 474         OExternalLockGuard aGuard( this );
 475
 476         rtl::Reference<utl::AccessibleStateSetHelper> pStateSetHelper = new utl::AccessibleStateSetHelper;
 477
 478         if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 479         {
 480             FillAccessibleStateSet( *pStateSetHelper );
 481         }
 482         else
 483         {
 484             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 485         }
 486
 487         return pStateSetHelper;
 488     }
 489
 490
 491     Locale AccessibleTabBarPageList::getLocale(  )
 492     {
 493         OExternalLockGuard aGuard( this );
 494
 495         return Application::GetSettings().GetLanguageTag().getLocale();
 496     }
 497
 498
 499     // XAccessibleComponent
 500
 501
 502     Reference< XAccessible > AccessibleTabBarPageList::getAccessibleAtPoint( const awt::Point& rPoint )
 503     {
 504         OExternalLockGuard aGuard( this );
 505
 506         Reference< XAccessible > xChild;
 507         for ( size_t i = 0; i < m_aAccessibleChildren.size(); ++i )
 508         {
 509             Reference< XAccessible > xAcc = getAccessibleChild( i );
 510             if ( xAcc.is() )
 511             {
 512                 Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 513                 if ( xComp.is() )
 514                 {
 515                     tools::Rectangle aRect = VCLRectangle( xComp->getBounds() );
 516                     Point aPos = VCLPoint( rPoint );
 517                     if ( aRect.Contains( aPos ) )
 518                     {
 519                         xChild = xAcc;
 520                         break;
 521                     }
 522                 }
 523             }
 524         }
 525
 526         return xChild;
 527     }
 528
 529
 530     void AccessibleTabBarPageList::grabFocus(  )
 531     {
 532         // no focus
 533     }
 534
 535
 536     sal_Int32 AccessibleTabBarPageList::getForeground(  )
 537     {
 538         OExternalLockGuard aGuard( this );
 539
 540         sal_Int32 nColor = 0;
 541         Reference< XAccessible > xParent = getAccessibleParent();
 542         if ( xParent.is() )
 543         {
 544             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 545             if ( xParentComp.is() )
 546                 nColor = xParentComp->getForeground();
 547         }
 548
 549         return nColor;
 550     }
 551
 552
 553     sal_Int32 AccessibleTabBarPageList::getBackground(  )
 554     {
 555         OExternalLockGuard aGuard( this );
 556
 557         sal_Int32 nColor = 0;
 558         Reference< XAccessible > xParent = getAccessibleParent();
 559         if ( xParent.is() )
 560         {
 561             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 562             if ( xParentComp.is() )
 563                 nColor = xParentComp->getBackground();
 564         }
 565
 566         return nColor;
 567     }
 568
 569
 570     // XAccessibleExtendedComponent
 571
 572
 573     Reference< awt::XFont > AccessibleTabBarPageList::getFont(  )
 574     {
 575         OExternalLockGuard aGuard( this );
 576
 577         Reference< awt::XFont > xFont;
 578         Reference< XAccessible > xParent = getAccessibleParent();
 579         if ( xParent.is() )
 580         {
 581             Reference< XAccessibleExtendedComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 582             if ( xParentComp.is() )
 583                 xFont = xParentComp->getFont();
 584         }
 585
 586         return xFont;
 587     }
 588
 589
 590     OUString AccessibleTabBarPageList::getTitledBorderText(  )
 591     {
 592         return OUString();
 593     }
 594
 595
 596     OUString AccessibleTabBarPageList::getToolTipText(  )
 597     {
 598         return OUString();
 599     }
 600
 601
 602     // XAccessibleSelection
 603
 604
 605     void AccessibleTabBarPageList::selectAccessibleChild( sal_Int32 nChildIndex )
 606     {
 607         OExternalLockGuard aGuard( this );
 608
 609         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 610             throw IndexOutOfBoundsException();
 611
 612         if ( m_pTabBar )
 613         {
 614             m_pTabBar->SetCurPageId( m_pTabBar->GetPageId( static_cast<sal_uInt16>(nChildIndex) ) );
 615             m_pTabBar->PaintImmediately();
 616             m_pTabBar->ActivatePage();
 617             m_pTabBar->Select();
 618         }
 619     }
 620
 621
 622     sal_Bool AccessibleTabBarPageList::isAccessibleChildSelected( sal_Int32 nChildIndex )
 623     {
 624         OExternalLockGuard aGuard( this );
 625
 626         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 627             throw IndexOutOfBoundsException();
 628
 629         bool bSelected = false;
 630         if ( m_pTabBar && m_pTabBar->GetCurPageId() == m_pTabBar->GetPageId( static_cast<sal_uInt16>(nChildIndex) ) )
 631             bSelected = true;
 632
 633         return bSelected;
 634     }
 635
 636
 637     void AccessibleTabBarPageList::clearAccessibleSelection(  )
 638     {
 639         // This method makes no sense in a TabBar, and so does nothing.
 640     }
 641
 642
 643     void AccessibleTabBarPageList::selectAllAccessibleChildren(  )
 644     {
 645         selectAccessibleChild( 0 );
 646     }
 647
 648
 649     sal_Int32 AccessibleTabBarPageList::getSelectedAccessibleChildCount(  )
 650     {
 651         return 1;
 652     }
 653
 654
 655     Reference< XAccessible > AccessibleTabBarPageList::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 656     {
 657         OExternalLockGuard aGuard( this );
 658
 659         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 660             throw IndexOutOfBoundsException();
 661
 662         Reference< XAccessible > xChild;
 663
 664         for ( sal_Int32 i = 0, j = 0, nCount = getAccessibleChildCount(); i < nCount; i++ )
 665         {
 666             if ( isAccessibleChildSelected( i ) && ( j++ == nSelectedChildIndex ) )
 667             {
 668                 xChild = getAccessibleChild( i );
 669                 break;
 670             }
 671         }
 672
 673         return xChild;
 674     }
 675
 676
 677     void AccessibleTabBarPageList::deselectAccessibleChild( sal_Int32 nChildIndex )
 678     {
 679         OExternalLockGuard aGuard( this );
 680
 681         if ( nChildIndex < 0 || nChildIndex >= getAccessibleChildCount() )
 682             throw IndexOutOfBoundsException();
 683
 684         // This method makes no sense in a TabBar, and so does nothing.
 685     }
 686
 687
 688 }   // namespace accessibility
 689
 690
 691 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */