accessibility/source/extended/accessiblelistbox.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 <extended/accessiblelistbox.hxx>
  21 #include <extended/accessiblelistboxentry.hxx>
  22 #include <vcl/treelistbox.hxx>
  23 #include <vcl/treelistentry.hxx>
  24 #include <com/sun/star/awt/Point.hpp>
  25 #include <com/sun/star/awt/Rectangle.hpp>
  26 #include <com/sun/star/awt/Size.hpp>
  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 <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <vcl/svapp.hxx>
  33 #include <toolkit/awt/vclxwindow.hxx>
  34 #include <toolkit/helper/convert.hxx>
  35 #include <unotools/accessiblestatesethelper.hxx>
  36
  37
  38 namespace accessibility
  39 {
  40
  41
  42     // class AccessibleListBox -----------------------------------------------------
  43
  44     using namespace ::com::sun::star::accessibility;
  45     using namespace ::com::sun::star::uno;
  46     using namespace ::com::sun::star::lang;
  47     using namespace ::com::sun::star;
  48
  49
  50     // Ctor() and Dtor()
  51
  52     AccessibleListBox::AccessibleListBox( SvTreeListBox const & _rListBox, const Reference< XAccessible >& _xParent ) :
  53
  54         VCLXAccessibleComponent( _rListBox.GetWindowPeer() ),
  55         m_xParent( _xParent )
  56     {
  57     }
  58
  59     AccessibleListBox::~AccessibleListBox()
  60     {
  61         if ( isAlive() )
  62         {
  63             // increment ref count to prevent double call of Dtor
  64             osl_atomic_increment( &m_refCount );
  65             dispose();
  66         }
  67     }
  68     IMPLEMENT_FORWARD_XINTERFACE2(AccessibleListBox, VCLXAccessibleComponent, ImplHelper2)
  69     IMPLEMENT_FORWARD_XTYPEPROVIDER2(AccessibleListBox, VCLXAccessibleComponent, ImplHelper2)
  70
  71     void AccessibleListBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
  72     {
  73         if ( isAlive() )
  74         {
  75             switch ( rVclWindowEvent.GetId() )
  76             {
  77             case  VclEventId::CheckboxToggle :
  78                 {
  79                     if ( !getListBox() || !getListBox()->HasFocus() )
  80                     {
  81                         return;
  82                     }
  83                     AccessibleListBoxEntry* pCurOpEntry = GetCurEventEntry(rVclWindowEvent);
  84                     if(!pCurOpEntry)
  85                     {
  86                         return ;
  87                     }
  88                     uno::Any aValue;
  89                     aValue <<= AccessibleStateType::CHECKED;
  90
  91                     if ( getListBox()->GetCheckButtonState( pCurOpEntry->GetSvLBoxEntry() ) == SvButtonState::Checked )
  92                     {
  93                         pCurOpEntry->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), aValue );
  94                     }
  95                     else
  96                     {
  97                         pCurOpEntry->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aValue,uno::Any() );
  98                     }
  99                     break;
 100                 }
 101
 102             case VclEventId::ListboxSelect :
 103                 {
 104                     OSL_FAIL("Debug: Treelist shouldn't use VclEventId::ListboxSelect");
 105                     break;
 106                 }
 107
 108             case VclEventId::ListboxTreeSelect:
 109                 {
 110                     if ( getListBox() && getListBox()->HasFocus() )
 111                     {
 112                         AccessibleListBoxEntry* pEntry =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
 113                         if (pEntry)
 114                         {
 115                             pEntry->NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
 116                         }
 117                     }
 118                 }
 119                 break;
 120             case VclEventId::ListboxTreeFocus:
 121                 {
 122                     VclPtr<SvTreeListBox> pBox = getListBox();
 123                     if( pBox && pBox->HasFocus() )
 124                     {
 125                         uno::Any aNewValue;
 126                         SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
 127                         if ( pEntry )
 128                         {
 129                             AccessibleListBoxEntry* pEntryFocus =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
 130                             if (pEntryFocus && pEntryFocus->GetSvLBoxEntry() == pEntry)
 131                             {
 132                                 aNewValue <<= m_xFocusedChild;
 133                                 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, uno::Any(), aNewValue );
 134                                 return ;
 135                             }
 136
 137                             uno::Any aOldValue;
 138                             aOldValue <<= m_xFocusedChild;
 139
 140                             MAP_ENTRY::iterator mi = m_mapEntry.find(pEntry);
 141                             if(mi != m_mapEntry.end())
 142                             {
 143                                 OSL_ASSERT(mi->second.get() != nullptr);
 144                                 m_xFocusedChild = mi->second;
 145                             }
 146                             else
 147                             {
 148                                 AccessibleListBoxEntry *pEntNew = new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
 149                                 m_xFocusedChild = pEntNew;
 150                                 m_mapEntry.emplace(pEntry,pEntNew);
 151                             }
 152
 153                             aNewValue <<= m_xFocusedChild;
 154                             NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldValue, aNewValue );
 155                         }
 156                         else
 157                         {
 158                             aNewValue <<= AccessibleStateType::FOCUSED;
 159                             NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), aNewValue );
 160                         }
 161                     }
 162                 }
 163                 break;
 164             case VclEventId::ListboxItemRemoved:
 165                 {
 166                     SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
 167                     if ( pEntry )
 168                     {
 169                         RemoveChildEntries(pEntry);
 170                     }
 171                     else
 172                     {
 173                         // NULL means Clear()
 174                         for (auto const& entry : m_mapEntry)
 175                         {
 176                             uno::Any aNewValue;
 177                             uno::Any aOldValue;
 178                             aOldValue <<= entry.second;
 179                             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 180                         }
 181                         m_mapEntry.clear();
 182                     }
 183                 }
 184                 break;
 185
 186                 // #i92103#
 187             case VclEventId::ItemExpanded :
 188             case VclEventId::ItemCollapsed :
 189                 {
 190                     SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
 191                     if ( pEntry )
 192                     {
 193                         AccessibleListBoxEntry* pAccListBoxEntry =
 194                             new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 195                         Reference< XAccessible > xChild = pAccListBoxEntry;
 196                         const short nAccEvent =
 197                                 ( rVclWindowEvent.GetId() == VclEventId::ItemExpanded )
 198                                 ? AccessibleEventId::LISTBOX_ENTRY_EXPANDED
 199                                 : AccessibleEventId::LISTBOX_ENTRY_COLLAPSED;
 200                         uno::Any aListBoxEntry;
 201                         aListBoxEntry <<= xChild;
 202                         NotifyAccessibleEvent( nAccEvent, Any(), aListBoxEntry );
 203                         if ( getListBox() && getListBox()->HasFocus() )
 204                         {
 205                             NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), aListBoxEntry );
 206                         }
 207                     }
 208                 }
 209                 break;
 210             default:
 211                 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
 212             }
 213         }
 214     }
 215
 216     AccessibleListBoxEntry* AccessibleListBox::GetCurEventEntry( const VclWindowEvent& rVclWindowEvent )
 217     {
 218         SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
 219         if ( !pEntry )
 220             pEntry = getListBox()->GetCurEntry();
 221
 222         AccessibleListBoxEntry* pEntryFocus =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
 223         if (pEntryFocus && pEntry && pEntry != pEntryFocus->GetSvLBoxEntry())
 224         {
 225             AccessibleListBoxEntry *pAccCurOptionEntry =nullptr;
 226             MAP_ENTRY::iterator mi = m_mapEntry.find(pEntry);
 227             if (mi != m_mapEntry.end())
 228             {
 229                 pAccCurOptionEntry= static_cast< AccessibleListBoxEntry* >(mi->second.get());
 230             }
 231             else
 232             {
 233                 pAccCurOptionEntry =new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
 234                 std::pair<MAP_ENTRY::iterator, bool> pairMi = m_mapEntry.emplace(pAccCurOptionEntry->GetSvLBoxEntry(), pAccCurOptionEntry);
 235                 mi = pairMi.first;
 236             }
 237
 238             uno::Any aNewValue;
 239             aNewValue <<= mi->second;//xAcc
 240             NotifyAccessibleEvent( AccessibleEventId::CHILD, uno::Any(), aNewValue );//Add
 241
 242             return pAccCurOptionEntry;
 243         }
 244         else
 245         {
 246             return pEntryFocus;
 247         }
 248     }
 249
 250     void AccessibleListBox::RemoveChildEntries(SvTreeListEntry* pEntry)
 251     {
 252         MAP_ENTRY::iterator mi = m_mapEntry.find(pEntry);
 253         if ( mi != m_mapEntry.end() )
 254         {
 255             uno::Any aNewValue;
 256             uno::Any aOldValue;
 257             aOldValue <<= mi->second;
 258             NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
 259
 260             m_mapEntry.erase(mi);
 261         }
 262
 263         VclPtr<SvTreeListBox> pBox = getListBox();
 264         SvTreeListEntry* pEntryChild = pBox->FirstChild(pEntry);
 265         while (pEntryChild)
 266         {
 267             RemoveChildEntries(pEntryChild);
 268             pEntryChild = pEntryChild->NextSibling();
 269         }
 270     }
 271
 272
 273     void AccessibleListBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
 274     {
 275         switch ( rVclWindowEvent.GetId() )
 276         {
 277             case VclEventId::WindowShow:
 278             case VclEventId::WindowHide:
 279             {
 280             }
 281             break;
 282             default:
 283             {
 284                 VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );
 285             }
 286             break;
 287         }
 288     }
 289
 290
 291     // XComponent
 292
 293     void SAL_CALL AccessibleListBox::disposing()
 294     {
 295         ::osl::MutexGuard aGuard( m_aMutex );
 296
 297         m_mapEntry.clear();
 298         VCLXAccessibleComponent::disposing();
 299         m_xParent = nullptr;
 300     }
 301
 302     // XServiceInfo
 303
 304     OUString SAL_CALL AccessibleListBox::getImplementationName()
 305     {
 306         return OUString( "com.sun.star.comp.svtools.AccessibleTreeListBox" );
 307     }
 308
 309     Sequence< OUString > SAL_CALL AccessibleListBox::getSupportedServiceNames()
 310     {
 311         return {"com.sun.star.accessibility.AccessibleContext",
 312                 "com.sun.star.accessibility.AccessibleComponent",
 313                 "com.sun.star.awt.AccessibleTreeListBox"};
 314     }
 315
 316     sal_Bool SAL_CALL AccessibleListBox::supportsService( const OUString& _rServiceName )
 317     {
 318         return cppu::supportsService(this, _rServiceName);
 319     }
 320
 321     // XAccessible
 322
 323     Reference< XAccessibleContext > SAL_CALL AccessibleListBox::getAccessibleContext(  )
 324     {
 325         ensureAlive();
 326         return this;
 327     }
 328
 329     // XAccessibleContext
 330
 331     sal_Int32 SAL_CALL AccessibleListBox::getAccessibleChildCount(  )
 332     {
 333         ::comphelper::OExternalLockGuard aGuard( this );
 334
 335         sal_Int32 nCount = 0;
 336         VclPtr<SvTreeListBox> pSvTreeListBox = getListBox();
 337         if ( pSvTreeListBox )
 338             nCount = pSvTreeListBox->GetLevelChildCount( nullptr );
 339
 340         return nCount;
 341     }
 342
 343     Reference< XAccessible > SAL_CALL AccessibleListBox::getAccessibleChild( sal_Int32 i )
 344     {
 345         ::comphelper::OExternalLockGuard aGuard( this );
 346
 347         SvTreeListEntry* pEntry = getListBox()->GetEntry(i);
 348         if ( !pEntry )
 349             throw IndexOutOfBoundsException();
 350
 351         // Solution: Set the parameter of the parent to null to let entry determine the parent by itself
 352         //return new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 353         return new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
 354     }
 355
 356     Reference< XAccessible > SAL_CALL AccessibleListBox::getAccessibleParent(  )
 357     {
 358         ::osl::MutexGuard aGuard( m_aMutex );
 359
 360         ensureAlive();
 361         return m_xParent;
 362     }
 363
 364     sal_Int32 AccessibleListBox::GetRoleType()
 365     {
 366         sal_Int32 nCase = 0;
 367         SvTreeListEntry* pEntry = getListBox()->GetEntry(0);
 368         if ( pEntry )
 369         {
 370             if( pEntry->HasChildrenOnDemand() || getListBox()->GetChildCount(pEntry) > 0  )
 371             {
 372                 nCase = 1;
 373                 return nCase;
 374             }
 375         }
 376
 377         bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
 378         if( !(getListBox()->GetTreeFlags() & SvTreeFlags::CHKBTN) )
 379         {
 380             if( bHasButtons )
 381                 nCase = 1;
 382         }
 383         else
 384         {
 385             if( bHasButtons )
 386                 nCase = 2;
 387             else
 388                 nCase = 3;
 389         }
 390         return nCase;
 391     }
 392
 393     sal_Int16 SAL_CALL AccessibleListBox::getAccessibleRole()
 394     {
 395         ::comphelper::OExternalLockGuard aGuard( this );
 396
 397         if(getListBox())
 398         {
 399             SvTreeAccRoleType nType = getListBox()->GetAllEntriesAccessibleRoleType();
 400             if( nType == SvTreeAccRoleType::TREE)
 401                 return AccessibleRole::TREE;
 402         }
 403
 404         //o is: return AccessibleRole::TREE;
 405         bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
 406         if(!bHasButtons && (getListBox()->GetTreeFlags() & SvTreeFlags::CHKBTN))
 407             return AccessibleRole::LIST;
 408         else
 409             if (GetRoleType() == 0)
 410                 return AccessibleRole::LIST;
 411             else
 412             return AccessibleRole::TREE;
 413     }
 414
 415     OUString SAL_CALL AccessibleListBox::getAccessibleDescription(  )
 416     {
 417         ::comphelper::OExternalLockGuard aGuard( this );
 418
 419         return getListBox()->GetAccessibleDescription();
 420     }
 421
 422     OUString SAL_CALL AccessibleListBox::getAccessibleName(  )
 423     {
 424         ::comphelper::OExternalLockGuard aGuard( this );
 425
 426         return getListBox()->GetAccessibleName();
 427     }
 428
 429     // XAccessibleSelection
 430
 431     void SAL_CALL AccessibleListBox::selectAccessibleChild( sal_Int32 nChildIndex )
 432     {
 433         ::comphelper::OExternalLockGuard aGuard( this );
 434
 435         SvTreeListEntry* pEntry = getListBox()->GetEntry( nChildIndex );
 436         if ( !pEntry )
 437             throw IndexOutOfBoundsException();
 438
 439         getListBox()->Select( pEntry );
 440     }
 441
 442     sal_Bool SAL_CALL AccessibleListBox::isAccessibleChildSelected( sal_Int32 nChildIndex )
 443     {
 444         ::comphelper::OExternalLockGuard aGuard( this );
 445
 446         SvTreeListEntry* pEntry = getListBox()->GetEntry( nChildIndex );
 447         if ( !pEntry )
 448             throw IndexOutOfBoundsException();
 449
 450         return getListBox()->IsSelected( pEntry );
 451     }
 452
 453     void SAL_CALL AccessibleListBox::clearAccessibleSelection(  )
 454     {
 455         ::comphelper::OExternalLockGuard aGuard( this );
 456
 457         sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
 458         for ( sal_Int32 i = 0; i < nCount; ++i )
 459         {
 460             SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
 461             if ( getListBox()->IsSelected( pEntry ) )
 462                 getListBox()->Select( pEntry, false );
 463         }
 464     }
 465
 466     void SAL_CALL AccessibleListBox::selectAllAccessibleChildren(  )
 467     {
 468         ::comphelper::OExternalLockGuard aGuard( this );
 469
 470         sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
 471         for ( sal_Int32 i = 0; i < nCount; ++i )
 472         {
 473             SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
 474             if ( !getListBox()->IsSelected( pEntry ) )
 475                 getListBox()->Select( pEntry );
 476         }
 477     }
 478
 479     sal_Int32 SAL_CALL AccessibleListBox::getSelectedAccessibleChildCount(  )
 480     {
 481         ::comphelper::OExternalLockGuard aGuard( this );
 482
 483         return getListBox()->GetSelectionCount();
 484     }
 485
 486     Reference< XAccessible > SAL_CALL AccessibleListBox::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
 487     {
 488         ::comphelper::OExternalLockGuard aGuard( this );
 489
 490         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 491             throw IndexOutOfBoundsException();
 492
 493         Reference< XAccessible > xChild;
 494         sal_Int32 nSelCount= 0;
 495         sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
 496         for ( sal_Int32 i = 0; i < nCount; ++i )
 497         {
 498             SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
 499             if ( getListBox()->IsSelected( pEntry ) )
 500                 ++nSelCount;
 501
 502             if ( nSelCount == ( nSelectedChildIndex + 1 ) )
 503             {
 504                 // Solution: Set the parameter of the parent to null to let entry determine the parent by itself
 505                 //xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 506                 xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
 507                 break;
 508             }
 509         }
 510
 511         return xChild;
 512     }
 513
 514     void SAL_CALL AccessibleListBox::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
 515     {
 516         ::comphelper::OExternalLockGuard aGuard( this );
 517
 518         SvTreeListEntry* pEntry = getListBox()->GetEntry( nSelectedChildIndex );
 519         if ( !pEntry )
 520             throw IndexOutOfBoundsException();
 521
 522         getListBox()->Select( pEntry, false );
 523     }
 524
 525     void AccessibleListBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
 526     {
 527         VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
 528         if ( getListBox() && isAlive() )
 529         {
 530             rStateSet.AddState( AccessibleStateType::FOCUSABLE );
 531             rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
 532             if ( getListBox()->GetSelectionMode() == SelectionMode::Multiple )
 533                 rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE );
 534         }
 535     }
 536
 537     VclPtr< SvTreeListBox > AccessibleListBox::getListBox() const
 538     {
 539         return GetAs< SvTreeListBox >();
 540     }
 541
 542 }// namespace accessibility
 543
 544
 545 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */