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