accessibility/source/extended/accessiblelistboxentry.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/accessiblelistboxentry.hxx>
  21 #include <extended/accessiblelistbox.hxx>
  22 #include <vcl/toolkit/treelistbox.hxx>
  23 #include <vcl/toolkit/svlbitm.hxx>
  24 #include <com/sun/star/awt/Rectangle.hpp>
  25 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  26 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  27 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  28 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  29 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  30 #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
  31 #include <i18nlangtag/languagetag.hxx>
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/settings.hxx>
  34 #include <vcl/unohelp.hxx>
  35 #include <vcl/unohelp2.hxx>
  36 #include <unotools/accessiblerelationsethelper.hxx>
  37 #include <cppuhelper/supportsservice.hxx>
  38 #include <comphelper/accessibleeventnotifier.hxx>
  39 #include <helper/accresmgr.hxx>
  40 #include <strings.hrc>
  41
  42 namespace accessibility
  43 {
  44     // class AccessibleListBoxEntry -----------------------------------------------------
  45
  46     using namespace ::com::sun::star::accessibility;
  47     using namespace ::com::sun::star::uno;
  48     using namespace ::com::sun::star::lang;
  49     using namespace ::com::sun::star;
  50     using namespace ::comphelper;
  51
  52
  53     // Ctor() and Dtor()
  54
  55     AccessibleListBoxEntry::AccessibleListBoxEntry( SvTreeListBox& _rListBox,
  56                                                     SvTreeListEntry& rEntry,
  57                                                     AccessibleListBox & rListBox)
  58         : AccessibleListBoxEntry_BASE( m_aMutex )
  59
  60         , m_pTreeListBox( &_rListBox )
  61         , m_pSvLBoxEntry(&rEntry)
  62         , m_nClientId( 0 )
  63         , m_wListBox(&rListBox)
  64     {
  65         m_pTreeListBox->AddEventListener( LINK( this, AccessibleListBoxEntry, WindowEventListener ) );
  66         _rListBox.FillEntryPath( m_pSvLBoxEntry, m_aEntryPath );
  67     }
  68
  69     AccessibleListBoxEntry::~AccessibleListBoxEntry()
  70     {
  71         if ( IsAlive_Impl() )
  72         {
  73             // increment ref count to prevent double call of Dtor
  74             osl_atomic_increment( &m_refCount );
  75             dispose();
  76         }
  77     }
  78
  79     IMPL_LINK( AccessibleListBoxEntry, WindowEventListener, VclWindowEvent&, rEvent, void )
  80     {
  81         OSL_ENSURE( rEvent.GetWindow() , "AccessibleListBoxEntry::WindowEventListener: no event window!" );
  82         OSL_ENSURE( rEvent.GetWindow() == m_pTreeListBox, "AccessibleListBoxEntry::WindowEventListener: where did this come from?" );
  83
  84         if ( m_pTreeListBox == nullptr )
  85             return;
  86
  87         switch ( rEvent.GetId() )
  88         {
  89             case VclEventId::CheckboxToggle:
  90             {
  91                 // assert this object is represented as a checkbox on a11y layer (LABEL role is used for
  92                 // SvButtonState::Tristate, s. AccessibleListBoxEntry::getAccessibleRole)
  93                 assert(getAccessibleRole() == AccessibleRole::CHECK_BOX
  94                        || getAccessibleRole() == AccessibleRole::LABEL);
  95                 Any aOldValue;
  96                 Any aNewValue;
  97                 if (getAccessibleStateSet() & AccessibleStateType::CHECKED)
  98                     aNewValue <<= AccessibleStateType::CHECKED;
  99                 else
 100                     aOldValue <<= AccessibleStateType::CHECKED;
 101
 102                 NotifyAccessibleEvent(AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue);
 103                 break;
 104             }
 105             case  VclEventId::ObjectDying :
 106             {
 107                 if ( m_pTreeListBox )
 108                     m_pTreeListBox->RemoveEventListener( LINK( this, AccessibleListBoxEntry, WindowEventListener ) );
 109                 m_pTreeListBox = nullptr;
 110                 dispose();
 111                 break;
 112             }
 113             default: break;
 114         }
 115     }
 116
 117     void AccessibleListBoxEntry::NotifyAccessibleEvent( sal_Int16 _nEventId,
 118                                                    const css::uno::Any& _aOldValue,
 119                                                    const css::uno::Any& _aNewValue )
 120     {
 121         Reference< uno::XInterface > xSource( *this );
 122         AccessibleEventObject aEventObj( xSource, _nEventId, _aNewValue, _aOldValue, -1 );
 123
 124         if (m_nClientId)
 125             comphelper::AccessibleEventNotifier::addEvent( m_nClientId, aEventObj );
 126     }
 127
 128
 129     tools::Rectangle AccessibleListBoxEntry::GetBoundingBox_Impl() const
 130     {
 131         tools::Rectangle aRect;
 132         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 133         if ( pEntry )
 134         {
 135             aRect = m_pTreeListBox->GetBoundingRect( pEntry );
 136             SvTreeListEntry* pParent = m_pTreeListBox->GetParent( pEntry );
 137             if ( pParent )
 138             {
 139                 // position relative to parent entry
 140                 Point aTopLeft = aRect.TopLeft();
 141                 aTopLeft -= m_pTreeListBox->GetBoundingRect( pParent ).TopLeft();
 142                 aRect = tools::Rectangle( aTopLeft, aRect.GetSize() );
 143             }
 144         }
 145
 146         return aRect;
 147     }
 148
 149     tools::Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen_Impl() const
 150     {
 151         tools::Rectangle aRect;
 152         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 153         if ( pEntry )
 154         {
 155             aRect = m_pTreeListBox->GetBoundingRect( pEntry );
 156             Point aTopLeft = aRect.TopLeft();
 157             aTopLeft += Point(m_pTreeListBox->GetWindowExtentsAbsolute().TopLeft());
 158             aRect = tools::Rectangle( aTopLeft, aRect.GetSize() );
 159         }
 160
 161         return aRect;
 162     }
 163
 164     bool AccessibleListBoxEntry::IsAlive_Impl() const
 165     {
 166         return !rBHelper.bDisposed && !rBHelper.bInDispose && (m_pTreeListBox != nullptr);
 167     }
 168
 169     bool AccessibleListBoxEntry::IsShowing_Impl() const
 170     {
 171         Reference< XAccessible > xParent = implGetParentAccessible( );
 172
 173         bool bShowing = false;
 174         Reference< XAccessibleContext > xParentContext =
 175             xParent.is() ? xParent->getAccessibleContext() : Reference< XAccessibleContext >();
 176         if( xParentContext.is() )
 177         {
 178             Reference< XAccessibleComponent > xParentComp( xParentContext, uno::UNO_QUERY );
 179             if( xParentComp.is() )
 180                 bShowing = GetBoundingBox_Impl().Overlaps(
 181                     vcl::unohelper::ConvertToVCLRect(xParentComp->getBounds()));
 182         }
 183
 184         return bShowing;
 185     }
 186
 187     tools::Rectangle AccessibleListBoxEntry::GetBoundingBox()
 188     {
 189         SolarMutexGuard aSolarGuard;
 190         ::osl::MutexGuard aGuard( m_aMutex );
 191
 192         EnsureIsAlive();
 193         return GetBoundingBox_Impl();
 194     }
 195
 196     tools::Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen()
 197     {
 198         SolarMutexGuard aSolarGuard;
 199         ::osl::MutexGuard aGuard( m_aMutex );
 200
 201         EnsureIsAlive();
 202         return GetBoundingBoxOnScreen_Impl();
 203     }
 204
 205     void AccessibleListBoxEntry::CheckActionIndex(sal_Int32 nIndex)
 206     {
 207         if (nIndex < 0 || nIndex >= getAccessibleActionCount())
 208             throw css::lang::IndexOutOfBoundsException();
 209     }
 210
 211     void AccessibleListBoxEntry::EnsureIsAlive() const
 212     {
 213         if ( !IsAlive_Impl() )
 214             throw lang::DisposedException();
 215     }
 216
 217     OUString AccessibleListBoxEntry::implGetText()
 218     {
 219         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 220         if (pEntry)
 221             return SvTreeListBox::SearchEntryTextWithHeadTitle(pEntry);
 222         return OUString();
 223     }
 224
 225     Locale AccessibleListBoxEntry::implGetLocale()
 226     {
 227         return Application::GetSettings().GetUILanguageTag().getLocale();
 228     }
 229     void AccessibleListBoxEntry::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 230     {
 231         nStartIndex = 0;
 232         nEndIndex = 0;
 233     }
 234
 235     // XTypeProvider
 236     Sequence< sal_Int8 > AccessibleListBoxEntry::getImplementationId()
 237     {
 238         return css::uno::Sequence<sal_Int8>();
 239     }
 240
 241
 242     // XComponent
 243
 244     void SAL_CALL AccessibleListBoxEntry::disposing()
 245     {
 246         SolarMutexGuard aSolarGuard;
 247         ::osl::MutexGuard aGuard( m_aMutex );
 248
 249         Reference< XAccessible > xKeepAlive( this );
 250
 251         // Send a disposing to all listeners.
 252         if ( m_nClientId )
 253         {
 254             ::comphelper::AccessibleEventNotifier::TClientId nId = m_nClientId;
 255             m_nClientId =  0;
 256             ::comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this );
 257         }
 258
 259         // clean up
 260         m_wListBox.clear();
 261
 262         if ( m_pTreeListBox )
 263             m_pTreeListBox->RemoveEventListener( LINK( this, AccessibleListBoxEntry, WindowEventListener ) );
 264         m_pTreeListBox = nullptr;
 265     }
 266
 267     // XServiceInfo
 268
 269     OUString SAL_CALL AccessibleListBoxEntry::getImplementationName()
 270     {
 271         return u"com.sun.star.comp.svtools.AccessibleTreeListBoxEntry"_ustr;
 272     }
 273
 274     Sequence< OUString > SAL_CALL AccessibleListBoxEntry::getSupportedServiceNames()
 275     {
 276         return {u"com.sun.star.accessibility.AccessibleContext"_ustr,
 277                 u"com.sun.star.accessibility.AccessibleComponent"_ustr,
 278                 u"com.sun.star.awt.AccessibleTreeListBoxEntry"_ustr};
 279     }
 280
 281     sal_Bool SAL_CALL AccessibleListBoxEntry::supportsService( const OUString& _rServiceName )
 282     {
 283         return cppu::supportsService(this, _rServiceName);
 284     }
 285
 286     // XAccessible
 287
 288     Reference< XAccessibleContext > SAL_CALL AccessibleListBoxEntry::getAccessibleContext(  )
 289     {
 290         EnsureIsAlive();
 291         return this;
 292     }
 293
 294     // XAccessibleContext
 295
 296     sal_Int64 SAL_CALL AccessibleListBoxEntry::getAccessibleChildCount(  )
 297     {
 298         SolarMutexGuard aSolarGuard;
 299         ::osl::MutexGuard aGuard( m_aMutex );
 300
 301         EnsureIsAlive();
 302         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 303         sal_Int32 nCount = 0;
 304         if ( pEntry )
 305             nCount = m_pTreeListBox->GetLevelChildCount( pEntry );
 306
 307         return nCount;
 308     }
 309
 310     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleChild( sal_Int64 i )
 311     {
 312         SolarMutexGuard aSolarGuard;
 313         ::osl::MutexGuard aGuard( m_aMutex );
 314         EnsureIsAlive();
 315
 316         SvTreeListEntry* pEntry = GetRealChild(i);
 317         if ( !pEntry )
 318             throw IndexOutOfBoundsException();
 319
 320         rtl::Reference<AccessibleListBox> xListBox(m_wListBox);
 321         assert(xListBox.is());
 322
 323         return xListBox->implGetAccessible(*pEntry);
 324     }
 325
 326     Reference< XAccessible > AccessibleListBoxEntry::implGetParentAccessible( ) const
 327     {
 328         Reference< XAccessible > xParent;
 329         assert( m_aEntryPath.size() ); // invalid path
 330         if ( m_aEntryPath.size() == 1 )
 331         {   // we're a top level entry
 332             // -> our parent is the tree listbox itself
 333             if ( m_pTreeListBox )
 334                 xParent = m_pTreeListBox->GetAccessible( );
 335         }
 336         else
 337         {   // we have an entry as parent -> get its accessible
 338
 339             // shorten our access path by one
 340             std::deque< sal_Int32 > aParentPath( m_aEntryPath );
 341             aParentPath.pop_back();
 342
 343             // get the entry for this shortened access path
 344             SvTreeListEntry* pParentEntry = m_pTreeListBox->GetEntryFromPath( aParentPath );
 345             assert(pParentEntry && "AccessibleListBoxEntry::implGetParentAccessible: could not obtain a parent entry!");
 346             if ( pParentEntry )
 347             {
 348                 rtl::Reference<AccessibleListBox> xListBox(m_wListBox);
 349                 assert(xListBox.is());
 350                 return xListBox->implGetAccessible(*pParentEntry);
 351                 // the AccessibleListBoxEntry class will create its parent
 352                 // when needed
 353             }
 354         }
 355
 356         return xParent;
 357     }
 358
 359
 360     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleParent(  )
 361     {
 362         SolarMutexGuard aSolarGuard;
 363         ::osl::MutexGuard aGuard( m_aMutex );
 364         EnsureIsAlive();
 365
 366         return implGetParentAccessible( );
 367     }
 368
 369     sal_Int64 SAL_CALL AccessibleListBoxEntry::getAccessibleIndexInParent(  )
 370     {
 371         ::osl::MutexGuard aGuard( m_aMutex );
 372
 373         OSL_ENSURE( !m_aEntryPath.empty(), "empty path" );
 374         return m_aEntryPath.empty() ? -1 : m_aEntryPath.back();
 375     }
 376
 377     sal_Int32 AccessibleListBoxEntry::GetRoleType() const
 378     {
 379         sal_Int32 nCase = 0;
 380         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry(0);
 381         if ( pEntry )
 382         {
 383             if( pEntry->HasChildrenOnDemand() || m_pTreeListBox->GetChildCount(pEntry) > 0  )
 384             {
 385                 nCase = 1;
 386                 return nCase;
 387             }
 388         }
 389
 390         bool bHasButtons = (m_pTreeListBox->GetStyle() & WB_HASBUTTONS)!=0;
 391         if( !(m_pTreeListBox->GetTreeFlags() & SvTreeFlags::CHKBTN) )
 392         {
 393             if( bHasButtons )
 394                 nCase = 1;
 395         }
 396         else
 397         {
 398             if( bHasButtons )
 399                 nCase = 2;
 400             else
 401                 nCase = 3;
 402         }
 403         return nCase;
 404     }
 405
 406     sal_Int16 SAL_CALL AccessibleListBoxEntry::getAccessibleRole(  )
 407     {
 408         SolarMutexGuard aSolarGuard;
 409         ::osl::MutexGuard aGuard( m_aMutex );
 410
 411         SvTreeListBox* pBox = m_pTreeListBox;
 412         if(!pBox)
 413             return AccessibleRole::UNKNOWN;
 414
 415         SvTreeFlags treeFlag = pBox->GetTreeFlags();
 416         if(treeFlag & SvTreeFlags::CHKBTN )
 417         {
 418             SvTreeListEntry* pEntry = pBox->GetEntryFromPath( m_aEntryPath );
 419             SvButtonState eState = pBox->GetCheckButtonState( pEntry );
 420             switch( eState )
 421             {
 422             case SvButtonState::Checked:
 423             case SvButtonState::Unchecked:
 424                 return AccessibleRole::CHECK_BOX;
 425             case SvButtonState::Tristate:
 426             default:
 427                 return AccessibleRole::LABEL;
 428             }
 429         }
 430         if (GetRoleType() == 0)
 431             return AccessibleRole::LIST_ITEM;
 432         else
 433             //o is: return AccessibleRole::LABEL;
 434             return AccessibleRole::TREE_ITEM;
 435     }
 436
 437     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleDescription(  )
 438     {
 439         SolarMutexGuard aSolarGuard;
 440         ::osl::MutexGuard aGuard( m_aMutex );
 441
 442         if( getAccessibleRole() == AccessibleRole::TREE_ITEM )
 443         {
 444             return OUString();
 445         }
 446         return m_pTreeListBox->GetEntryAccessibleDescription(
 447             m_pTreeListBox->GetEntryFromPath(m_aEntryPath));
 448     }
 449
 450     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleName(  )
 451     {
 452         ::osl::MutexGuard aGuard( m_aMutex );
 453
 454         EnsureIsAlive();
 455
 456         return implGetText();
 457     }
 458
 459     Reference< XAccessibleRelationSet > SAL_CALL AccessibleListBoxEntry::getAccessibleRelationSet(  )
 460     {
 461         Reference< XAccessibleRelationSet > xRelSet;
 462         Reference< XAccessible > xParent;
 463         if ( m_aEntryPath.size() > 1 ) // not a root entry
 464             xParent = implGetParentAccessible();
 465         if ( xParent.is() )
 466         {
 467             rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 468             Sequence<Reference<XAccessible>> aSequence { xParent };
 469             pRelationSetHelper->AddRelation(
 470                 AccessibleRelation( AccessibleRelationType_NODE_CHILD_OF, aSequence ) );
 471             xRelSet = pRelationSetHelper;
 472         }
 473         return xRelSet;
 474     }
 475
 476     sal_Int64 SAL_CALL AccessibleListBoxEntry::getAccessibleStateSet(  )
 477     {
 478         ::osl::MutexGuard aGuard( m_aMutex );
 479
 480         sal_Int64 nStateSet = 0;
 481
 482         if ( IsAlive_Impl() )
 483         {
 484             switch(getAccessibleRole())
 485             {
 486                 case AccessibleRole::LABEL:
 487                     nStateSet |= AccessibleStateType::TRANSIENT;
 488                     nStateSet |= AccessibleStateType::SELECTABLE;
 489                     nStateSet |= AccessibleStateType::ENABLED;
 490                     if (m_pTreeListBox->IsInplaceEditingEnabled())
 491                         nStateSet |= AccessibleStateType::EDITABLE;
 492                     if (IsShowing_Impl())
 493                         nStateSet |= AccessibleStateType::SHOWING;
 494                     break;
 495                 case AccessibleRole::CHECK_BOX:
 496                     nStateSet |= AccessibleStateType::TRANSIENT;
 497                     nStateSet |= AccessibleStateType::SELECTABLE;
 498                     nStateSet |= AccessibleStateType::ENABLED;
 499                     if (IsShowing_Impl())
 500                         nStateSet |= AccessibleStateType::SHOWING;
 501                     break;
 502             }
 503             SvTreeListEntry *pEntry = m_pTreeListBox->GetEntryFromPath(m_aEntryPath);
 504             if (pEntry)
 505                 m_pTreeListBox->FillAccessibleEntryStateSet(pEntry, nStateSet);
 506         }
 507         else
 508             nStateSet |= AccessibleStateType::DEFUNC;
 509
 510         return nStateSet;
 511     }
 512
 513     Locale SAL_CALL AccessibleListBoxEntry::getLocale(  )
 514     {
 515         SolarMutexGuard aSolarGuard;
 516         ::osl::MutexGuard aGuard( m_aMutex );
 517
 518         return implGetLocale();
 519     }
 520
 521     // XAccessibleComponent
 522
 523     sal_Bool SAL_CALL AccessibleListBoxEntry::containsPoint( const awt::Point& rPoint )
 524     {
 525         return tools::Rectangle(Point(), GetBoundingBox().GetSize())
 526             .Contains(vcl::unohelper::ConvertToVCLPoint(rPoint));
 527     }
 528
 529     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleAtPoint( const awt::Point& _aPoint )
 530     {
 531         SolarMutexGuard aSolarGuard;
 532         ::osl::MutexGuard aGuard( m_aMutex );
 533
 534         EnsureIsAlive();
 535         SvTreeListEntry* pEntry
 536             = m_pTreeListBox->GetEntry(vcl::unohelper::ConvertToVCLPoint(_aPoint));
 537         if ( !pEntry )
 538             throw RuntimeException(u"AccessibleListBoxEntry::getAccessibleAtPoint - pEntry cannot be empty!"_ustr);
 539
 540         Reference< XAccessible > xAcc;
 541         rtl::Reference<AccessibleListBox> xListBox(m_wListBox);
 542         assert(xListBox.is());
 543         auto pAccEntry = xListBox->implGetAccessible(*pEntry);
 544         tools::Rectangle aRect = pAccEntry->GetBoundingBox_Impl();
 545         if (aRect.Contains(vcl::unohelper::ConvertToVCLPoint(_aPoint)))
 546             xAcc = pAccEntry.get();
 547         return xAcc;
 548     }
 549
 550     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getBounds(  )
 551     {
 552         return vcl::unohelper::ConvertToAWTRect(GetBoundingBox());
 553     }
 554
 555     awt::Point SAL_CALL AccessibleListBoxEntry::getLocation(  )
 556     {
 557         return vcl::unohelper::ConvertToAWTPoint(GetBoundingBox().TopLeft());
 558     }
 559
 560     awt::Point SAL_CALL AccessibleListBoxEntry::getLocationOnScreen(  )
 561     {
 562         return vcl::unohelper::ConvertToAWTPoint(GetBoundingBoxOnScreen().TopLeft());
 563     }
 564
 565     awt::Size SAL_CALL AccessibleListBoxEntry::getSize(  )
 566     {
 567         return vcl::unohelper::ConvertToAWTSize(GetBoundingBox().GetSize());
 568     }
 569
 570     void SAL_CALL AccessibleListBoxEntry::grabFocus(  )
 571     {
 572         // do nothing, because no focus for each item
 573     }
 574
 575     sal_Int32 AccessibleListBoxEntry::getForeground(    )
 576     {
 577         SolarMutexGuard aSolarGuard;
 578         ::osl::MutexGuard aGuard( m_aMutex );
 579
 580         sal_Int32 nColor = 0;
 581         Reference< XAccessible > xParent = getAccessibleParent();
 582         if ( xParent.is() )
 583         {
 584             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 585             if ( xParentComp.is() )
 586                 nColor = xParentComp->getForeground();
 587         }
 588
 589         return nColor;
 590     }
 591
 592     sal_Int32 AccessibleListBoxEntry::getBackground(  )
 593     {
 594         SolarMutexGuard aSolarGuard;
 595         ::osl::MutexGuard aGuard( m_aMutex );
 596
 597         sal_Int32 nColor = 0;
 598         Reference< XAccessible > xParent = getAccessibleParent();
 599         if ( xParent.is() )
 600         {
 601             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 602             if ( xParentComp.is() )
 603                 nColor = xParentComp->getBackground();
 604         }
 605
 606         return nColor;
 607     }
 608
 609     // XAccessibleText
 610
 611
 612     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getCharacterBounds( sal_Int32 nIndex )
 613     {
 614         SolarMutexGuard aSolarGuard;
 615         ::osl::MutexGuard aGuard( m_aMutex );
 616
 617         EnsureIsAlive();
 618
 619         if ( !implIsValidIndex( nIndex, implGetText().getLength() ) )
 620             throw IndexOutOfBoundsException();
 621
 622         awt::Rectangle aBounds( 0, 0, 0, 0 );
 623         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 624         if ( pEntry )
 625         {
 626             vcl::ControlLayoutData aLayoutData;
 627             tools::Rectangle aItemRect = GetBoundingBox();
 628             m_pTreeListBox->RecordLayoutData( &aLayoutData, aItemRect );
 629             tools::Rectangle aCharRect = aLayoutData.GetCharacterBounds( nIndex );
 630             aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
 631             aBounds = vcl::unohelper::ConvertToAWTRect(aCharRect);
 632         }
 633
 634         return aBounds;
 635     }
 636
 637     sal_Int32 SAL_CALL AccessibleListBoxEntry::getIndexAtPoint( const awt::Point& aPoint )
 638     {
 639         SolarMutexGuard aSolarGuard;
 640         ::osl::MutexGuard aGuard( m_aMutex );
 641         EnsureIsAlive();
 642         if(aPoint.X==0 && aPoint.Y==0) return 0;
 643
 644         sal_Int32 nIndex = -1;
 645         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 646         if ( pEntry )
 647         {
 648             vcl::ControlLayoutData aLayoutData;
 649             tools::Rectangle aItemRect = GetBoundingBox();
 650             m_pTreeListBox->RecordLayoutData( &aLayoutData, aItemRect );
 651             Point aPnt(vcl::unohelper::ConvertToVCLPoint(aPoint));
 652             aPnt += aItemRect.TopLeft();
 653             nIndex = aLayoutData.GetIndexForPoint( aPnt );
 654         }
 655
 656         return nIndex;
 657     }
 658
 659     sal_Bool SAL_CALL AccessibleListBoxEntry::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
 660     {
 661         SolarMutexGuard aSolarGuard;
 662         ::osl::MutexGuard aGuard( m_aMutex );
 663         EnsureIsAlive();
 664
 665         OUString sText = implGetText();
 666         if  ( ( 0 > nStartIndex ) || ( sText.getLength() <= nStartIndex )
 667             || ( 0 > nEndIndex ) || ( sText.getLength() <= nEndIndex ) )
 668             throw IndexOutOfBoundsException();
 669
 670         if (!m_pTreeListBox)
 671             return false;
 672
 673         sal_Int32 nLen = nEndIndex - nStartIndex + 1;
 674         css::uno::Reference<css::datatransfer::clipboard::XClipboard> xClipBoard = m_pTreeListBox->GetClipboard();
 675         vcl::unohelper::TextDataObject::CopyStringTo(sText.copy(nStartIndex, nLen), xClipBoard);
 676
 677         return true;
 678     }
 679
 680     sal_Bool SAL_CALL AccessibleListBoxEntry::scrollSubstringTo( sal_Int32, sal_Int32, AccessibleScrollType )
 681     {
 682         return false;
 683     }
 684
 685     // XAccessibleEventBroadcaster
 686
 687     void SAL_CALL AccessibleListBoxEntry::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 688     {
 689         if (xListener.is())
 690         {
 691             ::osl::MutexGuard aGuard( m_aMutex );
 692             if (!m_nClientId)
 693                 m_nClientId = comphelper::AccessibleEventNotifier::registerClient( );
 694             comphelper::AccessibleEventNotifier::addEventListener( m_nClientId, xListener );
 695         }
 696     }
 697
 698     void SAL_CALL AccessibleListBoxEntry::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener )
 699     {
 700         if (!xListener.is())
 701             return;
 702
 703         ::osl::MutexGuard aGuard( m_aMutex );
 704
 705         sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( m_nClientId, xListener );
 706         if ( !nListenerCount )
 707         {
 708             // no listeners anymore
 709             // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 710             // and at least to us not firing any events anymore, in case somebody calls
 711             // NotifyAccessibleEvent, again
 712             sal_Int32 nId = m_nClientId;
 713             m_nClientId = 0;
 714             comphelper::AccessibleEventNotifier::revokeClient( nId );
 715
 716         }
 717     }
 718
 719     // XAccessibleAction
 720
 721     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleActionCount(  )
 722     {
 723         ::osl::MutexGuard aGuard( m_aMutex );
 724
 725         // three actions supported
 726         SvTreeFlags treeFlag = m_pTreeListBox->GetTreeFlags();
 727         bool bHasButtons = (m_pTreeListBox->GetStyle() & WB_HASBUTTONS)!=0;
 728         if( (treeFlag & SvTreeFlags::CHKBTN) && !bHasButtons)
 729         {
 730             sal_Int16 role = getAccessibleRole();
 731             if ( role == AccessibleRole::CHECK_BOX )
 732                 return 2;
 733             else if ( role == AccessibleRole::LABEL )
 734                 return 0;
 735         }
 736         else
 737             return 1;
 738         return 0;
 739     }
 740
 741     sal_Bool SAL_CALL AccessibleListBoxEntry::doAccessibleAction( sal_Int32 nIndex )
 742     {
 743         SolarMutexGuard aSolarGuard;
 744         ::osl::MutexGuard aGuard( m_aMutex );
 745
 746         bool bRet = false;
 747         CheckActionIndex(nIndex);
 748         EnsureIsAlive();
 749
 750         SvTreeFlags treeFlag = m_pTreeListBox->GetTreeFlags();
 751         if( nIndex == 0 && (treeFlag & SvTreeFlags::CHKBTN) )
 752         {
 753             if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
 754             {
 755                 SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 756                 SvButtonState state = m_pTreeListBox->GetCheckButtonState( pEntry );
 757                 if ( state == SvButtonState::Checked )
 758                     m_pTreeListBox->SetCheckButtonState(pEntry, SvButtonState::Unchecked);
 759                 else if (state == SvButtonState::Unchecked)
 760                     m_pTreeListBox->SetCheckButtonState(pEntry, SvButtonState::Checked);
 761             }
 762         }
 763         else if( (nIndex == 1 && (treeFlag & SvTreeFlags::CHKBTN) ) || (nIndex == 0) )
 764         {
 765             SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 766             if ( pEntry )
 767             {
 768                 if ( m_pTreeListBox->IsExpanded( pEntry ) )
 769                     m_pTreeListBox->Collapse( pEntry );
 770                 else
 771                     m_pTreeListBox->Expand( pEntry );
 772                 bRet = true;
 773             }
 774         }
 775
 776         return bRet;
 777     }
 778
 779     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleActionDescription( sal_Int32 nIndex )
 780     {
 781         SolarMutexGuard aSolarGuard;
 782         ::osl::MutexGuard aGuard( m_aMutex );
 783
 784         CheckActionIndex(nIndex);
 785         EnsureIsAlive();
 786
 787         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 788         SvButtonState state = m_pTreeListBox->GetCheckButtonState( pEntry );
 789         SvTreeFlags treeFlag = m_pTreeListBox->GetTreeFlags();
 790         if(nIndex == 0 && (treeFlag & SvTreeFlags::CHKBTN))
 791         {
 792             if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
 793             {
 794                 if ( state == SvButtonState::Checked )
 795                     return u"UnCheck"_ustr;
 796                 else if (state == SvButtonState::Unchecked)
 797                     return u"Check"_ustr;
 798             }
 799             else
 800             {
 801                 //Sometimes, a List or Tree may have both checkbox and label at the same time
 802                 return OUString();
 803             }
 804         }
 805         else if( (nIndex == 1 && (treeFlag & SvTreeFlags::CHKBTN)) || nIndex == 0 )
 806         {
 807             if( pEntry && (pEntry->HasChildren() || pEntry->HasChildrenOnDemand()) )
 808                 return m_pTreeListBox->IsExpanded( pEntry ) ?
 809                 AccResId(STR_SVT_ACC_ACTION_COLLAPSE) :
 810                 AccResId(STR_SVT_ACC_ACTION_EXPAND);
 811             return OUString();
 812
 813         }
 814         throw IndexOutOfBoundsException();
 815     }
 816
 817     Reference< XAccessibleKeyBinding > AccessibleListBoxEntry::getAccessibleActionKeyBinding( sal_Int32 nIndex )
 818     {
 819         Reference< XAccessibleKeyBinding > xRet;
 820         CheckActionIndex(nIndex);
 821         // ... which key?
 822         return xRet;
 823     }
 824
 825     // XAccessibleSelection
 826
 827     void SAL_CALL AccessibleListBoxEntry::selectAccessibleChild( sal_Int64 nChildIndex )
 828     {
 829         SolarMutexGuard aSolarGuard;
 830         ::osl::MutexGuard aGuard( m_aMutex );
 831
 832         EnsureIsAlive();
 833
 834         if (nChildIndex < 0 || nChildIndex >= getAccessibleChildCount())
 835             throw IndexOutOfBoundsException();
 836
 837         SvTreeListEntry* pEntry = GetRealChild(nChildIndex);
 838         if ( !pEntry )
 839             throw IndexOutOfBoundsException();
 840
 841         m_pTreeListBox->Select( pEntry );
 842     }
 843
 844     sal_Bool SAL_CALL AccessibleListBoxEntry::isAccessibleChildSelected( sal_Int64 nChildIndex )
 845     {
 846         SolarMutexGuard aSolarGuard;
 847         ::osl::MutexGuard aGuard( m_aMutex );
 848
 849         EnsureIsAlive();
 850
 851         if (nChildIndex < 0 || nChildIndex >= getAccessibleChildCount())
 852             throw IndexOutOfBoundsException();
 853
 854         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 855         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, nChildIndex );
 856         if ( !pEntry )
 857             throw IndexOutOfBoundsException();
 858
 859         return m_pTreeListBox->IsSelected( pEntry );
 860     }
 861
 862     void SAL_CALL AccessibleListBoxEntry::clearAccessibleSelection(  )
 863     {
 864         SolarMutexGuard aSolarGuard;
 865         ::osl::MutexGuard aGuard( m_aMutex );
 866
 867         EnsureIsAlive();
 868
 869         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 870         if ( !pParent )
 871             throw RuntimeException(u"AccessibleListBoxEntry::clearAccessibleSelection - pParent cannot be empty!"_ustr);
 872         sal_Int32 nCount = m_pTreeListBox->GetLevelChildCount( pParent );
 873         for ( sal_Int32 i = 0; i < nCount; ++i )
 874         {
 875             SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, i );
 876             if ( m_pTreeListBox->IsSelected( pEntry ) )
 877                 m_pTreeListBox->Select( pEntry, false );
 878         }
 879     }
 880
 881     void SAL_CALL AccessibleListBoxEntry::selectAllAccessibleChildren(  )
 882     {
 883         SolarMutexGuard aSolarGuard;
 884         ::osl::MutexGuard aGuard( m_aMutex );
 885
 886         EnsureIsAlive();
 887
 888         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 889         if ( !pParent )
 890             throw RuntimeException(u"AccessibleListBoxEntry::selectAllAccessibleChildren - pParent cannot be empty!"_ustr);
 891         sal_Int32 nCount = m_pTreeListBox->GetLevelChildCount( pParent );
 892         for ( sal_Int32 i = 0; i < nCount; ++i )
 893         {
 894             SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, i );
 895             if ( !m_pTreeListBox->IsSelected( pEntry ) )
 896                 m_pTreeListBox->Select( pEntry );
 897         }
 898     }
 899
 900     sal_Int64 SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChildCount(  )
 901     {
 902         SolarMutexGuard aSolarGuard;
 903         ::osl::MutexGuard aGuard( m_aMutex );
 904
 905         EnsureIsAlive();
 906
 907         sal_Int64 nSelCount = 0;
 908
 909         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 910         if ( !pParent )
 911             throw RuntimeException(u"AccessibleListBoxEntry::getSelectedAccessibleChildCount - pParent cannot be empty!"_ustr);
 912         sal_Int32 nCount = m_pTreeListBox->GetLevelChildCount( pParent );
 913         for (sal_Int32 i = 0; i < nCount; ++i )
 914         {
 915             SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, i );
 916             if ( m_pTreeListBox->IsSelected( pEntry ) )
 917                 ++nSelCount;
 918         }
 919
 920         return nSelCount;
 921     }
 922
 923     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChild( sal_Int64 nSelectedChildIndex )
 924     {
 925         SolarMutexGuard aSolarGuard;
 926         ::osl::MutexGuard aGuard( m_aMutex );
 927
 928         EnsureIsAlive();
 929
 930         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 931             throw IndexOutOfBoundsException();
 932
 933         Reference< XAccessible > xChild;
 934         sal_Int64 nSelCount = 0;
 935
 936         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 937         if ( !pParent )
 938             throw RuntimeException(u"AccessibleListBoxEntry::getSelectedAccessibleChild - pParent cannot be empty!"_ustr);
 939         sal_Int32 nCount = m_pTreeListBox->GetLevelChildCount( pParent );
 940         for (sal_Int32 i = 0; i < nCount; ++i )
 941         {
 942             SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, i );
 943             if ( m_pTreeListBox->IsSelected( pEntry ) )
 944                 ++nSelCount;
 945
 946             if ( nSelCount == ( nSelectedChildIndex + 1 ) )
 947             {
 948                 rtl::Reference<AccessibleListBox> xListBox(m_wListBox);
 949                 assert(xListBox.is());
 950                 xChild = xListBox->implGetAccessible(*pEntry).get();
 951                 break;
 952             }
 953         }
 954
 955         return xChild;
 956     }
 957
 958     void SAL_CALL AccessibleListBoxEntry::deselectAccessibleChild( sal_Int64 nSelectedChildIndex )
 959     {
 960         SolarMutexGuard aSolarGuard;
 961         ::osl::MutexGuard aGuard( m_aMutex );
 962
 963         EnsureIsAlive();
 964
 965         if (nSelectedChildIndex < 0 || nSelectedChildIndex >= getAccessibleChildCount())
 966             throw IndexOutOfBoundsException();
 967
 968         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
 969         SvTreeListEntry* pEntry = m_pTreeListBox->GetEntry( pParent, nSelectedChildIndex );
 970         if ( !pEntry )
 971             throw IndexOutOfBoundsException();
 972
 973         m_pTreeListBox->Select( pEntry, false );
 974     }
 975     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCaretPosition(  )
 976     {
 977         return -1;
 978     }
 979     sal_Bool SAL_CALL AccessibleListBoxEntry::setCaretPosition ( sal_Int32 nIndex )
 980     {
 981         SolarMutexGuard aSolarGuard;
 982         ::osl::MutexGuard aGuard( m_aMutex );
 983         EnsureIsAlive();
 984
 985         if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
 986             throw IndexOutOfBoundsException();
 987
 988         return false;
 989     }
 990     sal_Unicode SAL_CALL AccessibleListBoxEntry::getCharacter( sal_Int32 nIndex )
 991     {
 992         SolarMutexGuard aSolarGuard;
 993         ::osl::MutexGuard aGuard( m_aMutex );
 994         EnsureIsAlive();
 995         return OCommonAccessibleText::implGetCharacter( implGetText(), nIndex );
 996     }
 997     css::uno::Sequence< css::beans::PropertyValue > SAL_CALL AccessibleListBoxEntry::getCharacterAttributes( sal_Int32 nIndex, const css::uno::Sequence< OUString >& )
 998     {
 999         SolarMutexGuard aSolarGuard;
1000         ::osl::MutexGuard aGuard( m_aMutex );
1001         EnsureIsAlive();
1002
1003         OUString sText( implGetText() );
1004
1005         if ( !implIsValidIndex( nIndex, sText.getLength() ) )
1006             throw IndexOutOfBoundsException();
1007
1008         return css::uno::Sequence< css::beans::PropertyValue >();
1009     }
1010     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCharacterCount(  )
1011     {
1012         SolarMutexGuard aSolarGuard;
1013         ::osl::MutexGuard aGuard( m_aMutex );
1014         EnsureIsAlive();
1015         return implGetText().getLength();
1016     }
1017
1018     OUString SAL_CALL AccessibleListBoxEntry::getSelectedText(  )
1019     {
1020         SolarMutexGuard aSolarGuard;
1021         ::osl::MutexGuard aGuard( m_aMutex );
1022         EnsureIsAlive();
1023         return OUString();
1024     }
1025     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionStart(  )
1026     {
1027         SolarMutexGuard aSolarGuard;
1028         ::osl::MutexGuard aGuard( m_aMutex );
1029         EnsureIsAlive();
1030         return 0;
1031     }
1032     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionEnd(  )
1033     {
1034         SolarMutexGuard aSolarGuard;
1035         ::osl::MutexGuard aGuard( m_aMutex );
1036         EnsureIsAlive();
1037         return 0;
1038     }
1039     sal_Bool SAL_CALL AccessibleListBoxEntry::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
1040     {
1041         SolarMutexGuard aSolarGuard;
1042         ::osl::MutexGuard aGuard( m_aMutex );
1043         EnsureIsAlive();
1044
1045         if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
1046             throw IndexOutOfBoundsException();
1047
1048         return false;
1049     }
1050     OUString SAL_CALL AccessibleListBoxEntry::getText(  )
1051     {
1052         SolarMutexGuard aSolarGuard;
1053         ::osl::MutexGuard aGuard( m_aMutex );
1054         EnsureIsAlive();
1055         return implGetText(  );
1056     }
1057     OUString SAL_CALL AccessibleListBoxEntry::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex )
1058     {
1059         SolarMutexGuard aSolarGuard;
1060         ::osl::MutexGuard aGuard( m_aMutex );
1061         EnsureIsAlive();
1062         return OCommonAccessibleText::implGetTextRange( implGetText(), nStartIndex, nEndIndex );
1063     }
1064     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1065     {
1066         SolarMutexGuard aSolarGuard;
1067         ::osl::MutexGuard aGuard( m_aMutex );
1068         EnsureIsAlive();
1069         return OCommonAccessibleText::getTextAtIndex( nIndex ,aTextType);
1070     }
1071     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1072     {
1073         SolarMutexGuard aSolarGuard;
1074         ::osl::MutexGuard aGuard( m_aMutex );
1075         EnsureIsAlive();
1076         return OCommonAccessibleText::getTextBeforeIndex( nIndex ,aTextType);
1077     }
1078     css::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType )
1079     {
1080         SolarMutexGuard aSolarGuard;
1081         ::osl::MutexGuard aGuard( m_aMutex );
1082         EnsureIsAlive();
1083
1084         return OCommonAccessibleText::getTextBehindIndex( nIndex ,aTextType);
1085     }
1086
1087     // XAccessibleValue
1088
1089
1090     Any AccessibleListBoxEntry::getCurrentValue(  )
1091     {
1092         ::osl::MutexGuard aGuard( m_aMutex );
1093         Any aValue;
1094         sal_Int32 level = static_cast<sal_Int32>(m_aEntryPath.size()) - 1;
1095         level = level < 0 ?  0: level;
1096         aValue <<= level;
1097         return aValue;
1098     }
1099
1100
1101     sal_Bool AccessibleListBoxEntry::setCurrentValue( const Any& aNumber )
1102     {
1103         ::osl::MutexGuard aGuard( m_aMutex );
1104
1105
1106         bool bReturn = false;
1107         SvTreeListBox* pBox = m_pTreeListBox;
1108         if(getAccessibleRole() == AccessibleRole::CHECK_BOX)
1109         {
1110             SvTreeListEntry* pEntry = pBox->GetEntryFromPath( m_aEntryPath );
1111             if ( pEntry )
1112             {
1113                 sal_Int32 nValue(0), nValueMin(0), nValueMax(0);
1114                 aNumber >>= nValue;
1115                 getMinimumValue() >>= nValueMin;
1116                 getMaximumValue() >>= nValueMax;
1117
1118                 if ( nValue < nValueMin )
1119                     nValue = nValueMin;
1120                 else if ( nValue > nValueMax )
1121                     nValue = nValueMax;
1122
1123                 pBox->SetCheckButtonState(pEntry,  static_cast<SvButtonState>(nValue) );
1124                 bReturn = true;
1125             }
1126         }
1127
1128         return bReturn;
1129     }
1130
1131
1132     Any AccessibleListBoxEntry::getMaximumValue(  )
1133     {
1134         ::osl::MutexGuard aGuard( m_aMutex );
1135
1136         Any aValue;
1137         // SvTreeListBox* pBox = m_pTreeListBox;
1138         switch(getAccessibleRole())
1139         {
1140             case AccessibleRole::CHECK_BOX:
1141                 aValue <<= sal_Int32(1);
1142                 break;
1143             case AccessibleRole::LABEL:
1144             default:
1145                 break;
1146         }
1147
1148         return aValue;
1149     }
1150
1151
1152     Any AccessibleListBoxEntry::getMinimumValue(  )
1153     {
1154         ::osl::MutexGuard aGuard( m_aMutex );
1155
1156         Any aValue;
1157         // SvTreeListBox* pBox = m_pTreeListBox;
1158         switch(getAccessibleRole())
1159         {
1160             case AccessibleRole::CHECK_BOX:
1161                 aValue <<= sal_Int32(0);
1162                 break;
1163             case AccessibleRole::LABEL:
1164             default:
1165                 break;
1166         }
1167
1168         return aValue;
1169     }
1170
1171     Any AccessibleListBoxEntry::getMinimumIncrement(  )
1172     {
1173         ::osl::MutexGuard aGuard( m_aMutex );
1174
1175         Any aValue;
1176         switch(getAccessibleRole())
1177         {
1178             case AccessibleRole::CHECK_BOX:
1179                 aValue <<= sal_Int32(1);
1180                 break;
1181             case AccessibleRole::LABEL:
1182             default:
1183                 break;
1184         }
1185
1186         return aValue;
1187     }
1188
1189     SvTreeListEntry* AccessibleListBoxEntry::GetRealChild(sal_Int32 nIndex)
1190     {
1191         SvTreeListEntry* pEntry = nullptr;
1192         SvTreeListEntry* pParent = m_pTreeListBox->GetEntryFromPath( m_aEntryPath );
1193         if (pParent)
1194         {
1195             pEntry = m_pTreeListBox->GetEntry( pParent, nIndex );
1196             if ( !pEntry && getAccessibleChildCount() > 0 )
1197             {
1198                 m_pTreeListBox->RequestingChildren(pParent);
1199                 pEntry = m_pTreeListBox->GetEntry( pParent, nIndex );
1200             }
1201         }
1202         return pEntry;
1203     }
1204
1205 }// namespace accessibility
1206
1207
1208 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */