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