accessibility/source/standard/accessiblemenubasecomponent.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/standard/accessiblemenubasecomponent.hxx>
  21 #include <accessibility/standard/vclxaccessiblemenu.hxx>
  22 #include <accessibility/standard/vclxaccessiblemenuitem.hxx>
  23 #include <accessibility/standard/vclxaccessiblemenuseparator.hxx>
  24 #include <toolkit/helper/externallock.hxx>
  25 #include <toolkit/helper/convert.hxx>
  26
  27 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  28 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  29 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  30 #include <cppuhelper/supportsservice.hxx>
  31 #include <unotools/accessiblestatesethelper.hxx>
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/window.hxx>
  34 #include <vcl/menu.hxx>
  35
  36 using namespace ::com::sun::star;
  37 using namespace ::com::sun::star::lang;
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::accessibility;
  40 using namespace ::comphelper;
  41
  42
  43
  44 // OAccessibleMenuBaseComponent
  45
  46
  47 OAccessibleMenuBaseComponent::OAccessibleMenuBaseComponent( Menu* pMenu )
  48     :AccessibleExtendedComponentHelper_BASE( new VCLExternalSolarLock() )
  49     ,m_pMenu( pMenu )
  50     ,m_bEnabled( false )
  51     ,m_bFocused( false )
  52     ,m_bVisible( false )
  53     ,m_bSelected( false )
  54     ,m_bChecked( false )
  55 {
  56     m_pExternalLock = static_cast< VCLExternalSolarLock* >( getExternalLock() );
  57
  58     if ( m_pMenu )
  59     {
  60         m_aAccessibleChildren.assign( m_pMenu->GetItemCount(), Reference< XAccessible >() );
  61         m_pMenu->AddEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
  62     }
  63 }
  64
  65
  66
  67 OAccessibleMenuBaseComponent::~OAccessibleMenuBaseComponent()
  68 {
  69     if ( m_pMenu )
  70         m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
  71
  72     delete m_pExternalLock;
  73     m_pExternalLock = NULL;
  74 }
  75
  76
  77
  78 bool OAccessibleMenuBaseComponent::IsEnabled()
  79 {
  80     return false;
  81 }
  82
  83
  84
  85 bool OAccessibleMenuBaseComponent::IsFocused()
  86 {
  87     return false;
  88 }
  89
  90
  91
  92 bool OAccessibleMenuBaseComponent::IsVisible()
  93 {
  94     return false;
  95 }
  96
  97
  98
  99 bool OAccessibleMenuBaseComponent::IsSelected()
 100 {
 101     return false;
 102 }
 103
 104
 105
 106 bool OAccessibleMenuBaseComponent::IsChecked()
 107 {
 108     return false;
 109 }
 110
 111
 112
 113 void OAccessibleMenuBaseComponent::SetStates()
 114 {
 115     m_bEnabled = IsEnabled();
 116     m_bFocused = IsFocused();
 117     m_bVisible = IsVisible();
 118     m_bSelected = IsSelected();
 119     m_bChecked = IsChecked();
 120 }
 121
 122
 123
 124 void OAccessibleMenuBaseComponent::SetEnabled( bool bEnabled )
 125 {
 126     if ( m_bEnabled != bEnabled )
 127     {
 128         sal_Int16 nStateType=AccessibleStateType::ENABLED;
 129         if (IsMenuHideDisabledEntries())
 130         {
 131             nStateType = AccessibleStateType::VISIBLE;
 132         }
 133         Any aOldValue[2], aNewValue[2];
 134         if ( m_bEnabled )
 135         {
 136             aOldValue[0] <<= AccessibleStateType::SENSITIVE;
 137             aOldValue[1] <<= nStateType;
 138         }
 139         else
 140         {
 141             aNewValue[0] <<= nStateType;
 142             aNewValue[1] <<= AccessibleStateType::SENSITIVE;
 143         }
 144         m_bEnabled = bEnabled;
 145         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[0], aNewValue[0] );
 146         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue[1], aNewValue[1] );
 147     }
 148 }
 149
 150
 151
 152 void OAccessibleMenuBaseComponent::SetFocused( bool bFocused )
 153 {
 154     if ( m_bFocused != bFocused )
 155     {
 156         Any aOldValue, aNewValue;
 157         if ( m_bFocused )
 158             aOldValue <<= AccessibleStateType::FOCUSED;
 159         else
 160             aNewValue <<= AccessibleStateType::FOCUSED;
 161         m_bFocused = bFocused;
 162         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 163     }
 164 }
 165
 166
 167
 168 void OAccessibleMenuBaseComponent::SetVisible( bool bVisible )
 169 {
 170     if ( m_bVisible != bVisible )
 171     {
 172         Any aOldValue, aNewValue;
 173         if ( m_bVisible )
 174             aOldValue <<= AccessibleStateType::VISIBLE;
 175         else
 176             aNewValue <<= AccessibleStateType::VISIBLE;
 177         m_bVisible = bVisible;
 178         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 179     }
 180 }
 181
 182
 183
 184 void OAccessibleMenuBaseComponent::SetSelected( bool bSelected )
 185 {
 186     if ( m_bSelected != bSelected )
 187     {
 188         Any aOldValue, aNewValue;
 189         if ( m_bSelected )
 190             aOldValue <<= AccessibleStateType::SELECTED;
 191         else
 192             aNewValue <<= AccessibleStateType::SELECTED;
 193         m_bSelected = bSelected;
 194         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 195     }
 196 }
 197
 198
 199
 200 void OAccessibleMenuBaseComponent::SetChecked( bool bChecked )
 201 {
 202     if ( m_bChecked != bChecked )
 203     {
 204         Any aOldValue, aNewValue;
 205         if ( m_bChecked )
 206             aOldValue <<= AccessibleStateType::CHECKED;
 207         else
 208             aNewValue <<= AccessibleStateType::CHECKED;
 209         m_bChecked = bChecked;
 210         NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue );
 211     }
 212 }
 213
 214
 215
 216 void OAccessibleMenuBaseComponent::UpdateEnabled( sal_Int32 i, bool bEnabled )
 217 {
 218     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 219     {
 220         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 221         if ( xChild.is() )
 222         {
 223             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 224             if ( pComp )
 225                 pComp->SetEnabled( bEnabled );
 226         }
 227     }
 228 }
 229
 230
 231
 232 void OAccessibleMenuBaseComponent::UpdateFocused( sal_Int32 i, bool bFocused )
 233 {
 234     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 235     {
 236         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 237         if ( xChild.is() )
 238         {
 239             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 240             if ( pComp )
 241                 pComp->SetFocused( bFocused );
 242         }
 243     }
 244 }
 245
 246
 247
 248 void OAccessibleMenuBaseComponent::UpdateVisible()
 249 {
 250     SetVisible( IsVisible() );
 251     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 252     {
 253         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 254         if ( xChild.is() )
 255         {
 256             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 257             if ( pComp )
 258                 pComp->SetVisible( pComp->IsVisible() );
 259         }
 260     }
 261 }
 262
 263
 264
 265 void OAccessibleMenuBaseComponent::UpdateSelected( sal_Int32 i, bool bSelected )
 266 {
 267     NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 268
 269     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 270     {
 271         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 272         if ( xChild.is() )
 273         {
 274             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 275             if ( pComp )
 276                 pComp->SetSelected( bSelected );
 277         }
 278     }
 279 }
 280
 281
 282
 283 void OAccessibleMenuBaseComponent::UpdateChecked( sal_Int32 i, bool bChecked )
 284 {
 285     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 286     {
 287         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 288         if ( xChild.is() )
 289         {
 290             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 291             if ( pComp )
 292                 pComp->SetChecked( bChecked );
 293         }
 294     }
 295 }
 296
 297
 298
 299 void OAccessibleMenuBaseComponent::UpdateAccessibleName( sal_Int32 i )
 300 {
 301     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 302     {
 303         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 304         if ( xChild.is() )
 305         {
 306             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
 307             if ( pComp )
 308                 pComp->SetAccessibleName( pComp->GetAccessibleName() );
 309         }
 310     }
 311 }
 312
 313
 314
 315 void OAccessibleMenuBaseComponent::UpdateItemText( sal_Int32 i )
 316 {
 317     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 318     {
 319         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 320         if ( xChild.is() )
 321         {
 322             OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xChild.get() );
 323             if ( pComp )
 324                 pComp->SetItemText( pComp->GetItemText() );
 325         }
 326     }
 327 }
 328
 329
 330
 331 sal_Int32 OAccessibleMenuBaseComponent::GetChildCount()
 332 {
 333     return m_aAccessibleChildren.size();
 334 }
 335
 336
 337
 338 Reference< XAccessible > OAccessibleMenuBaseComponent::GetChild( sal_Int32 i )
 339 {
 340     Reference< XAccessible > xChild = m_aAccessibleChildren[i];
 341     if ( !xChild.is() )
 342     {
 343         if ( m_pMenu )
 344         {
 345             // create a new child
 346             OAccessibleMenuBaseComponent* pChild;
 347
 348             if ( m_pMenu->GetItemType( (sal_uInt16)i ) == MenuItemType::SEPARATOR )
 349             {
 350                 pChild = new VCLXAccessibleMenuSeparator( m_pMenu, (sal_uInt16)i );
 351             }
 352             else
 353             {
 354                 PopupMenu* pPopupMenu = m_pMenu->GetPopupMenu( m_pMenu->GetItemId( (sal_uInt16)i ) );
 355                 if ( pPopupMenu )
 356                 {
 357                     pChild = new VCLXAccessibleMenu( m_pMenu, (sal_uInt16)i, pPopupMenu );
 358                     pPopupMenu->SetAccessible( pChild );
 359                 }
 360                 else
 361                 {
 362                     pChild = new VCLXAccessibleMenuItem( m_pMenu, (sal_uInt16)i );
 363                 }
 364             }
 365
 366             // set states
 367             pChild->SetStates();
 368
 369             xChild = pChild;
 370
 371             // insert into menu item list
 372             m_aAccessibleChildren[i] = xChild;
 373         }
 374     }
 375
 376     return xChild;
 377 }
 378
 379
 380
 381 Reference< XAccessible > OAccessibleMenuBaseComponent::GetChildAt( const awt::Point& rPoint )
 382 {
 383     Reference< XAccessible > xChild;
 384     for ( sal_uInt32 i = 0, nCount = getAccessibleChildCount(); i < nCount; ++i )
 385     {
 386         Reference< XAccessible > xAcc = getAccessibleChild( i );
 387         if ( xAcc.is() )
 388         {
 389             Reference< XAccessibleComponent > xComp( xAcc->getAccessibleContext(), UNO_QUERY );
 390             if ( xComp.is() )
 391             {
 392                 Rectangle aRect = VCLRectangle( xComp->getBounds() );
 393                 Point aPos = VCLPoint( rPoint );
 394                 if ( aRect.IsInside( aPos ) )
 395                 {
 396                     xChild = xAcc;
 397                     break;
 398                 }
 399             }
 400         }
 401     }
 402
 403     return xChild;
 404 }
 405
 406
 407
 408 void OAccessibleMenuBaseComponent::InsertChild( sal_Int32 i )
 409 {
 410     if ( i > (sal_Int32)m_aAccessibleChildren.size() )
 411         i = m_aAccessibleChildren.size();
 412
 413     if ( i >= 0 )
 414     {
 415         // insert entry in child list
 416         m_aAccessibleChildren.insert( m_aAccessibleChildren.begin() + i, Reference< XAccessible >() );
 417
 418         // update item position of accessible children
 419         for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
 420         {
 421             Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
 422             if ( xAcc.is() )
 423             {
 424                 OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
 425                 if ( pComp )
 426                     pComp->SetItemPos( (sal_uInt16)j );
 427             }
 428         }
 429
 430         // send accessible child event
 431         Reference< XAccessible > xChild( GetChild( i ) );
 432         if ( xChild.is() )
 433         {
 434             Any aOldValue, aNewValue;
 435             aNewValue <<= xChild;
 436             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 437         }
 438     }
 439 }
 440
 441
 442
 443 void OAccessibleMenuBaseComponent::RemoveChild( sal_Int32 i )
 444 {
 445     if ( i >= 0 && i < (sal_Int32)m_aAccessibleChildren.size() )
 446     {
 447         // keep the accessible of the removed item
 448         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 449
 450         // remove entry in child list
 451         m_aAccessibleChildren.erase( m_aAccessibleChildren.begin() + i );
 452
 453         // update item position of accessible children
 454         for ( sal_uInt32 j = i, nCount = m_aAccessibleChildren.size(); j < nCount; ++j )
 455         {
 456             Reference< XAccessible > xAcc( m_aAccessibleChildren[j] );
 457             if ( xAcc.is() )
 458             {
 459                 OAccessibleMenuItemComponent* pComp = static_cast< OAccessibleMenuItemComponent* >( xAcc.get() );
 460                 if ( pComp )
 461                     pComp->SetItemPos( (sal_uInt16)j );
 462             }
 463         }
 464
 465         // send accessible child event
 466         if ( xChild.is() )
 467         {
 468             Any aOldValue, aNewValue;
 469             aOldValue <<= xChild;
 470             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 471
 472             Reference< XComponent > xComponent( xChild, UNO_QUERY );
 473             if ( xComponent.is() )
 474                 xComponent->dispose();
 475         }
 476     }
 477 }
 478
 479
 480
 481 bool OAccessibleMenuBaseComponent::IsHighlighted()
 482 {
 483     return false;
 484 }
 485
 486
 487
 488 bool OAccessibleMenuBaseComponent::IsChildHighlighted()
 489 {
 490     bool bChildHighlighted = false;
 491
 492     for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 493     {
 494         Reference< XAccessible > xChild( m_aAccessibleChildren[i] );
 495         if ( xChild.is() )
 496         {
 497             OAccessibleMenuBaseComponent* pComp = static_cast< OAccessibleMenuBaseComponent* >( xChild.get() );
 498             if ( pComp && pComp->IsHighlighted() )
 499             {
 500                 bChildHighlighted = true;
 501                 break;
 502             }
 503         }
 504     }
 505
 506     return bChildHighlighted;
 507 }
 508
 509
 510
 511 void OAccessibleMenuBaseComponent::SelectChild( sal_Int32 i )
 512 {
 513     // open the menu
 514     if ( getAccessibleRole() == AccessibleRole::MENU && !IsPopupMenuOpen() )
 515         Click();
 516
 517     // highlight the child
 518     if ( m_pMenu )
 519         m_pMenu->HighlightItem( (sal_uInt16)i );
 520 }
 521
 522
 523
 524 void OAccessibleMenuBaseComponent::DeSelectAll()
 525 {
 526     if ( m_pMenu )
 527         m_pMenu->DeHighlight();
 528 }
 529
 530
 531
 532 bool OAccessibleMenuBaseComponent::IsChildSelected( sal_Int32 i )
 533 {
 534     bool bSelected = false;
 535
 536     if ( m_pMenu && m_pMenu->IsHighlighted( (sal_uInt16)i ) )
 537         bSelected = true;
 538
 539     return bSelected;
 540 }
 541
 542
 543
 544 void OAccessibleMenuBaseComponent::Select()
 545 {
 546 }
 547
 548
 549
 550 void OAccessibleMenuBaseComponent::DeSelect()
 551 {
 552 }
 553
 554
 555
 556 void OAccessibleMenuBaseComponent::Click()
 557 {
 558 }
 559
 560
 561
 562 bool OAccessibleMenuBaseComponent::IsPopupMenuOpen()
 563 {
 564     return false;
 565 }
 566
 567
 568
 569 IMPL_LINK( OAccessibleMenuBaseComponent, MenuEventListener, VclSimpleEvent*, pEvent )
 570 {
 571     OSL_ENSURE( pEvent && pEvent->ISA( VclMenuEvent ), "OAccessibleMenuBaseComponent - Unknown MenuEvent!" );
 572     if ( pEvent && pEvent->ISA( VclMenuEvent ) )
 573     {
 574         OSL_ENSURE( static_cast<VclMenuEvent*>(pEvent)->GetMenu(), "OAccessibleMenuBaseComponent - Menu?" );
 575         ProcessMenuEvent( *static_cast<VclMenuEvent*>(pEvent) );
 576     }
 577     return 0;
 578 }
 579
 580
 581
 582 void OAccessibleMenuBaseComponent::ProcessMenuEvent( const VclMenuEvent& rVclMenuEvent )
 583 {
 584     sal_uInt16 nItemPos = rVclMenuEvent.GetItemPos();
 585
 586     switch ( rVclMenuEvent.GetId() )
 587     {
 588         case VCLEVENT_MENU_SHOW:
 589         case VCLEVENT_MENU_HIDE:
 590         {
 591             UpdateVisible();
 592         }
 593         break;
 594         case VCLEVENT_MENU_HIGHLIGHT:
 595         {
 596             SetFocused( false );
 597             UpdateFocused( nItemPos, true );
 598             UpdateSelected( nItemPos, true );
 599         }
 600         break;
 601         case VCLEVENT_MENU_DEHIGHLIGHT:
 602         {
 603             UpdateFocused( nItemPos, false );
 604             UpdateSelected( nItemPos, false );
 605         }
 606         break;
 607         case VCLEVENT_MENU_SUBMENUACTIVATE:
 608         {
 609         }
 610         break;
 611         case VCLEVENT_MENU_SUBMENUDEACTIVATE:
 612         {
 613             UpdateFocused( nItemPos, true );
 614         }
 615         break;
 616         case VCLEVENT_MENU_ENABLE:
 617         {
 618             UpdateEnabled( nItemPos, true );
 619         }
 620         break;
 621         case VCLEVENT_MENU_DISABLE:
 622         {
 623             UpdateEnabled( nItemPos, false );
 624         }
 625         break;
 626         case VCLEVENT_MENU_SUBMENUCHANGED:
 627         {
 628             RemoveChild( nItemPos );
 629             InsertChild( nItemPos );
 630         }
 631         break;
 632         case VCLEVENT_MENU_INSERTITEM:
 633         {
 634             InsertChild( nItemPos );
 635         }
 636         break;
 637         case VCLEVENT_MENU_REMOVEITEM:
 638         {
 639             RemoveChild( nItemPos );
 640         }
 641         break;
 642         case VCLEVENT_MENU_ACCESSIBLENAMECHANGED:
 643         {
 644             UpdateAccessibleName( nItemPos );
 645         }
 646         break;
 647         case VCLEVENT_MENU_ITEMTEXTCHANGED:
 648         {
 649             UpdateAccessibleName( nItemPos );
 650             UpdateItemText( nItemPos );
 651         }
 652         break;
 653         case VCLEVENT_MENU_ITEMCHECKED:
 654         {
 655             UpdateChecked( nItemPos, true );
 656         }
 657         break;
 658         case VCLEVENT_MENU_ITEMUNCHECKED:
 659         {
 660             UpdateChecked( nItemPos, false );
 661         }
 662         break;
 663         case VCLEVENT_OBJECT_DYING:
 664         {
 665             if ( m_pMenu )
 666             {
 667                 m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
 668
 669                 m_pMenu = NULL;
 670
 671                 // dispose all menu items
 672                 for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 673                 {
 674                     Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 675                     if ( xComponent.is() )
 676                         xComponent->dispose();
 677                 }
 678                 m_aAccessibleChildren.clear();
 679             }
 680         }
 681         break;
 682         default:
 683         {
 684         }
 685         break;
 686     }
 687 }
 688
 689
 690 // XInterface
 691
 692
 693 IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleMenuBaseComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleMenuBaseComponent_BASE )
 694
 695
 696 // XTypeProvider
 697
 698
 699 IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleMenuBaseComponent, AccessibleExtendedComponentHelper_BASE, OAccessibleMenuBaseComponent_BASE )
 700
 701
 702 // XComponent
 703
 704
 705 void OAccessibleMenuBaseComponent::disposing()
 706 {
 707     AccessibleExtendedComponentHelper_BASE::disposing();
 708
 709     if ( m_pMenu )
 710     {
 711         m_pMenu->RemoveEventListener( LINK( this, OAccessibleMenuBaseComponent, MenuEventListener ) );
 712
 713         m_pMenu = NULL;
 714
 715         // dispose all menu items
 716         for ( sal_uInt32 i = 0; i < m_aAccessibleChildren.size(); ++i )
 717         {
 718             Reference< XComponent > xComponent( m_aAccessibleChildren[i], UNO_QUERY );
 719             if ( xComponent.is() )
 720                 xComponent->dispose();
 721         }
 722         m_aAccessibleChildren.clear();
 723     }
 724 }
 725
 726
 727 // XServiceInfo
 728
 729
 730 sal_Bool OAccessibleMenuBaseComponent::supportsService( const OUString& rServiceName ) throw (RuntimeException, std::exception)
 731 {
 732     return cppu::supportsService(this, rServiceName);
 733 }
 734
 735
 736 // XAccessible
 737
 738
 739 Reference< XAccessibleContext > OAccessibleMenuBaseComponent::getAccessibleContext(  ) throw (RuntimeException, std::exception)
 740 {
 741     OExternalLockGuard aGuard( this );
 742
 743     return this;
 744 }
 745
 746
 747 // XAccessibleContext
 748
 749
 750 Reference< XAccessibleStateSet > OAccessibleMenuBaseComponent::getAccessibleStateSet(  ) throw (RuntimeException, std::exception)
 751 {
 752     OExternalLockGuard aGuard( this );
 753
 754     utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 755     Reference< XAccessibleStateSet > xSet = pStateSetHelper;
 756
 757     if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
 758     {
 759         FillAccessibleStateSet( *pStateSetHelper );
 760     }
 761     else
 762     {
 763         pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 764     }
 765
 766     return xSet;
 767 }
 768
 769
 770
 771 bool OAccessibleMenuBaseComponent::IsMenuHideDisabledEntries()
 772 {
 773     return false;
 774 }
 775
 776 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */