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