accessibility/source/standard/accessiblemenubasecomponent.cxx

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