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