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