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 "accessibility/extended/accessiblelistboxentry.hxx"
  21 #include <svtools/treelistbox.hxx>
  22 #include <svtools/stringtransfer.hxx>
  23 #include <com/sun/star/awt/Point.hpp>
  24 #include <com/sun/star/awt/Rectangle.hpp>
  25 #include <com/sun/star/awt/Size.hpp>
  26 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  27 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
  28 #include <com/sun/star/accessibility/AccessibleRole.hpp>
  29 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/controllayout.hxx>
  32 #include <toolkit/awt/vclxwindow.hxx>
  33 #include <toolkit/helper/convert.hxx>
  34 #include <unotools/accessiblestatesethelper.hxx>
  35 #include <unotools/accessiblerelationsethelper.hxx>
  36 #include <cppuhelper/supportsservice.hxx>
  37 #include <cppuhelper/typeprovider.hxx>
  38 #include <comphelper/sequence.hxx>
  39 #include <comphelper/accessibleeventnotifier.hxx>
  40 #include <toolkit/helper/vclunohelper.hxx>
  41
  42 #define ACCESSIBLE_ACTION_COUNT 1
  43
  44 namespace
  45 {
  46     void checkActionIndex_Impl( sal_Int32 _nIndex ) throw (::com::sun::star::lang::IndexOutOfBoundsException)
  47     {
  48         if ( _nIndex < 0 || _nIndex >= ACCESSIBLE_ACTION_COUNT )
  49             // only three actions
  50             throw ::com::sun::star::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
  64     // -----------------------------------------------------------------------------
  65     // Ctor() and Dtor()
  66     // -----------------------------------------------------------------------------
  67     AccessibleListBoxEntry::AccessibleListBoxEntry( SvTreeListBox& _rListBox,
  68                                                     SvTreeListEntry* _pEntry,
  69                                                     const Reference< XAccessible >& _xParent ) :
  70
  71         AccessibleListBoxEntry_BASE ( m_aMutex ),
  72         ListBoxAccessibleBase( _rListBox ),
  73
  74         m_nClientId     ( 0 ),
  75         m_aParent       ( _xParent )
  76
  77     {
  78         _rListBox.FillEntryPath( _pEntry, m_aEntryPath );
  79     }
  80     // -----------------------------------------------------------------------------
  81     AccessibleListBoxEntry::~AccessibleListBoxEntry()
  82     {
  83         if ( IsAlive_Impl() )
  84         {
  85             // increment ref count to prevent double call of Dtor
  86             osl_atomic_increment( &m_refCount );
  87             dispose();
  88         }
  89     }
  90
  91     // -----------------------------------------------------------------------------
  92     Rectangle AccessibleListBoxEntry::GetBoundingBox_Impl() const
  93     {
  94         Rectangle aRect;
  95         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
  96         if ( pEntry )
  97         {
  98             aRect = getListBox()->GetBoundingRect( pEntry );
  99             SvTreeListEntry* pParent = getListBox()->GetParent( pEntry );
 100             if ( pParent )
 101             {
 102                 // position relative to parent entry
 103                 Point aTopLeft = aRect.TopLeft();
 104                 aTopLeft -= getListBox()->GetBoundingRect( pParent ).TopLeft();
 105                 aRect = Rectangle( aTopLeft, aRect.GetSize() );
 106             }
 107         }
 108
 109         return aRect;
 110     }
 111     // -----------------------------------------------------------------------------
 112     Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen_Impl() const
 113     {
 114         Rectangle aRect;
 115         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 116         if ( pEntry )
 117         {
 118             aRect = getListBox()->GetBoundingRect( pEntry );
 119             Point aTopLeft = aRect.TopLeft();
 120             aTopLeft += getListBox()->GetWindowExtentsRelative( NULL ).TopLeft();
 121             aRect = Rectangle( aTopLeft, aRect.GetSize() );
 122         }
 123
 124         return aRect;
 125     }
 126     // -----------------------------------------------------------------------------
 127     sal_Bool AccessibleListBoxEntry::IsAlive_Impl() const
 128     {
 129         return ( !rBHelper.bDisposed && !rBHelper.bInDispose && isAlive() );
 130     }
 131     // -----------------------------------------------------------------------------
 132     sal_Bool AccessibleListBoxEntry::IsShowing_Impl() const
 133     {
 134         Reference< XAccessible > xParent = implGetParentAccessible( );
 135
 136         sal_Bool bShowing = sal_False;
 137         Reference< XAccessibleContext > m_xParentContext =
 138             xParent.is() ? xParent->getAccessibleContext() : Reference< XAccessibleContext >();
 139         if( m_xParentContext.is() )
 140         {
 141             Reference< XAccessibleComponent > xParentComp( m_xParentContext, uno::UNO_QUERY );
 142             if( xParentComp.is() )
 143                 bShowing = GetBoundingBox_Impl().IsOver( VCLRectangle( xParentComp->getBounds() ) );
 144         }
 145
 146         return bShowing;
 147     }
 148     // -----------------------------------------------------------------------------
 149     Rectangle AccessibleListBoxEntry::GetBoundingBox() throw ( lang::DisposedException )
 150     {
 151         SolarMutexGuard aSolarGuard;
 152         ::osl::MutexGuard aGuard( m_aMutex );
 153
 154         EnsureIsAlive();
 155         return GetBoundingBox_Impl();
 156     }
 157     // -----------------------------------------------------------------------------
 158     Rectangle AccessibleListBoxEntry::GetBoundingBoxOnScreen() throw ( lang::DisposedException )
 159     {
 160         SolarMutexGuard aSolarGuard;
 161         ::osl::MutexGuard aGuard( m_aMutex );
 162
 163         EnsureIsAlive();
 164         return GetBoundingBoxOnScreen_Impl();
 165     }
 166     // -----------------------------------------------------------------------------
 167     void AccessibleListBoxEntry::EnsureIsAlive() const throw ( lang::DisposedException )
 168     {
 169         if ( !IsAlive_Impl() )
 170             throw lang::DisposedException();
 171     }
 172     // -----------------------------------------------------------------------------
 173     OUString AccessibleListBoxEntry::implGetText()
 174     {
 175         OUString sRet;
 176         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 177         if ( pEntry )
 178             sRet = getListBox()->SearchEntryText( pEntry );
 179         return sRet;
 180     }
 181     // -----------------------------------------------------------------------------
 182     Locale AccessibleListBoxEntry::implGetLocale()
 183     {
 184         Locale aLocale;
 185         aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
 186
 187         return aLocale;
 188     }
 189     void AccessibleListBoxEntry::implGetSelection( sal_Int32& nStartIndex, sal_Int32& nEndIndex )
 190     {
 191         nStartIndex = 0;
 192         nEndIndex = 0;
 193     }
 194     // -----------------------------------------------------------------------------
 195     // XTypeProvider
 196     // -----------------------------------------------------------------------------
 197     // -----------------------------------------------------------------------------
 198     Sequence< sal_Int8 > AccessibleListBoxEntry::getImplementationId() throw (RuntimeException)
 199     {
 200         static ::cppu::OImplementationId* pId = NULL;
 201
 202         if ( !pId )
 203         {
 204             ::osl::Guard< ::osl::Mutex > aGuard( m_aMutex );
 205
 206             if ( !pId )
 207             {
 208                 static ::cppu::OImplementationId aId;
 209                 pId = &aId;
 210             }
 211         }
 212         return pId->getImplementationId();
 213     }
 214
 215     // -----------------------------------------------------------------------------
 216     // XComponent/ListBoxAccessibleBase
 217     // -----------------------------------------------------------------------------
 218     void SAL_CALL AccessibleListBoxEntry::dispose() throw ( uno::RuntimeException )
 219     {
 220         AccessibleListBoxEntry_BASE::dispose();
 221     }
 222
 223     // -----------------------------------------------------------------------------
 224     // XComponent
 225     // -----------------------------------------------------------------------------
 226     void SAL_CALL AccessibleListBoxEntry::disposing()
 227     {
 228         SolarMutexGuard();
 229         ::osl::MutexGuard aGuard( m_aMutex );
 230
 231         Reference< XAccessible > xKeepAlive( this );
 232
 233         // Send a disposing to all listeners.
 234         if ( m_nClientId )
 235         {
 236             ::comphelper::AccessibleEventNotifier::TClientId nId = m_nClientId;
 237             m_nClientId =  0;
 238             ::comphelper::AccessibleEventNotifier::revokeClientNotifyDisposing( nId, *this );
 239         }
 240
 241         // clean up
 242         {
 243
 244             ListBoxAccessibleBase::disposing();
 245         }
 246         m_aParent = WeakReference< XAccessible >();
 247     }
 248     // -----------------------------------------------------------------------------
 249     // XServiceInfo
 250     // -----------------------------------------------------------------------------
 251     OUString SAL_CALL AccessibleListBoxEntry::getImplementationName() throw(RuntimeException)
 252     {
 253         return getImplementationName_Static();
 254     }
 255     // -----------------------------------------------------------------------------
 256     Sequence< OUString > SAL_CALL AccessibleListBoxEntry::getSupportedServiceNames() throw(RuntimeException)
 257     {
 258         return getSupportedServiceNames_Static();
 259     }
 260     // -----------------------------------------------------------------------------
 261     sal_Bool SAL_CALL AccessibleListBoxEntry::supportsService( const OUString& _rServiceName ) throw (RuntimeException)
 262     {
 263         return cppu::supportsService(this, _rServiceName);
 264     }
 265     // -----------------------------------------------------------------------------
 266     // XServiceInfo - static methods
 267     // -----------------------------------------------------------------------------
 268     Sequence< OUString > AccessibleListBoxEntry::getSupportedServiceNames_Static(void) throw( RuntimeException )
 269     {
 270         Sequence< OUString > aSupported(3);
 271         aSupported[0] = "com.sun.star.accessibility.AccessibleContext";
 272         aSupported[1] = "com.sun.star.accessibility.AccessibleComponent";
 273         aSupported[2] = "com.sun.star.awt.AccessibleTreeListBoxEntry";
 274         return aSupported;
 275     }
 276     // -----------------------------------------------------------------------------
 277     OUString AccessibleListBoxEntry::getImplementationName_Static(void) throw( RuntimeException )
 278     {
 279         return OUString( "com.sun.star.comp.svtools.AccessibleTreeListBoxEntry" );
 280     }
 281     // -----------------------------------------------------------------------------
 282     // XAccessible
 283     // -----------------------------------------------------------------------------
 284     Reference< XAccessibleContext > SAL_CALL AccessibleListBoxEntry::getAccessibleContext(  ) throw (RuntimeException)
 285     {
 286         EnsureIsAlive();
 287         return this;
 288     }
 289     // -----------------------------------------------------------------------------
 290     // XAccessibleContext
 291     // -----------------------------------------------------------------------------
 292     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleChildCount(  ) throw (RuntimeException)
 293     {
 294         SolarMutexGuard aSolarGuard;
 295         ::osl::MutexGuard aGuard( m_aMutex );
 296
 297         EnsureIsAlive();
 298         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 299         sal_Int32 nCount = 0;
 300         if ( pEntry )
 301             nCount = getListBox()->GetLevelChildCount( pEntry );
 302
 303         return nCount;
 304     }
 305     // -----------------------------------------------------------------------------
 306     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException,RuntimeException)
 307     {
 308         SolarMutexGuard aSolarGuard;
 309         ::osl::MutexGuard aGuard( m_aMutex );
 310         EnsureIsAlive();
 311
 312         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 313         SvTreeListEntry* pEntry = pParent ? getListBox()->GetEntry( pParent, i ) : NULL;
 314         if ( !pEntry )
 315             throw IndexOutOfBoundsException();
 316
 317         return new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 318     }
 319
 320     // -----------------------------------------------------------------------------
 321     Reference< XAccessible > AccessibleListBoxEntry::implGetParentAccessible( ) const
 322     {
 323         Reference< XAccessible > xParent = (Reference< XAccessible >)m_aParent;
 324         if ( !xParent.is() )
 325         {
 326             OSL_ENSURE( m_aEntryPath.size(), "AccessibleListBoxEntry::getAccessibleParent: invalid path!" );
 327             if ( 1 == m_aEntryPath.size() )
 328             {   // we're a top level entry
 329                 // -> our parent is the tree listbox itself
 330                 if ( getListBox() )
 331                     xParent = getListBox()->GetAccessible( );
 332             }
 333             else
 334             {   // we have a entry as parent -> get it's accessible
 335
 336                 // shorten our access path by one
 337                 ::std::deque< sal_Int32 > aParentPath( m_aEntryPath );
 338                 aParentPath.pop_back();
 339
 340                 // get the entry for this shortened access path
 341                 SvTreeListEntry* pParentEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 342                 OSL_ENSURE( pParentEntry, "AccessibleListBoxEntry::implGetParentAccessible: could not obtain a parent entry!" );
 343
 344                 if ( pParentEntry )
 345                     xParent = new AccessibleListBoxEntry( *getListBox(), pParentEntry, NULL );
 346                     // note that we pass NULL here as parent-accessible:
 347                     // this is allowed, as the AccessibleListBoxEntry class will create it's parent
 348                     // when needed
 349             }
 350         }
 351
 352         return xParent;
 353     }
 354
 355     // -----------------------------------------------------------------------------
 356     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleParent(  ) throw (RuntimeException)
 357     {
 358         SolarMutexGuard aSolarGuard;
 359         ::osl::MutexGuard aGuard( m_aMutex );
 360         EnsureIsAlive();
 361
 362         return implGetParentAccessible( );
 363     }
 364     // -----------------------------------------------------------------------------
 365     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleIndexInParent(  ) throw (RuntimeException)
 366     {
 367         ::osl::MutexGuard aGuard( m_aMutex );
 368
 369         OSL_ENSURE( !m_aEntryPath.empty(), "empty path" );
 370         return m_aEntryPath.empty() ? -1 : m_aEntryPath.back();
 371     }
 372     // -----------------------------------------------------------------------------
 373     sal_Int16 SAL_CALL AccessibleListBoxEntry::getAccessibleRole(  ) throw (RuntimeException)
 374     {
 375         return AccessibleRole::LABEL;
 376     }
 377     // -----------------------------------------------------------------------------
 378     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleDescription(  ) throw (RuntimeException)
 379     {
 380         // no description for every item
 381         return OUString();
 382     }
 383     // -----------------------------------------------------------------------------
 384     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleName(  ) throw (RuntimeException)
 385     {
 386         ::osl::MutexGuard aGuard( m_aMutex );
 387
 388         EnsureIsAlive();
 389         return implGetText();
 390     }
 391     // -----------------------------------------------------------------------------
 392     Reference< XAccessibleRelationSet > SAL_CALL AccessibleListBoxEntry::getAccessibleRelationSet(  ) throw (RuntimeException)
 393     {
 394         Reference< XAccessibleRelationSet > xRelSet;
 395         Reference< XAccessible > xParent;
 396         if ( m_aEntryPath.size() > 1 ) // not a root entry
 397             xParent = implGetParentAccessible();
 398         if ( xParent.is() )
 399         {
 400             utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper;
 401             Sequence< Reference< XInterface > > aSequence(1);
 402             aSequence[0] = xParent;
 403             pRelationSetHelper->AddRelation(
 404                 AccessibleRelation( AccessibleRelationType::NODE_CHILD_OF, aSequence ) );
 405             xRelSet = pRelationSetHelper;
 406         }
 407         return xRelSet;
 408     }
 409     // -----------------------------------------------------------------------------
 410     Reference< XAccessibleStateSet > SAL_CALL AccessibleListBoxEntry::getAccessibleStateSet(  ) throw (RuntimeException)
 411     {
 412         ::osl::MutexGuard aGuard( m_aMutex );
 413
 414         utl::AccessibleStateSetHelper* pStateSetHelper = new utl::AccessibleStateSetHelper;
 415         Reference< XAccessibleStateSet > xStateSet = pStateSetHelper;
 416
 417         if ( IsAlive_Impl() )
 418         {
 419                pStateSetHelper->AddState( AccessibleStateType::TRANSIENT );
 420                pStateSetHelper->AddState( AccessibleStateType::SELECTABLE );
 421                pStateSetHelper->AddState( AccessibleStateType::ENABLED );
 422             pStateSetHelper->AddState( AccessibleStateType::SENSITIVE );
 423             if ( getListBox()->IsInplaceEditingEnabled() )
 424                    pStateSetHelper->AddState( AccessibleStateType::EDITABLE );
 425             if ( IsShowing_Impl() )
 426                 pStateSetHelper->AddState( AccessibleStateType::SHOWING );
 427             getListBox()->FillAccessibleEntryStateSet(
 428                 getListBox()->GetEntryFromPath( m_aEntryPath ), *pStateSetHelper );
 429         }
 430         else
 431             pStateSetHelper->AddState( AccessibleStateType::DEFUNC );
 432
 433         return xStateSet;
 434     }
 435     // -----------------------------------------------------------------------------
 436     Locale SAL_CALL AccessibleListBoxEntry::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 437     {
 438         SolarMutexGuard aSolarGuard;
 439         ::osl::MutexGuard aGuard( m_aMutex );
 440
 441         return implGetLocale();
 442     }
 443     // -----------------------------------------------------------------------------
 444     // XAccessibleComponent
 445     // -----------------------------------------------------------------------------
 446     sal_Bool SAL_CALL AccessibleListBoxEntry::containsPoint( const awt::Point& rPoint ) throw (RuntimeException)
 447     {
 448         return Rectangle( Point(), GetBoundingBox().GetSize() ).IsInside( VCLPoint( rPoint ) );
 449     }
 450     // -----------------------------------------------------------------------------
 451     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getAccessibleAtPoint( const awt::Point& _aPoint ) throw (RuntimeException)
 452     {
 453         SolarMutexGuard aSolarGuard;
 454         ::osl::MutexGuard aGuard( m_aMutex );
 455
 456         EnsureIsAlive();
 457         SvTreeListEntry* pEntry = getListBox()->GetEntry( VCLPoint( _aPoint ) );
 458         if ( !pEntry )
 459             throw RuntimeException();
 460
 461         Reference< XAccessible > xAcc;
 462         AccessibleListBoxEntry* pAccEntry = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 463         Rectangle aRect = pAccEntry->GetBoundingBox_Impl();
 464         if ( aRect.IsInside( VCLPoint( _aPoint ) ) )
 465             xAcc = pAccEntry;
 466         return xAcc;
 467     }
 468     // -----------------------------------------------------------------------------
 469     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getBounds(  ) throw (RuntimeException)
 470     {
 471         return AWTRectangle( GetBoundingBox() );
 472     }
 473     // -----------------------------------------------------------------------------
 474     awt::Point SAL_CALL AccessibleListBoxEntry::getLocation(  ) throw (RuntimeException)
 475     {
 476         return AWTPoint( GetBoundingBox().TopLeft() );
 477     }
 478     // -----------------------------------------------------------------------------
 479     awt::Point SAL_CALL AccessibleListBoxEntry::getLocationOnScreen(  ) throw (RuntimeException)
 480     {
 481         return AWTPoint( GetBoundingBoxOnScreen().TopLeft() );
 482     }
 483     // -----------------------------------------------------------------------------
 484     awt::Size SAL_CALL AccessibleListBoxEntry::getSize(  ) throw (RuntimeException)
 485     {
 486         return AWTSize( GetBoundingBox().GetSize() );
 487     }
 488     // -----------------------------------------------------------------------------
 489     void SAL_CALL AccessibleListBoxEntry::grabFocus(  ) throw (RuntimeException)
 490     {
 491         // do nothing, because no focus for each item
 492     }
 493     // -----------------------------------------------------------------------------
 494     sal_Int32 AccessibleListBoxEntry::getForeground(    ) throw (RuntimeException)
 495     {
 496         SolarMutexGuard aSolarGuard;
 497         ::osl::MutexGuard aGuard( m_aMutex );
 498
 499         sal_Int32 nColor = 0;
 500         Reference< XAccessible > xParent = getAccessibleParent();
 501         if ( xParent.is() )
 502         {
 503             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 504             if ( xParentComp.is() )
 505                 nColor = xParentComp->getForeground();
 506         }
 507
 508         return nColor;
 509     }
 510     // -----------------------------------------------------------------------------
 511     sal_Int32 AccessibleListBoxEntry::getBackground(  ) throw (RuntimeException)
 512     {
 513         SolarMutexGuard aSolarGuard;
 514         ::osl::MutexGuard aGuard( m_aMutex );
 515
 516         sal_Int32 nColor = 0;
 517         Reference< XAccessible > xParent = getAccessibleParent();
 518         if ( xParent.is() )
 519         {
 520             Reference< XAccessibleComponent > xParentComp( xParent->getAccessibleContext(), UNO_QUERY );
 521             if ( xParentComp.is() )
 522                 nColor = xParentComp->getBackground();
 523         }
 524
 525         return nColor;
 526     }
 527     // -----------------------------------------------------------------------------
 528     // XAccessibleText
 529     // -----------------------------------------------------------------------------
 530     // -----------------------------------------------------------------------------
 531     awt::Rectangle SAL_CALL AccessibleListBoxEntry::getCharacterBounds( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 532     {
 533         SolarMutexGuard aSolarGuard;
 534         ::osl::MutexGuard aGuard( m_aMutex );
 535
 536         EnsureIsAlive();
 537
 538         if ( !implIsValidIndex( nIndex, implGetText().getLength() ) )
 539             throw IndexOutOfBoundsException();
 540
 541         awt::Rectangle aBounds( 0, 0, 0, 0 );
 542         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 543         if ( pEntry )
 544         {
 545             ::vcl::ControlLayoutData aLayoutData;
 546             Rectangle aItemRect = GetBoundingBox();
 547             getListBox()->RecordLayoutData( &aLayoutData, aItemRect );
 548             Rectangle aCharRect = aLayoutData.GetCharacterBounds( nIndex );
 549             aCharRect.Move( -aItemRect.Left(), -aItemRect.Top() );
 550             aBounds = AWTRectangle( aCharRect );
 551         }
 552
 553         return aBounds;
 554     }
 555     // -----------------------------------------------------------------------------
 556     sal_Int32 SAL_CALL AccessibleListBoxEntry::getIndexAtPoint( const awt::Point& aPoint ) throw (RuntimeException)
 557     {
 558         SolarMutexGuard aSolarGuard;
 559         ::osl::MutexGuard aGuard( m_aMutex );
 560         EnsureIsAlive();
 561
 562         sal_Int32 nIndex = -1;
 563         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 564         if ( pEntry )
 565         {
 566             ::vcl::ControlLayoutData aLayoutData;
 567             Rectangle aItemRect = GetBoundingBox();
 568             getListBox()->RecordLayoutData( &aLayoutData, aItemRect );
 569             Point aPnt( VCLPoint( aPoint ) );
 570             aPnt += aItemRect.TopLeft();
 571             nIndex = aLayoutData.GetIndexForPoint( aPnt );
 572         }
 573
 574         return nIndex;
 575     }
 576     // -----------------------------------------------------------------------------
 577     sal_Bool SAL_CALL AccessibleListBoxEntry::copyText( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 578     {
 579         SolarMutexGuard aSolarGuard;
 580         ::osl::MutexGuard aGuard( m_aMutex );
 581         EnsureIsAlive();
 582
 583         String sText = getText();
 584         if  ( ( 0 > nStartIndex ) || ( sText.Len() <= nStartIndex )
 585             || ( 0 > nEndIndex ) || ( sText.Len() <= nEndIndex ) )
 586             throw IndexOutOfBoundsException();
 587
 588         sal_Int32 nLen = nEndIndex - nStartIndex + 1;
 589         ::svt::OStringTransfer::CopyString( sText.Copy( (sal_uInt16)nStartIndex, (sal_uInt16)nLen ), getListBox() );
 590
 591         return sal_True;
 592     }
 593     // -----------------------------------------------------------------------------
 594     // XAccessibleEventBroadcaster
 595     // -----------------------------------------------------------------------------
 596     void SAL_CALL AccessibleListBoxEntry::addAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException)
 597     {
 598         if (xListener.is())
 599         {
 600             ::osl::MutexGuard aGuard( m_aMutex );
 601             if (!m_nClientId)
 602                 m_nClientId = comphelper::AccessibleEventNotifier::registerClient( );
 603             comphelper::AccessibleEventNotifier::addEventListener( m_nClientId, xListener );
 604         }
 605     }
 606     // -----------------------------------------------------------------------------
 607     void SAL_CALL AccessibleListBoxEntry::removeAccessibleEventListener( const Reference< XAccessibleEventListener >& xListener ) throw (RuntimeException)
 608     {
 609         if (xListener.is())
 610         {
 611             ::osl::MutexGuard aGuard( m_aMutex );
 612
 613             sal_Int32 nListenerCount = comphelper::AccessibleEventNotifier::removeEventListener( m_nClientId, xListener );
 614             if ( !nListenerCount )
 615             {
 616                 // no listeners anymore
 617                 // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 618                 // and at least to us not firing any events anymore, in case somebody calls
 619                 // NotifyAccessibleEvent, again
 620                 sal_Int32 nId = m_nClientId;
 621                 m_nClientId = 0;
 622                 comphelper::AccessibleEventNotifier::revokeClient( nId );
 623
 624             }
 625         }
 626     }
 627     // -----------------------------------------------------------------------------
 628     // XAccessibleAction
 629     // -----------------------------------------------------------------------------
 630     sal_Int32 SAL_CALL AccessibleListBoxEntry::getAccessibleActionCount(  ) throw (RuntimeException)
 631     {
 632         ::osl::MutexGuard aGuard( m_aMutex );
 633
 634         // three actions supported
 635         return ACCESSIBLE_ACTION_COUNT;
 636     }
 637     // -----------------------------------------------------------------------------
 638     sal_Bool SAL_CALL AccessibleListBoxEntry::doAccessibleAction( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 639     {
 640         SolarMutexGuard aSolarGuard;
 641         ::osl::MutexGuard aGuard( m_aMutex );
 642
 643         sal_Bool bRet = sal_False;
 644         checkActionIndex_Impl( nIndex );
 645         EnsureIsAlive();
 646
 647         SvTreeListEntry* pEntry = getListBox()->GetEntryFromPath( m_aEntryPath );
 648         if ( pEntry )
 649         {
 650             if ( getListBox()->IsExpanded( pEntry ) )
 651                 getListBox()->Collapse( pEntry );
 652             else
 653                 getListBox()->Expand( pEntry );
 654             bRet = sal_True;
 655         }
 656
 657         return bRet;
 658     }
 659     // -----------------------------------------------------------------------------
 660     OUString SAL_CALL AccessibleListBoxEntry::getAccessibleActionDescription( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 661     {
 662         SolarMutexGuard aSolarGuard;
 663         ::osl::MutexGuard aGuard( m_aMutex );
 664
 665         checkActionIndex_Impl( nIndex );
 666         EnsureIsAlive();
 667
 668         static const OUString sActionDesc( "toggleExpand" );
 669         return sActionDesc;
 670     }
 671     // -----------------------------------------------------------------------------
 672     Reference< XAccessibleKeyBinding > AccessibleListBoxEntry::getAccessibleActionKeyBinding( sal_Int32 nIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 673     {
 674         ::osl::MutexGuard aGuard( m_aMutex );
 675
 676         Reference< XAccessibleKeyBinding > xRet;
 677         checkActionIndex_Impl( nIndex );
 678         // ... which key?
 679         return xRet;
 680     }
 681     // -----------------------------------------------------------------------------
 682     // XAccessibleSelection
 683     // -----------------------------------------------------------------------------
 684     void SAL_CALL AccessibleListBoxEntry::selectAccessibleChild( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 685     {
 686         SolarMutexGuard aSolarGuard;
 687         ::osl::MutexGuard aGuard( m_aMutex );
 688
 689         EnsureIsAlive();
 690
 691         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 692         SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, nChildIndex );
 693         if ( !pEntry )
 694             throw IndexOutOfBoundsException();
 695
 696         getListBox()->Select( pEntry, sal_True );
 697     }
 698     // -----------------------------------------------------------------------------
 699     sal_Bool SAL_CALL AccessibleListBoxEntry::isAccessibleChildSelected( sal_Int32 nChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 700     {
 701         SolarMutexGuard aSolarGuard;
 702         ::osl::MutexGuard aGuard( m_aMutex );
 703
 704         EnsureIsAlive();
 705
 706         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 707         SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, nChildIndex );
 708         if ( !pEntry )
 709             throw IndexOutOfBoundsException();
 710
 711         return getListBox()->IsSelected( pEntry );
 712     }
 713     // -----------------------------------------------------------------------------
 714     void SAL_CALL AccessibleListBoxEntry::clearAccessibleSelection(  ) throw (RuntimeException)
 715     {
 716         SolarMutexGuard aSolarGuard;
 717         ::osl::MutexGuard aGuard( m_aMutex );
 718
 719         EnsureIsAlive();
 720
 721         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 722         if ( !pParent )
 723             throw RuntimeException();
 724         sal_Int32 nCount = getListBox()->GetLevelChildCount( pParent );
 725         for ( sal_Int32 i = 0; i < nCount; ++i )
 726         {
 727             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 728             if ( getListBox()->IsSelected( pEntry ) )
 729                 getListBox()->Select( pEntry, sal_False );
 730         }
 731     }
 732     // -----------------------------------------------------------------------------
 733     void SAL_CALL AccessibleListBoxEntry::selectAllAccessibleChildren(  ) throw (RuntimeException)
 734     {
 735         SolarMutexGuard aSolarGuard;
 736         ::osl::MutexGuard aGuard( m_aMutex );
 737
 738         EnsureIsAlive();
 739
 740         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 741         if ( !pParent )
 742             throw RuntimeException();
 743         sal_Int32 nCount = getListBox()->GetLevelChildCount( pParent );
 744         for ( sal_Int32 i = 0; i < nCount; ++i )
 745         {
 746             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 747             if ( !getListBox()->IsSelected( pEntry ) )
 748                 getListBox()->Select( pEntry, sal_True );
 749         }
 750     }
 751     // -----------------------------------------------------------------------------
 752     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChildCount(  ) throw (RuntimeException)
 753     {
 754         SolarMutexGuard aSolarGuard;
 755         ::osl::MutexGuard aGuard( m_aMutex );
 756
 757         EnsureIsAlive();
 758
 759         sal_Int32 i, nSelCount = 0, nCount = 0;
 760
 761         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 762         if ( !pParent )
 763             throw RuntimeException();
 764         nCount = getListBox()->GetLevelChildCount( pParent );
 765         for ( i = 0; i < nCount; ++i )
 766         {
 767             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 768             if ( getListBox()->IsSelected( pEntry ) )
 769                 ++nSelCount;
 770         }
 771
 772         return nSelCount;
 773     }
 774     // -----------------------------------------------------------------------------
 775     Reference< XAccessible > SAL_CALL AccessibleListBoxEntry::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 776     {
 777         SolarMutexGuard aSolarGuard;
 778         ::osl::MutexGuard aGuard( m_aMutex );
 779
 780         EnsureIsAlive();
 781
 782         if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
 783             throw IndexOutOfBoundsException();
 784
 785         Reference< XAccessible > xChild;
 786         sal_Int32 i, nSelCount = 0, nCount = 0;
 787
 788         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 789         if ( !pParent )
 790             throw RuntimeException();
 791         nCount = getListBox()->GetLevelChildCount( pParent );
 792         for ( i = 0; i < nCount; ++i )
 793         {
 794             SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, i );
 795             if ( getListBox()->IsSelected( pEntry ) )
 796                 ++nSelCount;
 797
 798             if ( nSelCount == ( nSelectedChildIndex + 1 ) )
 799             {
 800                 xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
 801                 break;
 802             }
 803         }
 804
 805         return xChild;
 806     }
 807     // -----------------------------------------------------------------------------
 808     void SAL_CALL AccessibleListBoxEntry::deselectAccessibleChild( sal_Int32 nSelectedChildIndex ) throw (IndexOutOfBoundsException, RuntimeException)
 809     {
 810         SolarMutexGuard aSolarGuard;
 811         ::osl::MutexGuard aGuard( m_aMutex );
 812
 813         EnsureIsAlive();
 814
 815         SvTreeListEntry* pParent = getListBox()->GetEntryFromPath( m_aEntryPath );
 816         SvTreeListEntry* pEntry = getListBox()->GetEntry( pParent, nSelectedChildIndex );
 817         if ( !pEntry )
 818             throw IndexOutOfBoundsException();
 819
 820         getListBox()->Select( pEntry, sal_False );
 821     }
 822     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCaretPosition(  ) throw (::com::sun::star::uno::RuntimeException)
 823     {
 824         return -1;
 825     }
 826     sal_Bool SAL_CALL AccessibleListBoxEntry::setCaretPosition ( sal_Int32 nIndex ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException)
 827     {
 828         SolarMutexGuard aSolarGuard;
 829         ::osl::MutexGuard aGuard( m_aMutex );
 830         EnsureIsAlive();
 831
 832         if ( !implIsValidRange( nIndex, nIndex, implGetText().getLength() ) )
 833             throw IndexOutOfBoundsException();
 834
 835         return sal_False;
 836     }
 837     sal_Unicode SAL_CALL AccessibleListBoxEntry::getCharacter( sal_Int32 nIndex ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException)
 838     {
 839         SolarMutexGuard aSolarGuard;
 840         ::osl::MutexGuard aGuard( m_aMutex );
 841         EnsureIsAlive();
 842         return OCommonAccessibleText::getCharacter( nIndex );
 843     }
 844     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > SAL_CALL AccessibleListBoxEntry::getCharacterAttributes( sal_Int32 nIndex, const ::com::sun::star::uno::Sequence< OUString >& ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException)
 845     {
 846         SolarMutexGuard aSolarGuard;
 847         ::osl::MutexGuard aGuard( m_aMutex );
 848         EnsureIsAlive();
 849
 850         OUString sText( implGetText() );
 851
 852         if ( !implIsValidIndex( nIndex, sText.getLength() ) )
 853             throw IndexOutOfBoundsException();
 854
 855         return ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue >();
 856     }
 857     sal_Int32 SAL_CALL AccessibleListBoxEntry::getCharacterCount(  ) throw (::com::sun::star::uno::RuntimeException)
 858     {
 859         SolarMutexGuard aSolarGuard;
 860         ::osl::MutexGuard aGuard( m_aMutex );
 861         EnsureIsAlive();
 862         return OCommonAccessibleText::getCharacterCount(  );
 863     }
 864
 865     OUString SAL_CALL AccessibleListBoxEntry::getSelectedText(  ) throw (::com::sun::star::uno::RuntimeException)
 866     {
 867         SolarMutexGuard aSolarGuard;
 868         ::osl::MutexGuard aGuard( m_aMutex );
 869         EnsureIsAlive();
 870         return OCommonAccessibleText::getSelectedText(  );
 871     }
 872     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionStart(  ) throw (::com::sun::star::uno::RuntimeException)
 873     {
 874         SolarMutexGuard aSolarGuard;
 875         ::osl::MutexGuard aGuard( m_aMutex );
 876         EnsureIsAlive();
 877         return OCommonAccessibleText::getSelectionStart(  );
 878     }
 879     sal_Int32 SAL_CALL AccessibleListBoxEntry::getSelectionEnd(  ) throw (::com::sun::star::uno::RuntimeException)
 880     {
 881         SolarMutexGuard aSolarGuard;
 882         ::osl::MutexGuard aGuard( m_aMutex );
 883         EnsureIsAlive();
 884         return OCommonAccessibleText::getSelectionEnd(  );
 885     }
 886     sal_Bool SAL_CALL AccessibleListBoxEntry::setSelection( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException)
 887     {
 888         SolarMutexGuard aSolarGuard;
 889         ::osl::MutexGuard aGuard( m_aMutex );
 890         EnsureIsAlive();
 891
 892         if ( !implIsValidRange( nStartIndex, nEndIndex, implGetText().getLength() ) )
 893             throw IndexOutOfBoundsException();
 894
 895         return sal_False;
 896     }
 897     OUString SAL_CALL AccessibleListBoxEntry::getText(  ) throw (::com::sun::star::uno::RuntimeException)
 898     {
 899         SolarMutexGuard aSolarGuard;
 900         ::osl::MutexGuard aGuard( m_aMutex );
 901         EnsureIsAlive();
 902         return OCommonAccessibleText::getText(  );
 903     }
 904     OUString SAL_CALL AccessibleListBoxEntry::getTextRange( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::uno::RuntimeException)
 905     {
 906         SolarMutexGuard aSolarGuard;
 907         ::osl::MutexGuard aGuard( m_aMutex );
 908         EnsureIsAlive();
 909         return OCommonAccessibleText::getTextRange( nStartIndex, nEndIndex );
 910     }
 911     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextAtIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
 912     {
 913         SolarMutexGuard aSolarGuard;
 914         ::osl::MutexGuard aGuard( m_aMutex );
 915         EnsureIsAlive();
 916         return OCommonAccessibleText::getTextAtIndex( nIndex ,aTextType);
 917     }
 918     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBeforeIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
 919     {
 920         SolarMutexGuard aSolarGuard;
 921         ::osl::MutexGuard aGuard( m_aMutex );
 922         EnsureIsAlive();
 923         return OCommonAccessibleText::getTextBeforeIndex( nIndex ,aTextType);
 924     }
 925     ::com::sun::star::accessibility::TextSegment SAL_CALL AccessibleListBoxEntry::getTextBehindIndex( sal_Int32 nIndex, sal_Int16 aTextType ) throw (::com::sun::star::lang::IndexOutOfBoundsException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException)
 926     {
 927         SolarMutexGuard aSolarGuard;
 928         ::osl::MutexGuard aGuard( m_aMutex );
 929         EnsureIsAlive();
 930
 931         return OCommonAccessibleText::getTextBehindIndex( nIndex ,aTextType);
 932     }
 933 //........................................................................
 934 }// namespace accessibility
 935 //........................................................................
 936
 937 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */