accessibility/source/standard/vclxaccessibletoolbox.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 #include <string.h>
  20
  21 #include <standard/vclxaccessibletoolbox.hxx>
  22 #include <standard/vclxaccessibletoolboxitem.hxx>
  23
  24 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  25 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  26 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  27 #include <o3tl/safeint.hxx>
  28 #include <vcl/toolbox.hxx>
  29 #include <vcl/unohelp.hxx>
  30 #include <vcl/vclevent.hxx>
  31 #include <comphelper/accessiblecontexthelper.hxx>
  32 #include <comphelper/accessiblewrapper.hxx>
  33 #include <comphelper/processfactory.hxx>
  34 #include <comphelper/servicehelper.hxx>
  35 #include <comphelper/types.hxx>
  36
  37 using namespace ::comphelper;
  38 using namespace ::com::sun::star;
  39 using namespace ::com::sun::star::uno;
  40 using namespace ::com::sun::star::lang;
  41 using namespace ::com::sun::star::accessibility;
  42
  43 namespace
  44 {
  45
  46     // = OToolBoxWindowItemContext
  47
  48     /** XAccessibleContext implementation for a toolbox item which is represented by a VCL Window
  49     */
  50     class OToolBoxWindowItemContext final : public OAccessibleContextWrapper
  51     {
  52         sal_Int32 m_nIndexInParent;
  53     public:
  54         OToolBoxWindowItemContext(sal_Int32 _nIndexInParent,
  55             const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
  56             const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerAccessibleContext,
  57             const css::uno::Reference< css::accessibility::XAccessible >& _rxOwningAccessible,
  58             const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
  59             ) : OAccessibleContextWrapper(
  60             _rxContext,
  61             _rxInnerAccessibleContext,
  62             _rxOwningAccessible,
  63             _rxParentAccessible     )
  64             ,m_nIndexInParent(_nIndexInParent)
  65         {
  66         }
  67         virtual sal_Int64 SAL_CALL getAccessibleIndexInParent(  ) override;
  68     };
  69
  70
  71     sal_Int64 SAL_CALL OToolBoxWindowItemContext::getAccessibleIndexInParent(  )
  72     {
  73         return m_nIndexInParent;
  74     }
  75
  76
  77     // = OToolBoxWindowItem
  78
  79     /** XAccessible implementation for a toolbox item which is represented by a VCL Window
  80     */
  81     class OToolBoxWindowItem : public OAccessibleWrapper
  82     {
  83     private:
  84         sal_Int32 m_nIndexInParent;
  85
  86     public:
  87         OToolBoxWindowItem(sal_Int32 _nIndexInParent,
  88             const css::uno::Reference< css::uno::XComponentContext >& _rxContext,
  89             const css::uno::Reference< css::accessibility::XAccessible >& _rxInnerAccessible,
  90             const css::uno::Reference< css::accessibility::XAccessible >& _rxParentAccessible
  91             ) : OAccessibleWrapper(
  92             _rxContext,
  93             _rxInnerAccessible,
  94             _rxParentAccessible)
  95             ,m_nIndexInParent(_nIndexInParent)
  96         {
  97         }
  98
  99     protected:
 100         // OAccessibleWrapper
 101         virtual rtl::Reference<OAccessibleContextWrapper> createAccessibleContext(
 102                 const css::uno::Reference< css::accessibility::XAccessibleContext >& _rxInnerContext
 103             ) override;
 104     };
 105
 106     rtl::Reference<OAccessibleContextWrapper> OToolBoxWindowItem::createAccessibleContext(
 107             const Reference< XAccessibleContext >& _rxInnerContext )
 108     {
 109         return new OToolBoxWindowItemContext( m_nIndexInParent, getComponentContext(), _rxInnerContext, this, getParent() );
 110     }
 111 }
 112
 113 // VCLXAccessibleToolBox
 114
 115 VCLXAccessibleToolBox::VCLXAccessibleToolBox(ToolBox* pToolBox)
 116     : ImplInheritanceHelper(pToolBox)
 117 {
 118 }
 119
 120 VCLXAccessibleToolBox::~VCLXAccessibleToolBox()
 121 {
 122 }
 123
 124 VCLXAccessibleToolBoxItem* VCLXAccessibleToolBox::GetItem_Impl( ToolBox::ImplToolItems::size_type _nPos )
 125 {
 126     VCLXAccessibleToolBoxItem* pItem = nullptr;
 127     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 128     if ( pToolBox )
 129     {
 130         ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
 131             //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 132         // returns only toolbox buttons, not windows
 133         if ( aIter != m_aAccessibleChildren.end()  && aIter->second.is())
 134             pItem = aIter->second.get();
 135     }
 136
 137     return pItem;
 138 }
 139
 140 void VCLXAccessibleToolBox::UpdateFocus_Impl()
 141 {
 142     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 143     if( !pToolBox )
 144         return;
 145
 146     // submit events only if toolbox has the focus to avoid sending events due to mouse move
 147     bool bHasFocus = false;
 148     if ( pToolBox->HasFocus() )
 149         bHasFocus = true;
 150     else
 151     {
 152         // check for subtoolbar, i.e. check if our parent is a toolbar
 153         ToolBox* pToolBoxParent = dynamic_cast< ToolBox* >( pToolBox->GetParent() );
 154         // subtoolbars never get the focus as key input is just forwarded, so check if the parent toolbar has it
 155         if ( pToolBoxParent && pToolBoxParent->HasFocus() )
 156             bHasFocus = true;
 157     }
 158
 159     if ( !bHasFocus )
 160         return;
 161
 162     ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
 163     sal_uInt16 nFocusCount = 0;
 164     for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
 165     {
 166         ToolBoxItemId nItemId = pToolBox->GetItemId( rPos );
 167
 168         if ( rxChild.is() )
 169         {
 170             VCLXAccessibleToolBoxItem* pItem = rxChild.get();
 171             if ( pItem->HasFocus() && nItemId != nHighlightItemId )
 172             {
 173                 // reset the old focused item
 174                 pItem->SetFocus( false );
 175                 nFocusCount++;
 176             }
 177             if ( nItemId == nHighlightItemId )
 178             {
 179                 // set the new focused item
 180                 pItem->SetFocus( true );
 181                 nFocusCount++;
 182             }
 183         }
 184         // both items changed?
 185         if ( nFocusCount > 1 )
 186             break;
 187     }
 188 }
 189
 190 void VCLXAccessibleToolBox::ReleaseFocus_Impl( ToolBox::ImplToolItems::size_type _nPos )
 191 {
 192     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 193     if ( pToolBox ) // #107124#, do not check for focus because this message is also handled in losefocus
 194     {
 195         ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
 196             //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 197         if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
 198         {
 199             VCLXAccessibleToolBoxItem* pItem = aIter->second.get();
 200             if ( pItem->HasFocus() )
 201                 pItem->SetFocus( false );
 202         }
 203     }
 204 }
 205
 206 void VCLXAccessibleToolBox::UpdateChecked_Impl( ToolBox::ImplToolItems::size_type _nPos )
 207 {
 208     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 209     if ( !pToolBox )
 210         return;
 211
 212     ToolBoxItemId nFocusId = pToolBox->GetItemId( _nPos );
 213     VCLXAccessibleToolBoxItem* pFocusItem = nullptr;
 214
 215     for ( const auto& [rPos, rxChild] : m_aAccessibleChildren )
 216     {
 217             ToolBoxItemId nItemId = pToolBox->GetItemId( rPos );
 218
 219             VCLXAccessibleToolBoxItem* pItem = rxChild.get();
 220             pItem->SetChecked( pToolBox->IsItemChecked( nItemId ) );
 221             if ( nItemId == nFocusId )
 222                 pFocusItem = pItem;
 223     }
 224     //Solution:If the position is not a child item,the focus should not be called
 225     if ( pFocusItem && _nPos != ToolBox::ITEM_NOTFOUND )
 226         pFocusItem->SetFocus( true );
 227 }
 228
 229 void VCLXAccessibleToolBox::UpdateIndeterminate_Impl( ToolBox::ImplToolItems::size_type _nPos )
 230 {
 231     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 232     if ( !pToolBox )
 233         return;
 234
 235     ToolBoxItemId nItemId = pToolBox->GetItemId( _nPos );
 236
 237     ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find( _nPos );
 238         //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 239     if ( aIter != m_aAccessibleChildren.end() && aIter->second.is() )
 240     {
 241         VCLXAccessibleToolBoxItem* pItem = aIter->second.get();
 242         if ( pItem )
 243             pItem->SetIndeterminate( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET );
 244     }
 245 }
 246
 247 void VCLXAccessibleToolBox::implReleaseToolboxItem( ToolBoxItemsMap::iterator const & _rMapPos,
 248         bool _bNotifyRemoval )
 249 {
 250     rtl::Reference<VCLXAccessibleToolBoxItem> xItemAcc(_rMapPos->second);
 251     if ( !xItemAcc.is() )
 252         return;
 253
 254     if ( _bNotifyRemoval )
 255     {
 256         NotifyAccessibleEvent(AccessibleEventId::CHILD, Any(Reference<XAccessible>(xItemAcc)), Any());
 257     }
 258
 259     xItemAcc->ReleaseToolBox();
 260     xItemAcc->dispose();
 261 }
 262
 263 void VCLXAccessibleToolBox::UpdateItem_Impl( ToolBox::ImplToolItems::size_type _nPos)
 264 {
 265     if ( _nPos < m_aAccessibleChildren.size() )
 266     {
 267         UpdateAllItems_Impl();
 268         return;
 269     }
 270
 271     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 272     if ( !pToolBox )
 273         return;
 274
 275     // adjust the "index-in-parent"s
 276     ToolBoxItemsMap::iterator aIndexAdjust = m_aAccessibleChildren.upper_bound( _nPos );
 277         //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 278     while ( m_aAccessibleChildren.end() != aIndexAdjust )
 279     {
 280         rtl::Reference<VCLXAccessibleToolBoxItem> xItem(aIndexAdjust->second);
 281         if (xItem.is())
 282         {
 283             sal_Int32 nIndex = xItem->getIndexInParent();
 284             nIndex++;
 285             xItem->setIndexInParent(nIndex);
 286         }
 287
 288         ++aIndexAdjust;
 289     }
 290
 291     // TODO: we should make this dependent on the existence of event listeners
 292     // with the current implementation, we always create accessible object
 293     Any aNewChild( getAccessibleChild( static_cast<sal_Int64>(_nPos) ) );
 294         //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 295     NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewChild );
 296 }
 297
 298 void VCLXAccessibleToolBox::UpdateAllItems_Impl()
 299 {
 300     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 301     if ( !pToolBox )
 302         return;
 303
 304     // deregister the old items
 305     for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
 306             aIter != m_aAccessibleChildren.end(); ++aIter )
 307     {
 308         implReleaseToolboxItem( aIter, true );
 309     }
 310     m_aAccessibleChildren.clear();
 311
 312     // register the new items
 313     ToolBox::ImplToolItems::size_type i, nCount = pToolBox->GetItemCount();
 314     for ( i = 0; i < nCount; ++i )
 315     {
 316         Any aNewValue;
 317         aNewValue <<= getAccessibleChild(i);
 318         NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
 319     }
 320 }
 321
 322 void VCLXAccessibleToolBox::UpdateCustomPopupItemp_Impl( vcl::Window* pWindow, bool bOpen )
 323 {
 324     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 325     if( !(pWindow && pToolBox) )
 326         return;
 327
 328     const ToolBoxItemId nDownItem = pToolBox->GetDownItemId();
 329     if ( !nDownItem )
 330         // No item is currently in down state.
 331         // Moreover, calling GetItemPos with 0 will find a separator if there is any.
 332         return;
 333
 334     Reference< XAccessible > xChild( pWindow->GetAccessible() );
 335     if( xChild.is() )
 336     {
 337         Reference< XAccessible > xChildItem( getAccessibleChild(pToolBox->GetItemPos(nDownItem)));
 338         VCLXAccessibleToolBoxItem* pItem = static_cast< VCLXAccessibleToolBoxItem* >( xChildItem.get() );
 339
 340         pItem->SetChild( xChild );
 341         pItem->NotifyChildEvent( xChild, bOpen );
 342     }
 343 }
 344
 345 void VCLXAccessibleToolBox::UpdateItemName_Impl( ToolBox::ImplToolItems::size_type _nPos )
 346 {
 347     VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
 348     if ( pItem )
 349         pItem->NameChanged();
 350 }
 351
 352 void VCLXAccessibleToolBox::UpdateItemEnabled_Impl( ToolBox::ImplToolItems::size_type _nPos )
 353 {
 354     VCLXAccessibleToolBoxItem* pItem = GetItem_Impl( _nPos );
 355     if ( pItem )
 356         pItem->ToggleEnableState();
 357 }
 358
 359 void VCLXAccessibleToolBox::HandleSubToolBarEvent( const VclWindowEvent& rVclWindowEvent )
 360 {
 361     vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
 362     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 363     if ( !(pChildWindow
 364         && pToolBox
 365         && pToolBox == pChildWindow->GetParent()
 366         && pChildWindow->GetType() == WindowType::TOOLBOX) )
 367         return;
 368
 369     const ToolBoxItemId nCurItemId( pToolBox->GetCurItemId() );
 370     if ( !nCurItemId )
 371         // No item is currently active (might happen when opening the overflow popup).
 372         // Moreover, calling GetItemPos with 0 will find a separator if there is any.
 373         return;
 374
 375     ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( nCurItemId );
 376     Reference< XAccessible > xItem = getAccessibleChild( nIndex );
 377     if ( xItem.is() )
 378     {
 379         Reference< XAccessible > xChild = pChildWindow->GetAccessible();
 380         VCLXAccessibleToolBoxItem* pItem =
 381             static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
 382         pItem->SetChild( xChild );
 383         pItem->NotifyChildEvent( xChild, true/*_bShow*/ );
 384     }
 385 }
 386
 387 void VCLXAccessibleToolBox::ReleaseSubToolBox( ToolBox* _pSubToolBox )
 388 {
 389     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 390     if ( !pToolBox )
 391         return;
 392
 393     ToolBox::ImplToolItems::size_type nIndex = pToolBox->GetItemPos( pToolBox->GetCurItemId() );
 394     if ( nIndex == ToolBox::ITEM_NOTFOUND )
 395         return; // not found
 396
 397     Reference< XAccessible > xItem = getAccessibleChild( nIndex );
 398     if ( !xItem.is() )
 399         return;
 400
 401     Reference< XAccessible > xChild = _pSubToolBox->GetAccessible();
 402     VCLXAccessibleToolBoxItem* pItem =
 403         static_cast< VCLXAccessibleToolBoxItem* >( xItem.get() );
 404     if ( pItem->GetChild() == xChild )
 405     {
 406         pItem->SetChild( Reference< XAccessible >() );
 407         pItem->NotifyChildEvent( xChild, false );
 408     }
 409 }
 410
 411 void VCLXAccessibleToolBox::FillAccessibleStateSet( sal_Int64& rStateSet )
 412 {
 413     VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
 414
 415     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 416     if ( pToolBox )
 417     {
 418         rStateSet |= AccessibleStateType::FOCUSABLE;
 419         if ( pToolBox->IsHorizontal() )
 420             rStateSet |= AccessibleStateType::HORIZONTAL;
 421         else
 422             rStateSet |= AccessibleStateType::VERTICAL;
 423     }
 424 }
 425
 426 void VCLXAccessibleToolBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
 427 {
 428     // to prevent an early release of the toolbox (VclEventId::ObjectDying)
 429     Reference< XAccessibleContext > xHoldAlive = this;
 430
 431     switch ( rVclWindowEvent.GetId() )
 432     {
 433         case VclEventId::ToolboxClick:
 434         case VclEventId::ToolboxSelect:
 435         {
 436             VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 437             if ( rVclWindowEvent.GetData() )
 438             {
 439                 UpdateChecked_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 440                 UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 441             }
 442             else if( pToolBox->GetItemPos(pToolBox->GetCurItemId()) != ToolBox::ITEM_NOTFOUND )
 443             {
 444                 UpdateChecked_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
 445                 UpdateIndeterminate_Impl( pToolBox->GetItemPos(pToolBox->GetCurItemId()) );
 446             }
 447             break;
 448         }
 449         case VclEventId::ToolboxDoubleClick:
 450         case VclEventId::ToolboxActivate:
 451         case VclEventId::ToolboxDeactivate:
 452         //case VclEventId::ToolboxSelect:
 453             break;
 454
 455         case VclEventId::ToolboxItemUpdated:
 456         {
 457             if ( rVclWindowEvent.GetData() )
 458             {
 459                 UpdateChecked_Impl( ToolBox::ITEM_NOTFOUND );
 460                 UpdateIndeterminate_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 461             }
 462             break;
 463         }
 464
 465         case VclEventId::ToolboxHighlight:
 466             UpdateFocus_Impl();
 467             break;
 468
 469         case VclEventId::ToolboxHighlightOff:
 470             ReleaseFocus_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 471             break;
 472
 473         case VclEventId::ToolboxItemAdded :
 474             UpdateItem_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 475             break;
 476
 477         case VclEventId::ToolboxItemRemoved :
 478         case VclEventId::ToolboxAllItemsChanged :
 479         {
 480             UpdateAllItems_Impl();
 481             break;
 482         }
 483
 484         case VclEventId::ToolboxItemWindowChanged:
 485         {
 486             auto nPos = static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData()));
 487             ToolBoxItemsMap::iterator aAccessiblePos( m_aAccessibleChildren.find( nPos ) );
 488                 //TODO: ToolBox::ImplToolItems::size_type -> sal_Int32!
 489             if ( m_aAccessibleChildren.end() != aAccessiblePos )
 490             {
 491                 implReleaseToolboxItem( aAccessiblePos, false );
 492                 m_aAccessibleChildren.erase (aAccessiblePos);
 493             }
 494
 495             Any aNewValue;
 496             aNewValue <<= getAccessibleChild(nPos);
 497             NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), aNewValue );
 498             break;
 499         }
 500         case VclEventId::ToolboxItemTextChanged :
 501             UpdateItemName_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 502             break;
 503
 504         case VclEventId::ToolboxItemEnabled :
 505         case VclEventId::ToolboxItemDisabled :
 506         {
 507             UpdateItemEnabled_Impl( static_cast<ToolBox::ImplToolItems::size_type>(reinterpret_cast<sal_IntPtr>(rVclWindowEvent.GetData())) );
 508             break;
 509         }
 510
 511         case VclEventId::DropdownOpen:
 512         case VclEventId::DropdownClose:
 513         {
 514             UpdateCustomPopupItemp_Impl( static_cast< vcl::Window* >( rVclWindowEvent.GetData() ), rVclWindowEvent.GetId() == VclEventId::DropdownOpen );
 515             break;
 516         }
 517
 518         case VclEventId::ObjectDying :
 519         {
 520             // if this toolbox is a subtoolbox, we have to release it from its parent
 521             VclPtr< vcl::Window > pWin = GetAs< vcl::Window >();
 522             if ( pWin && pWin->GetParent() &&
 523                  pWin->GetParent()->GetType() == WindowType::TOOLBOX )
 524             {
 525                 auto pParentAccContext = pWin->GetParent()->GetAccessible()->getAccessibleContext();
 526                 VCLXAccessibleToolBox* pParent = static_cast< VCLXAccessibleToolBox* >( pParentAccContext.get() );
 527                 if ( pParent )
 528                     pParent->ReleaseSubToolBox(static_cast<ToolBox *>(pWin.get()));
 529             }
 530
 531             // dispose all items
 532             for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
 533                   aIter != m_aAccessibleChildren.end(); ++aIter )
 534             {
 535                 implReleaseToolboxItem( aIter, false );
 536             }
 537             m_aAccessibleChildren.clear();
 538
 539             [[fallthrough]]; // call base class
 540         }
 541
 542         default:
 543             VCLXAccessibleComponent::ProcessWindowEvent( rVclWindowEvent );
 544     }
 545 }
 546
 547 void VCLXAccessibleToolBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
 548 {
 549     switch ( rVclWindowEvent.GetId() )
 550     {
 551         case VclEventId::WindowShow:  // send create on show for direct accessible children
 552         {
 553             Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
 554             if ( xReturn.is() )
 555                 NotifyAccessibleEvent( AccessibleEventId::CHILD, Any(), Any(xReturn) );
 556             else
 557                 HandleSubToolBarEvent( rVclWindowEvent );
 558         }
 559         break;
 560
 561         default:
 562            VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );
 563
 564     }
 565 }
 566
 567 // XComponent
 568 void SAL_CALL VCLXAccessibleToolBox::disposing()
 569 {
 570     VCLXAccessibleComponent::disposing();
 571
 572     // release the items
 573     for ( ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.begin();
 574           aIter != m_aAccessibleChildren.end(); ++aIter )
 575     {
 576         implReleaseToolboxItem( aIter, false );
 577     }
 578     m_aAccessibleChildren.clear();
 579 }
 580
 581 // XServiceInfo
 582 OUString VCLXAccessibleToolBox::getImplementationName()
 583 {
 584     return u"com.sun.star.comp.toolkit.AccessibleToolBox"_ustr;
 585 }
 586
 587 Sequence< OUString > VCLXAccessibleToolBox::getSupportedServiceNames()
 588 {
 589     return comphelper::concatSequences(VCLXAccessibleComponent::getSupportedServiceNames(),
 590                                        std::initializer_list<OUString>{u"com.sun.star.accessibility.AccessibleToolBox"_ustr});
 591 }
 592
 593 // XAccessibleContext
 594 sal_Int64 SAL_CALL VCLXAccessibleToolBox::getAccessibleChildCount(  )
 595 {
 596     comphelper::OExternalLockGuard aGuard( this );
 597     return implGetAccessibleChildCount();
 598 }
 599
 600  sal_Int64 VCLXAccessibleToolBox::implGetAccessibleChildCount(  )
 601  {
 602     sal_Int64 nCount = 0;
 603     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 604     if ( pToolBox )
 605         nCount = pToolBox->GetItemCount();
 606
 607     return nCount;
 608 }
 609
 610 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleChild( sal_Int64 i )
 611 {
 612     comphelper::OExternalLockGuard aGuard( this );
 613
 614     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 615     if ( (!pToolBox) || i < 0 || o3tl::make_unsigned(i) >= pToolBox->GetItemCount() )
 616         throw IndexOutOfBoundsException();
 617
 618     rtl::Reference< VCLXAccessibleToolBoxItem > xChild;
 619     // search for the child
 620     ToolBoxItemsMap::iterator aIter = m_aAccessibleChildren.find(i);
 621     if ( m_aAccessibleChildren.end() == aIter )
 622     {
 623         ToolBoxItemId nItemId = pToolBox->GetItemId( i );
 624         ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
 625         vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
 626         // not found -> create a new child
 627         xChild = new VCLXAccessibleToolBoxItem( pToolBox, i );
 628         if ( pItemWindow )
 629         {
 630             Reference< XAccessible> xParent = xChild;
 631             auto const xInnerAcc(pItemWindow->GetAccessible());
 632             if (xInnerAcc) // else child is being disposed - avoid crashing
 633             {
 634                 rtl::Reference<OToolBoxWindowItem> xChild2(new OToolBoxWindowItem(0,
 635                     ::comphelper::getProcessComponentContext(), xInnerAcc, xParent));
 636                 pItemWindow->SetAccessible(xChild2);
 637                 xChild->SetChild( xChild2 );
 638             }
 639         }
 640         if ( nHighlightItemId > ToolBoxItemId(0) && nItemId == nHighlightItemId )
 641             xChild->SetFocus( true );
 642         if ( pToolBox->IsItemChecked( nItemId ) )
 643             xChild->SetChecked( true );
 644         if ( pToolBox->GetItemState( nItemId ) == TRISTATE_INDET )
 645             xChild->SetIndeterminate( true );
 646         m_aAccessibleChildren.emplace( i, xChild );
 647     }
 648     else
 649     {
 650         // found it
 651         xChild = aIter->second;
 652     }
 653     return xChild;
 654 }
 655
 656 Reference< XAccessible > SAL_CALL VCLXAccessibleToolBox::getAccessibleAtPoint( const awt::Point& _rPoint )
 657 {
 658     comphelper::OExternalLockGuard aGuard( this );
 659
 660     Reference< XAccessible > xAccessible;
 661     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 662     if ( pToolBox )
 663     {
 664         ToolBox::ImplToolItems::size_type nItemPos
 665             = pToolBox->GetItemPos(vcl::unohelper::ConvertToVCLPoint(_rPoint));
 666         if ( nItemPos != ToolBox::ITEM_NOTFOUND )
 667             xAccessible = getAccessibleChild( nItemPos );
 668     }
 669
 670     return xAccessible;
 671 }
 672
 673 Reference< XAccessible > VCLXAccessibleToolBox::GetItemWindowAccessible( const VclWindowEvent& rVclWindowEvent )
 674 {
 675     Reference< XAccessible > xReturn;
 676     vcl::Window* pChildWindow = static_cast<vcl::Window *>(rVclWindowEvent.GetData());
 677     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 678     if ( pChildWindow && pToolBox )
 679     {
 680         ToolBox::ImplToolItems::size_type nCount = pToolBox->GetItemCount();
 681         for (ToolBox::ImplToolItems::size_type i = 0 ; i < nCount && !xReturn.is() ; ++i)
 682         {
 683             ToolBoxItemId nItemId = pToolBox->GetItemId( i );
 684             vcl::Window* pItemWindow = pToolBox->GetItemWindow( nItemId );
 685             if ( pItemWindow == pChildWindow )
 686                 xReturn = getAccessibleChild(i);
 687         }
 688     }
 689     return xReturn;
 690 }
 691
 692 Reference< XAccessible > VCLXAccessibleToolBox::GetChildAccessible( const VclWindowEvent& rVclWindowEvent )
 693 {
 694     Reference< XAccessible > xReturn = GetItemWindowAccessible(rVclWindowEvent);
 695
 696     if ( !xReturn.is() )
 697         xReturn = VCLXAccessibleComponent::GetChildAccessible(rVclWindowEvent);
 698     return xReturn;
 699 }
 700
 701 // XAccessibleSelection
 702 void VCLXAccessibleToolBox::selectAccessibleChild( sal_Int64 nChildIndex )
 703 {
 704     OExternalLockGuard aGuard( this );
 705
 706     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 707     if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
 708         throw IndexOutOfBoundsException();
 709
 710     pToolBox->ChangeHighlight( nChildIndex );
 711 }
 712
 713 sal_Bool VCLXAccessibleToolBox::isAccessibleChildSelected( sal_Int64 nChildIndex )
 714 {
 715     OExternalLockGuard aGuard( this );
 716     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 717     if ( (!pToolBox) || nChildIndex < 0 || o3tl::make_unsigned(nChildIndex) >= pToolBox->GetItemCount() )
 718         throw IndexOutOfBoundsException();
 719
 720     if ( pToolBox->GetHighlightItemId() == pToolBox->GetItemId( nChildIndex ) )
 721         return true;
 722     else
 723         return false;
 724 }
 725
 726 void VCLXAccessibleToolBox::clearAccessibleSelection(  )
 727 {
 728     OExternalLockGuard aGuard( this );
 729     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 730     pToolBox -> LoseFocus();
 731 }
 732
 733 void VCLXAccessibleToolBox::selectAllAccessibleChildren(  )
 734 {
 735     OExternalLockGuard aGuard( this );
 736     // intentionally empty. makes no sense for a toolbox
 737 }
 738
 739 sal_Int64 VCLXAccessibleToolBox::getSelectedAccessibleChildCount(  )
 740 {
 741     OExternalLockGuard aGuard( this );
 742
 743     sal_Int64 nRet = 0;
 744     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 745     if (pToolBox)
 746     {
 747         ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
 748         for ( size_t i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
 749         {
 750             if ( nHighlightItemId == pToolBox->GetItemId( i ) )
 751             {
 752                 nRet = 1;
 753                 break; // a toolbox can only have (n)one selected child
 754             }
 755         }
 756     }
 757
 758     return nRet;
 759 }
 760
 761 Reference< XAccessible > VCLXAccessibleToolBox::getSelectedAccessibleChild( sal_Int64 nSelectedChildIndex )
 762 {
 763     OExternalLockGuard aGuard( this );
 764     if ( nSelectedChildIndex != 0 )
 765         throw IndexOutOfBoundsException();
 766
 767     Reference< XAccessible > xChild;
 768     VclPtr< ToolBox > pToolBox = GetAs< ToolBox >();
 769     if (pToolBox)
 770     {
 771         ToolBoxItemId nHighlightItemId = pToolBox->GetHighlightItemId();
 772         for (ToolBox::ImplToolItems::size_type i = 0, nCount = pToolBox->GetItemCount(); i < nCount; i++ )
 773         {
 774             if ( nHighlightItemId == pToolBox->GetItemId( i ) )
 775             {
 776                 xChild = getAccessibleChild( i );
 777                 break;
 778             }
 779         }
 780     }
 781
 782     if (!xChild)
 783         throw IndexOutOfBoundsException();
 784
 785     return xChild;
 786 }
 787
 788 void VCLXAccessibleToolBox::deselectAccessibleChild( sal_Int64 nChildIndex )
 789 {
 790     OExternalLockGuard aGuard( this );
 791     if ( nChildIndex < 0 || nChildIndex >= implGetAccessibleChildCount() )
 792         throw IndexOutOfBoundsException();
 793     clearAccessibleSelection(); // a toolbox can only have (n)one selected child
 794 }
 795
 796 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */