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