comphelper/source/misc/accessiblewrapper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: accessiblewrapper.cxx,v $
  10  * $Revision: 1.15 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_comphelper.hxx"
  33 #include "comphelper/accessiblewrapper.hxx"
  34 #include <com/sun/star/reflection/XProxyFactory.hpp>
  35 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  36 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  37
  38 #include <algorithm>
  39
  40 using namespace ::comphelper;
  41 using namespace ::com::sun::star::accessibility;
  42 using namespace ::com::sun::star::uno;
  43 using namespace ::com::sun::star::lang;
  44
  45 //.............................................................................
  46 namespace comphelper
  47 {
  48 //.............................................................................
  49
  50     //=========================================================================
  51     //= OWrappedAccessibleChildrenManager
  52     //=========================================================================
  53     //--------------------------------------------------------------------
  54     struct RemoveEventListener
  55             : public ::std::unary_function< AccessibleMap::value_type, void >
  56     {
  57     private:
  58         Reference< XEventListener >     m_xListener;
  59
  60     public:
  61         RemoveEventListener( const Reference< XEventListener >& _rxListener )
  62             :m_xListener( _rxListener  )
  63         {
  64         }
  65
  66         void operator()( const AccessibleMap::value_type& _rMapEntry ) const
  67         {
  68             Reference< XComponent > xComp( _rMapEntry.first, UNO_QUERY );
  69             if ( xComp.is() )
  70                 xComp->removeEventListener( m_xListener );
  71         }
  72     };
  73
  74     //--------------------------------------------------------------------
  75     struct DisposeMappedChild
  76             : public ::std::unary_function< AccessibleMap::value_type, void >
  77     {
  78         void operator()( const AccessibleMap::value_type& _rMapEntry ) const
  79         {
  80             Reference< XComponent > xContextComponent;
  81             if ( _rMapEntry.second.is() )
  82                 xContextComponent = xContextComponent.query( _rMapEntry.second->getAccessibleContext() );
  83             if ( xContextComponent.is() )
  84                 xContextComponent->dispose();
  85         }
  86     };
  87
  88     //-------------------------------------------------------------------------
  89     OWrappedAccessibleChildrenManager::OWrappedAccessibleChildrenManager( const Reference< XMultiServiceFactory >& _rxORB )
  90         :m_xORB( _rxORB )
  91         ,m_bTransientChildren( sal_True )
  92     {
  93     }
  94
  95     //-------------------------------------------------------------------------
  96     OWrappedAccessibleChildrenManager::~OWrappedAccessibleChildrenManager( )
  97     {
  98     }
  99
 100     //-------------------------------------------------------------------------
 101     void OWrappedAccessibleChildrenManager::setTransientChildren( sal_Bool _bSet )
 102     {
 103         m_bTransientChildren = _bSet;
 104     }
 105
 106     //-------------------------------------------------------------------------
 107     void OWrappedAccessibleChildrenManager::setOwningAccessible( const Reference< XAccessible >& _rxAcc )
 108     {
 109         OSL_ENSURE( !m_aOwningAccessible.get().is(), "OWrappedAccessibleChildrenManager::setOwningAccessible: to be called only once!" );
 110         m_aOwningAccessible = WeakReference< XAccessible >( _rxAcc );
 111     }
 112
 113     //-------------------------------------------------------------------------
 114     void OWrappedAccessibleChildrenManager::removeFromCache( const Reference< XAccessible >& _rxKey )
 115     {
 116         AccessibleMap::iterator aRemovedPos = m_aChildrenMap.find( _rxKey );
 117         if ( m_aChildrenMap.end() != aRemovedPos )
 118         {       // it was cached
 119             // remove ourself as event listener
 120             RemoveEventListener aOperator( this );
 121             aOperator( *aRemovedPos );
 122             // and remove the entry from the map
 123             m_aChildrenMap.erase( aRemovedPos );
 124         }
 125     }
 126
 127     //-------------------------------------------------------------------------
 128     void OWrappedAccessibleChildrenManager::invalidateAll( )
 129     {
 130         // remove as event listener from the map elements
 131         ::std::for_each( m_aChildrenMap.begin(), m_aChildrenMap.end(), RemoveEventListener( this ) );
 132         // clear the map
 133         AccessibleMap aMap;
 134         m_aChildrenMap.swap( aMap );
 135     }
 136
 137     //-------------------------------------------------------------------------
 138     Reference< XAccessible > OWrappedAccessibleChildrenManager::getAccessibleWrapperFor(
 139         const Reference< XAccessible >& _rxKey, sal_Bool _bCreate )
 140     {
 141         Reference< XAccessible > xValue;
 142
 143         if( !_rxKey.is() )
 144         {
 145             // fprintf( stderr, "It was this path that was crashing stuff\n" );
 146             return xValue;
 147         }
 148
 149         // do we have this child in the cahce?
 150         AccessibleMap::const_iterator aPos = m_aChildrenMap.find( _rxKey );
 151         if ( m_aChildrenMap.end() != aPos )
 152         {
 153             xValue = aPos->second;
 154         }
 155         else if ( _bCreate )
 156         {       // not found in the cache, and allowed to create
 157             // -> new wrapper
 158             xValue = new OAccessibleWrapper( m_xORB, _rxKey, (Reference< XAccessible >)m_aOwningAccessible );
 159
 160             // see if we do cache children
 161             if ( !m_bTransientChildren )
 162             {
 163                 if (!m_aChildrenMap.insert(
 164                         AccessibleMap::value_type( _rxKey, xValue ) ).second)
 165                 {
 166                     OSL_ENSURE(
 167                         false,
 168                         "OWrappedAccessibleChildrenManager::"
 169                             "getAccessibleWrapperFor: element was already"
 170                             " inserted!" );
 171                 }
 172
 173                 // listen for disposals of inner children - this may happen when the inner context
 174                 // is the owner for the inner children (it will dispose these children, and of course
 175                 // not our wrapper for these children)
 176                 Reference< XComponent > xComp( _rxKey, UNO_QUERY );
 177                 if ( xComp.is() )
 178                     xComp->addEventListener( this );
 179             }
 180         }
 181
 182         return xValue;
 183     }
 184
 185     //-------------------------------------------------------------------------
 186     void OWrappedAccessibleChildrenManager::dispose()
 187     {
 188         // dispose our children
 189         ::std::for_each( m_aChildrenMap.begin(), m_aChildrenMap.end(), RemoveEventListener( this ) );
 190         ::std::for_each( m_aChildrenMap.begin(), m_aChildrenMap.end(), DisposeMappedChild( ) );
 191         // clear our children
 192         AccessibleMap aMap;
 193         m_aChildrenMap.swap( aMap );
 194     }
 195
 196     //--------------------------------------------------------------------
 197     void OWrappedAccessibleChildrenManager::implTranslateChildEventValue( const Any& _rInValue, Any& _rOutValue )
 198     {
 199         _rOutValue.clear();
 200         Reference< XAccessible > xChild;
 201         if ( _rInValue >>= xChild )
 202             _rOutValue <<= getAccessibleWrapperFor( xChild, sal_True );
 203     }
 204
 205     //-------------------------------------------------------------------------
 206     void OWrappedAccessibleChildrenManager::translateAccessibleEvent( const AccessibleEventObject& _rEvent, AccessibleEventObject& _rTranslatedEvent )
 207     {
 208         // just in case we can't translate some of the values:
 209         _rTranslatedEvent.NewValue = _rEvent.NewValue;
 210         _rTranslatedEvent.OldValue = _rEvent.OldValue;
 211
 212         switch ( _rEvent.EventId )
 213         {
 214             case AccessibleEventId::CHILD:
 215             case AccessibleEventId::ACTIVE_DESCENDANT_CHANGED:
 216             case AccessibleEventId::CONTROLLED_BY_RELATION_CHANGED:
 217             case AccessibleEventId::CONTROLLER_FOR_RELATION_CHANGED:
 218             case AccessibleEventId::LABEL_FOR_RELATION_CHANGED:
 219             case AccessibleEventId::LABELED_BY_RELATION_CHANGED:
 220             case AccessibleEventId::CONTENT_FLOWS_FROM_RELATION_CHANGED:
 221             case AccessibleEventId::CONTENT_FLOWS_TO_RELATION_CHANGED:
 222                 // these are events where both the old and the new value contain child references
 223                 implTranslateChildEventValue( _rEvent.OldValue, _rTranslatedEvent.OldValue );
 224                 implTranslateChildEventValue( _rEvent.NewValue, _rTranslatedEvent.NewValue );
 225                 break;
 226
 227             case AccessibleEventId::NAME_CHANGED:
 228             case AccessibleEventId::DESCRIPTION_CHANGED:
 229             case AccessibleEventId::ACTION_CHANGED:
 230             case AccessibleEventId::STATE_CHANGED:
 231             case AccessibleEventId::BOUNDRECT_CHANGED:
 232             case AccessibleEventId::INVALIDATE_ALL_CHILDREN:
 233             case AccessibleEventId::SELECTION_CHANGED:
 234             case AccessibleEventId::VISIBLE_DATA_CHANGED:
 235             case AccessibleEventId::VALUE_CHANGED:
 236             case AccessibleEventId::MEMBER_OF_RELATION_CHANGED:
 237             case AccessibleEventId::CARET_CHANGED:
 238             case AccessibleEventId::TEXT_CHANGED:
 239             case AccessibleEventId::HYPERTEXT_CHANGED:
 240             case AccessibleEventId::TABLE_CAPTION_CHANGED:
 241             case AccessibleEventId::TABLE_COLUMN_DESCRIPTION_CHANGED:
 242             case AccessibleEventId::TABLE_COLUMN_HEADER_CHANGED:
 243             case AccessibleEventId::TABLE_MODEL_CHANGED:
 244             case AccessibleEventId::TABLE_ROW_DESCRIPTION_CHANGED:
 245             case AccessibleEventId::TABLE_ROW_HEADER_CHANGED:
 246             case AccessibleEventId::TABLE_SUMMARY_CHANGED:
 247             // --> PB 2006-03-21 #130798# EventId TEXT_SELECTION_CHANGED was missed
 248             // these Ids are also missed: SUB_WINDOW_OF_RELATION_CHANGED & TEXT_ATTRIBUTE_CHANGED
 249             case AccessibleEventId::TEXT_SELECTION_CHANGED:
 250             // <--
 251                 // nothing to translate
 252                 break;
 253
 254             default:
 255                 OSL_ENSURE( sal_False, "OWrappedAccessibleChildrenManager::translateAccessibleEvent: unknown (or unexpected) event id!" );
 256                 break;
 257         }
 258     }
 259
 260     //-------------------------------------------------------------------------
 261     void OWrappedAccessibleChildrenManager::handleChildNotification( const AccessibleEventObject& _rEvent )
 262     {
 263         if ( AccessibleEventId::INVALIDATE_ALL_CHILDREN == _rEvent.EventId )
 264         {       // clear our child map
 265             invalidateAll( );
 266         }
 267         else if ( AccessibleEventId::CHILD == _rEvent.EventId )
 268         {
 269             // check if the removed or replaced element is cached
 270             Reference< XAccessible > xRemoved;
 271             if ( _rEvent.OldValue >>= xRemoved )
 272                 removeFromCache( xRemoved );
 273         }
 274     }
 275
 276     //--------------------------------------------------------------------
 277     void SAL_CALL OWrappedAccessibleChildrenManager::disposing( const EventObject& _rSource ) throw (RuntimeException)
 278     {
 279         // this should come from one of the inner XAccessible's of our children
 280         Reference< XAccessible > xSource( _rSource.Source, UNO_QUERY );
 281         AccessibleMap::iterator aDisposedPos = m_aChildrenMap.find( xSource );
 282 #if OSL_DEBUG_LEVEL > 0
 283         if ( m_aChildrenMap.end() == aDisposedPos )
 284         {
 285                OSL_ENSURE( sal_False,
 286                 "OWrappedAccessibleChildrenManager::disposing: where did this come from?" );
 287             // helper for dignostics
 288             Reference< XAccessible > xOwningAccessible( m_aOwningAccessible );
 289             Reference< XAccessibleContext > xContext;
 290             try
 291             {
 292                 if ( xOwningAccessible.is() )
 293                     xContext = xOwningAccessible->getAccessibleContext();
 294                 if ( xContext.is() )
 295                 {
 296                     ::rtl::OUString sName = xContext->getAccessibleName();
 297                     ::rtl::OUString sDescription = xContext->getAccessibleDescription();
 298 //                  sal_Int32 nPlaceYourBreakpointHere = 0;
 299                 }
 300             }
 301             catch( const Exception& /*e*/ )
 302             {
 303                 // silent this, it's only diagnostics which failed
 304             }
 305         }
 306 #endif
 307         if ( m_aChildrenMap.end() != aDisposedPos )
 308         {
 309             m_aChildrenMap.erase( aDisposedPos );
 310         }
 311     }
 312
 313     //=========================================================================
 314     //= OAccessibleWrapper (implementation)
 315     //=========================================================================
 316     //-------------------------------------------------------------------------
 317     OAccessibleWrapper::OAccessibleWrapper( const Reference< XMultiServiceFactory >& _rxORB,
 318             const Reference< XAccessible >& _rxInnerAccessible, const Reference< XAccessible >& _rxParentAccessible )
 319         :OAccessibleWrapper_Base( )
 320         ,OComponentProxyAggregation( _rxORB, Reference< XComponent >( _rxInnerAccessible, UNO_QUERY ) )
 321         ,m_xParentAccessible( _rxParentAccessible )
 322         ,m_xInnerAccessible( _rxInnerAccessible )
 323     {
 324     }
 325
 326     //--------------------------------------------------------------------
 327     OAccessibleWrapper::~OAccessibleWrapper( )
 328     {
 329         if ( !m_rBHelper.bDisposed )
 330         {
 331             acquire();  // to prevent duplicate dtor calls
 332             dispose();
 333         }
 334     }
 335
 336     //--------------------------------------------------------------------
 337     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleWrapper, OComponentProxyAggregation, OAccessibleWrapper_Base )
 338     IMPLEMENT_FORWARD_REFCOUNT( OAccessibleWrapper, OComponentProxyAggregation )
 339
 340     //--------------------------------------------------------------------
 341     Any OAccessibleWrapper::queryInterface( const Type& _rType ) throw (RuntimeException)
 342     {
 343         // #111089# instead of the inner XAccessible the proxy XAccessible must be returned
 344         Any aReturn = OAccessibleWrapper_Base::queryInterface( _rType );
 345         if ( !aReturn.hasValue() )
 346             aReturn = OComponentProxyAggregation::queryInterface( _rType );
 347
 348         return aReturn;
 349     }
 350
 351     //--------------------------------------------------------------------
 352     Reference< XAccessibleContext > OAccessibleWrapper::getContextNoCreate( ) const
 353     {
 354         return (Reference< XAccessibleContext >)m_aContext;
 355     }
 356
 357     //--------------------------------------------------------------------
 358     OAccessibleContextWrapper* OAccessibleWrapper::createAccessibleContext( const Reference< XAccessibleContext >& _rxInnerContext )
 359     {
 360         return new OAccessibleContextWrapper( getORB(), _rxInnerContext, this, m_xParentAccessible );
 361     }
 362
 363     //--------------------------------------------------------------------
 364     Reference< XAccessibleContext > SAL_CALL OAccessibleWrapper::getAccessibleContext(  ) throw (RuntimeException)
 365     {
 366         // see if the context is still alive (we cache it)
 367         Reference< XAccessibleContext > xContext = (Reference< XAccessibleContext >)m_aContext;
 368         if ( !xContext.is() )
 369         {
 370             // create a new context
 371             Reference< XAccessibleContext > xInnerContext = m_xInnerAccessible->getAccessibleContext( );
 372             if ( xInnerContext.is() )
 373             {
 374                 xContext = createAccessibleContext( xInnerContext );
 375                 // cache it
 376                 m_aContext = WeakReference< XAccessibleContext >( xContext );
 377             }
 378         }
 379
 380         return xContext;
 381     }
 382
 383     //=========================================================================
 384     //= OAccessibleWrapper (implementation)
 385     //=========================================================================
 386     //-------------------------------------------------------------------------
 387     OAccessibleContextWrapperHelper::OAccessibleContextWrapperHelper(
 388                 const Reference< XMultiServiceFactory >& _rxORB,
 389                 ::cppu::OBroadcastHelper& _rBHelper,
 390                 const Reference< XAccessibleContext >& _rxInnerAccessibleContext,
 391                 const Reference< XAccessible >& _rxOwningAccessible,
 392                 const Reference< XAccessible >& _rxParentAccessible )
 393         :OComponentProxyAggregationHelper( _rxORB, _rBHelper )
 394         ,m_xInnerContext( _rxInnerAccessibleContext )
 395         ,m_xOwningAccessible( _rxOwningAccessible )
 396         ,m_xParentAccessible( _rxParentAccessible )
 397         ,m_pChildMapper( NULL )
 398     {
 399         // initialize the mapper for our children
 400         m_pChildMapper = new OWrappedAccessibleChildrenManager( getORB() );
 401         m_pChildMapper->acquire();
 402
 403         // determine if we're allowed to cache children
 404         Reference< XAccessibleStateSet > xStates( m_xInnerContext->getAccessibleStateSet( ) );
 405         OSL_ENSURE( xStates.is(), "OAccessibleContextWrapperHelper::OAccessibleContextWrapperHelper: no inner state set!" );
 406         m_pChildMapper->setTransientChildren( !xStates.is() || xStates->contains( AccessibleStateType::MANAGES_DESCENDANTS) );
 407
 408         m_pChildMapper->setOwningAccessible( m_xOwningAccessible );
 409     }
 410
 411     //--------------------------------------------------------------------
 412     void OAccessibleContextWrapperHelper::aggregateProxy( oslInterlockedCount& _rRefCount, ::cppu::OWeakObject& _rDelegator )
 413     {
 414         Reference< XComponent > xInnerComponent( m_xInnerContext, UNO_QUERY );
 415         OSL_ENSURE( xInnerComponent.is(), "OComponentProxyAggregation::aggregateProxy: accessible is no XComponent!" );
 416         if ( xInnerComponent.is() )
 417             componentAggregateProxyFor( xInnerComponent, _rRefCount, _rDelegator );
 418
 419         // add as event listener to the inner context, because we want to multiplex the AccessibleEvents
 420         osl_incrementInterlockedCount( &_rRefCount );
 421         {
 422             Reference< XAccessibleEventBroadcaster > xBroadcaster( m_xInner, UNO_QUERY );
 423             if ( xBroadcaster.is() )
 424                 xBroadcaster->addEventListener( this );
 425         }
 426         osl_decrementInterlockedCount( &_rRefCount );
 427     }
 428
 429     //--------------------------------------------------------------------
 430     OAccessibleContextWrapperHelper::~OAccessibleContextWrapperHelper( )
 431     {
 432         OSL_ENSURE( m_rBHelper.bDisposed, "OAccessibleContextWrapperHelper::~OAccessibleContextWrapperHelper: you should ensure (in your dtor) that the object is disposed!" );
 433
 434         m_pChildMapper->release();
 435         m_pChildMapper = NULL;
 436     }
 437
 438     //--------------------------------------------------------------------
 439     Any SAL_CALL OAccessibleContextWrapperHelper::queryInterface( const Type& _rType ) throw (RuntimeException)
 440     {
 441         Any aReturn = OComponentProxyAggregationHelper::queryInterface( _rType );
 442         if ( !aReturn.hasValue() )
 443             aReturn = OAccessibleContextWrapperHelper_Base::queryInterface( _rType );
 444         return aReturn;
 445     }
 446
 447     //--------------------------------------------------------------------
 448     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleContextWrapperHelper, OComponentProxyAggregationHelper, OAccessibleContextWrapperHelper_Base )
 449
 450     //--------------------------------------------------------------------
 451     sal_Int32 SAL_CALL OAccessibleContextWrapperHelper::getAccessibleChildCount(  ) throw (RuntimeException)
 452     {
 453         return m_xInnerContext->getAccessibleChildCount();
 454     }
 455
 456     //--------------------------------------------------------------------
 457     Reference< XAccessible > SAL_CALL OAccessibleContextWrapperHelper::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 458     {
 459         // get the child of the wrapped component
 460         Reference< XAccessible > xInnerChild = m_xInnerContext->getAccessibleChild( i );
 461         return m_pChildMapper->getAccessibleWrapperFor( xInnerChild );
 462     }
 463
 464     //--------------------------------------------------------------------
 465     Reference< XAccessibleRelationSet > SAL_CALL OAccessibleContextWrapperHelper::getAccessibleRelationSet(  ) throw (RuntimeException)
 466     {
 467         return m_xInnerContext->getAccessibleRelationSet();
 468             // TODO: if this relation set would contain relations to siblings, we would normally need
 469             // to wrap them, too ....
 470     }
 471
 472     //--------------------------------------------------------------------
 473     void SAL_CALL OAccessibleContextWrapperHelper::notifyEvent( const AccessibleEventObject& _rEvent ) throw (RuntimeException)
 474     {
 475 #if OSL_DEBUG_LEVEL > 0
 476         if ( AccessibleEventId::STATE_CHANGED == _rEvent.EventId )
 477         {
 478             sal_Bool bChildTransienceChanged = sal_False;
 479             sal_Int16 nChangeState = 0;
 480             if ( _rEvent.OldValue >>= nChangeState )
 481                 bChildTransienceChanged = bChildTransienceChanged || AccessibleStateType::MANAGES_DESCENDANTS == nChangeState;
 482             if ( _rEvent.NewValue >>= nChangeState )
 483                 bChildTransienceChanged = bChildTransienceChanged || AccessibleStateType::MANAGES_DESCENDANTS == nChangeState;
 484             OSL_ENSURE( !bChildTransienceChanged, "OAccessibleContextWrapperHelper::notifyEvent: MANAGES_DESCENDANTS is not expected to change during runtime!" );
 485                 // if this asserts, then we would need to update our m_bTransientChildren flag here,
 486                 // as well as (potentially) our child cache
 487         }
 488 #endif
 489         AccessibleEventObject aTranslatedEvent( _rEvent );
 490
 491         {
 492             ::osl::MutexGuard aGuard( m_rBHelper.rMutex );
 493
 494             // translate the event
 495             queryInterface( ::getCppuType( static_cast< Reference< XInterface >* >( NULL ) ) ) >>= aTranslatedEvent.Source;
 496             m_pChildMapper->translateAccessibleEvent( _rEvent, aTranslatedEvent );
 497
 498             // see if any of these notifications affect our child manager
 499             m_pChildMapper->handleChildNotification( _rEvent );
 500
 501             if ( aTranslatedEvent.NewValue == m_xInner )
 502                 aTranslatedEvent.NewValue = makeAny(aTranslatedEvent.Source);
 503             if ( aTranslatedEvent.OldValue == m_xInner )
 504                 aTranslatedEvent.OldValue = makeAny(aTranslatedEvent.Source);
 505         }
 506
 507         notifyTranslatedEvent( aTranslatedEvent );
 508     }
 509
 510     //--------------------------------------------------------------------
 511     void SAL_CALL OAccessibleContextWrapperHelper::dispose() throw( RuntimeException )
 512     {
 513         ::osl::MutexGuard aGuard( m_rBHelper.rMutex );
 514
 515         // stop multiplexing events
 516         Reference< XAccessibleEventBroadcaster > xBroadcaster( m_xInner, UNO_QUERY );
 517         OSL_ENSURE( xBroadcaster.is(), "OAccessibleContextWrapperHelper::disposing(): inner context is no broadcaster!" );
 518         if ( xBroadcaster.is() )
 519             xBroadcaster->removeEventListener( this );
 520
 521         // dispose the child cache/map
 522         m_pChildMapper->dispose();
 523
 524         // let the base class dispose the inner component
 525         OComponentProxyAggregationHelper::dispose();
 526     }
 527
 528     //--------------------------------------------------------------------
 529     void SAL_CALL OAccessibleContextWrapperHelper::disposing( const EventObject& _rEvent )  throw (RuntimeException)
 530     {
 531         // simply disambiguate this
 532         OComponentProxyAggregationHelper::disposing( _rEvent );
 533     }
 534
 535     //====================================================================
 536     //= OAccessibleContextWrapper
 537     //====================================================================
 538     //--------------------------------------------------------------------
 539     IMPLEMENT_FORWARD_XINTERFACE2( OAccessibleContextWrapper, OAccessibleContextWrapper_CBase, OAccessibleContextWrapperHelper )
 540
 541     //--------------------------------------------------------------------
 542     IMPLEMENT_FORWARD_XTYPEPROVIDER2( OAccessibleContextWrapper, OAccessibleContextWrapper_CBase, OAccessibleContextWrapperHelper )
 543
 544     //--------------------------------------------------------------------
 545     OAccessibleContextWrapper::OAccessibleContextWrapper( const Reference< XMultiServiceFactory >& _rxORB,
 546             const Reference< XAccessibleContext >& _rxInnerAccessibleContext, const Reference< XAccessible >& _rxOwningAccessible,
 547             const Reference< XAccessible >& _rxParentAccessible )
 548         :OAccessibleContextWrapper_CBase( m_aMutex )
 549         ,OAccessibleContextWrapperHelper( _rxORB, rBHelper, _rxInnerAccessibleContext, _rxOwningAccessible, _rxParentAccessible )
 550         ,m_nNotifierClient( 0 )
 551     {
 552         aggregateProxy( m_refCount, *this );
 553     }
 554
 555     //--------------------------------------------------------------------
 556     OAccessibleContextWrapper::~OAccessibleContextWrapper()
 557     {
 558     }
 559
 560     //--------------------------------------------------------------------
 561     sal_Int32 SAL_CALL OAccessibleContextWrapper::getAccessibleChildCount(  ) throw (RuntimeException)
 562     {
 563         return OAccessibleContextWrapperHelper::getAccessibleChildCount();
 564     }
 565
 566     //--------------------------------------------------------------------
 567     Reference< XAccessible > SAL_CALL OAccessibleContextWrapper::getAccessibleChild( sal_Int32 i ) throw (IndexOutOfBoundsException, RuntimeException)
 568     {
 569         return OAccessibleContextWrapperHelper::getAccessibleChild( i );
 570     }
 571
 572     //--------------------------------------------------------------------
 573     Reference< XAccessible > SAL_CALL OAccessibleContextWrapper::getAccessibleParent(  ) throw (RuntimeException)
 574     {
 575         return m_xParentAccessible;
 576     }
 577
 578     //--------------------------------------------------------------------
 579     sal_Int32 SAL_CALL OAccessibleContextWrapper::getAccessibleIndexInParent(  ) throw (RuntimeException)
 580     {
 581         return m_xInnerContext->getAccessibleIndexInParent();
 582     }
 583
 584     //--------------------------------------------------------------------
 585     sal_Int16 SAL_CALL OAccessibleContextWrapper::getAccessibleRole(  ) throw (RuntimeException)
 586     {
 587         return m_xInnerContext->getAccessibleRole();
 588     }
 589
 590     //--------------------------------------------------------------------
 591     ::rtl::OUString SAL_CALL OAccessibleContextWrapper::getAccessibleDescription(  ) throw (RuntimeException)
 592     {
 593         return m_xInnerContext->getAccessibleDescription();
 594     }
 595
 596     //--------------------------------------------------------------------
 597     ::rtl::OUString SAL_CALL OAccessibleContextWrapper::getAccessibleName(  ) throw (RuntimeException)
 598     {
 599         return m_xInnerContext->getAccessibleName();
 600     }
 601
 602     //--------------------------------------------------------------------
 603     Reference< XAccessibleRelationSet > SAL_CALL OAccessibleContextWrapper::getAccessibleRelationSet(  ) throw (RuntimeException)
 604     {
 605         return OAccessibleContextWrapperHelper::getAccessibleRelationSet();
 606     }
 607
 608     //--------------------------------------------------------------------
 609     Reference< XAccessibleStateSet > SAL_CALL OAccessibleContextWrapper::getAccessibleStateSet(  ) throw (RuntimeException)
 610     {
 611         return m_xInnerContext->getAccessibleStateSet();
 612     }
 613
 614     //--------------------------------------------------------------------
 615     Locale SAL_CALL OAccessibleContextWrapper::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 616     {
 617         return m_xInnerContext->getLocale();
 618     }
 619
 620     //--------------------------------------------------------------------
 621     void OAccessibleContextWrapper::notifyTranslatedEvent( const AccessibleEventObject& _rEvent ) throw (RuntimeException)
 622     {
 623         if ( m_nNotifierClient )
 624             AccessibleEventNotifier::addEvent( m_nNotifierClient, _rEvent );
 625     }
 626
 627     //--------------------------------------------------------------------
 628     void SAL_CALL OAccessibleContextWrapper::addEventListener( const Reference< XAccessibleEventListener >& _rxListener ) throw (RuntimeException)
 629     {
 630         ::osl::MutexGuard aGuard( m_aMutex );
 631         if ( !m_nNotifierClient )
 632             m_nNotifierClient = AccessibleEventNotifier::registerClient( );
 633         AccessibleEventNotifier::addEventListener( m_nNotifierClient, _rxListener );
 634     }
 635
 636     //--------------------------------------------------------------------
 637     void SAL_CALL OAccessibleContextWrapper::removeEventListener( const Reference< XAccessibleEventListener >& _rxListener ) throw (RuntimeException)
 638     {
 639         ::osl::MutexGuard aGuard( m_aMutex );
 640         if ( m_nNotifierClient )
 641         {
 642             if ( 0 == AccessibleEventNotifier::removeEventListener( m_nNotifierClient, _rxListener ) )
 643             {
 644                 AccessibleEventNotifier::TClientId nId( m_nNotifierClient );
 645                 m_nNotifierClient = 0;
 646                 AccessibleEventNotifier::revokeClient( nId );
 647             }
 648         }
 649     }
 650
 651     //--------------------------------------------------------------------
 652     void SAL_CALL OAccessibleContextWrapper::disposing()  throw (RuntimeException)
 653     {
 654         AccessibleEventNotifier::TClientId nClientId( 0 );
 655
 656         // --- <mutex lock> -----------------------------------------
 657         {
 658             ::osl::MutexGuard aGuard( m_aMutex );
 659
 660             // prepare notifying our AccessibleListeners
 661             if ( m_nNotifierClient )
 662             {
 663                 nClientId = m_nNotifierClient;
 664                 m_nNotifierClient = 0;
 665             }
 666         }
 667         // --- </mutex lock> -----------------------------------------
 668
 669         // let the base class do
 670         OAccessibleContextWrapperHelper::dispose();
 671
 672         // notify the disposal
 673         if ( nClientId )
 674             AccessibleEventNotifier::revokeClientNotifyDisposing( nClientId, *this );
 675     }
 676
 677     //--------------------------------------------------------------------
 678     void SAL_CALL OAccessibleContextWrapper::dispose() throw( RuntimeException )
 679     {
 680         // simply disambiguate
 681         OComponentProxyAggregation_CBase::dispose();
 682     }
 683
 684 //.............................................................................
 685 }       // namespace accessibility
 686 //.............................................................................