comphelper/source/misc/accessiblecontexthelper.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: accessiblecontexthelper.cxx,v $
  10  * $Revision: 1.16 $
  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/accessiblecontexthelper.hxx>
  34 #include <comphelper/accessibleeventbuffer.hxx>
  35 #include <osl/diagnose.h>
  36 #include <cppuhelper/weakref.hxx>
  37 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
  38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
  39 #include <comphelper/accessibleeventnotifier.hxx>
  40
  41 //.........................................................................
  42 namespace comphelper
  43 {
  44 //.........................................................................
  45
  46     using namespace ::com::sun::star::uno;
  47     using namespace ::com::sun::star::lang;
  48     using namespace ::com::sun::star::accessibility;
  49
  50     //=====================================================================
  51     //= OContextHelper_Impl
  52     //=====================================================================
  53     /** implementation class for OAccessibleContextHelper. No own thread safety!
  54     */
  55     class OContextHelper_Impl
  56     {
  57     private:
  58         OAccessibleContextHelper*                       m_pAntiImpl;            // the owning instance
  59         IMutex*                                                         m_pExternalLock;        // the optional additional external lock
  60
  61         ::cppu::OInterfaceContainerHelper*      m_pEventListeners;
  62         WeakReference< XAccessible >            m_aCreator;                     // the XAccessible which created our XAccessibleContext
  63
  64         AccessibleEventNotifier::TClientId      m_nClientId;
  65
  66     public:
  67         inline  Reference< XAccessible >        getCreator( ) const                                     { return m_aCreator; }
  68         inline  void                                            setCreator( const Reference< XAccessible >& _rAcc );
  69
  70         inline  IMutex*                                         getExternalLock( )                                      { return m_pExternalLock; }
  71         inline  void                                            setExternalLock( IMutex* _pLock )       { m_pExternalLock = _pLock; }
  72
  73         inline  AccessibleEventNotifier::TClientId
  74                                             getClientId() const                                 { return m_nClientId; }
  75         inline  void                                            setClientId( const AccessibleEventNotifier::TClientId _nId )
  76                                                                                 { m_nClientId = _nId; }
  77
  78     public:
  79         OContextHelper_Impl( OAccessibleContextHelper* _pAntiImpl )
  80             :m_pAntiImpl( _pAntiImpl )
  81             ,m_pExternalLock( NULL )
  82             ,m_pEventListeners( NULL )
  83             ,m_nClientId( 0 )
  84         {
  85         }
  86     };
  87
  88     //---------------------------------------------------------------------
  89     inline      void OContextHelper_Impl::setCreator( const Reference< XAccessible >& _rAcc )
  90     {
  91         m_aCreator = _rAcc;
  92     }
  93
  94     //=====================================================================
  95     //= OAccessibleContextHelper
  96     //=====================================================================
  97     //---------------------------------------------------------------------
  98     OAccessibleContextHelper::OAccessibleContextHelper( )
  99         :OAccessibleContextHelper_Base( GetMutex() )
 100         ,m_pImpl( NULL )
 101     {
 102         m_pImpl = new OContextHelper_Impl( this );
 103     }
 104
 105     //---------------------------------------------------------------------
 106     OAccessibleContextHelper::OAccessibleContextHelper( IMutex* _pExternalLock )
 107         :OAccessibleContextHelper_Base( GetMutex() )
 108         ,m_pImpl( NULL )
 109     {
 110         m_pImpl = new OContextHelper_Impl( this );
 111         m_pImpl->setExternalLock( _pExternalLock );
 112     }
 113
 114     //---------------------------------------------------------------------
 115     void OAccessibleContextHelper::forgetExternalLock()
 116     {
 117         m_pImpl->setExternalLock( NULL );
 118     }
 119
 120     //---------------------------------------------------------------------
 121     OAccessibleContextHelper::~OAccessibleContextHelper( )
 122     {
 123         forgetExternalLock();
 124             // this ensures that the lock, which may be already destroyed as part of the derivee,
 125             // is not used anymore
 126
 127         ensureDisposed();
 128
 129         delete m_pImpl;
 130         m_pImpl = NULL;
 131     }
 132
 133     //---------------------------------------------------------------------
 134     IMutex* OAccessibleContextHelper::getExternalLock( )
 135     {
 136         return m_pImpl->getExternalLock();
 137     }
 138
 139     //---------------------------------------------------------------------
 140     void SAL_CALL OAccessibleContextHelper::disposing()
 141     {
 142         ::osl::ClearableMutexGuard aGuard( GetMutex() );
 143
 144         if ( m_pImpl->getClientId( ) )
 145         {
 146             AccessibleEventNotifier::revokeClientNotifyDisposing( m_pImpl->getClientId( ), *this );
 147             m_pImpl->setClientId( 0 );
 148         }
 149     }
 150
 151     //---------------------------------------------------------------------
 152     void SAL_CALL OAccessibleContextHelper::addEventListener( const Reference< XAccessibleEventListener >& _rxListener ) throw (RuntimeException)
 153     {
 154         OMutexGuard aGuard( getExternalLock() );
 155             // don't use the OContextEntryGuard - it will throw an exception if we're not alive
 156             // anymore, while the most recent specification for XComponent states that we should
 157             // silently ignore the call in such a situation
 158         if ( !isAlive() )
 159         {
 160             if ( _rxListener.is() )
 161                 _rxListener->disposing( EventObject( *this ) );
 162             return;
 163         }
 164
 165         if ( _rxListener.is() )
 166         {
 167             if ( !m_pImpl->getClientId( ) )
 168                 m_pImpl->setClientId( AccessibleEventNotifier::registerClient( ) );
 169
 170             AccessibleEventNotifier::addEventListener( m_pImpl->getClientId( ), _rxListener );
 171         }
 172     }
 173
 174     //---------------------------------------------------------------------
 175     void SAL_CALL OAccessibleContextHelper::removeEventListener( const Reference< XAccessibleEventListener >& _rxListener ) throw (RuntimeException)
 176     {
 177         OMutexGuard aGuard( getExternalLock() );
 178             // don't use the OContextEntryGuard - it will throw an exception if we're not alive
 179             // anymore, while the most recent specification for XComponent states that we should
 180             // silently ignore the call in such a situation
 181         if ( !isAlive() )
 182             return;
 183
 184         if ( _rxListener.is() )
 185         {
 186             sal_Int32 nListenerCount = AccessibleEventNotifier::removeEventListener( m_pImpl->getClientId( ), _rxListener );
 187             if ( !nListenerCount )
 188             {
 189                 // no listeners anymore
 190                 // -> revoke ourself. This may lead to the notifier thread dying (if we were the last client),
 191                 // and at least to us not firing any events anymore, in case somebody calls
 192                 // NotifyAccessibleEvent, again
 193                 AccessibleEventNotifier::revokeClient( m_pImpl->getClientId( ) );
 194                 m_pImpl->setClientId( 0 );
 195             }
 196         }
 197     }
 198
 199     //---------------------------------------------------------------------
 200     void SAL_CALL OAccessibleContextHelper::NotifyAccessibleEvent( const sal_Int16 _nEventId,
 201         const Any& _rOldValue, const Any& _rNewValue )
 202     {
 203         if ( !m_pImpl->getClientId( ) )
 204             // if we don't have a client id for the notifier, then we don't have listeners, then
 205             // we don't need to notify anything
 206             return;
 207
 208         // build an event object
 209         AccessibleEventObject aEvent;
 210         aEvent.Source = *this;
 211         aEvent.EventId = _nEventId;
 212         aEvent.OldValue = _rOldValue;
 213         aEvent.NewValue = _rNewValue;
 214
 215         // let the notifier handle this event
 216         AccessibleEventNotifier::addEvent( m_pImpl->getClientId( ), aEvent );
 217     }
 218
 219     //---------------------------------------------------------------------
 220     void SAL_CALL OAccessibleContextHelper::BufferAccessibleEvent( const sal_Int16 _nEventId,
 221         const Any& _rOldValue, const Any& _rNewValue,
 222         AccessibleEventBuffer & _rBuffer )
 223     {
 224         // TODO: this whole method (as well as the class AccessibleEventBuffer) should be removed
 225         // The reasons why they have been introduces id that we needed to collect a set of events
 226         // before notifying them alltogether (after releasing our mutex). With the other
 227         // NotifyAccessibleEvent being asynchronous now, this should not be necessary anymore
 228         // - clients could use the other version now.
 229
 230         // copy our current listeners
 231         Sequence< Reference< XInterface > > aListeners;
 232         if ( m_pImpl->getClientId( ) )
 233             aListeners = AccessibleEventNotifier::getEventListeners( m_pImpl->getClientId( ) );
 234
 235         if ( aListeners.getLength() )
 236         {
 237             AccessibleEventObject aEvent;
 238             aEvent.Source = *this;
 239             OSL_ENSURE( aEvent.Source.is(), "OAccessibleContextHelper::BufferAccessibleEvent: invalid creator!" );
 240             aEvent.EventId = _nEventId;
 241             aEvent.OldValue = _rOldValue;
 242             aEvent.NewValue = _rNewValue;
 243
 244             _rBuffer.addEvent( aEvent, aListeners );
 245         }
 246     }
 247
 248     //---------------------------------------------------------------------
 249     sal_Bool OAccessibleContextHelper::isAlive() const
 250     {
 251         return !GetBroadcastHelper().bDisposed && !GetBroadcastHelper().bInDispose;
 252     }
 253
 254     //---------------------------------------------------------------------
 255     void OAccessibleContextHelper::ensureAlive() const SAL_THROW( ( DisposedException ) )
 256     {
 257         if( !isAlive() )
 258             throw DisposedException();
 259     }
 260
 261     //---------------------------------------------------------------------
 262     void OAccessibleContextHelper::ensureDisposed( )
 263     {
 264         if ( !GetBroadcastHelper().bDisposed )
 265         {
 266             OSL_ENSURE( 0 == m_refCount, "OAccessibleContextHelper::ensureDisposed: this method _has_ to be called from without your dtor only!" );
 267             acquire();
 268             dispose();
 269         }
 270     }
 271
 272     //---------------------------------------------------------------------
 273     void OAccessibleContextHelper::lateInit( const Reference< XAccessible >& _rxAccessible )
 274     {
 275         m_pImpl->setCreator( _rxAccessible );
 276     }
 277
 278     //---------------------------------------------------------------------
 279     Reference< XAccessible > OAccessibleContextHelper::getAccessibleCreator( ) const
 280     {
 281         return m_pImpl->getCreator();
 282     }
 283
 284     //---------------------------------------------------------------------
 285     sal_Int32 SAL_CALL OAccessibleContextHelper::getAccessibleIndexInParent(  ) throw (RuntimeException)
 286     {
 287         OExternalLockGuard aGuard( this );
 288
 289         // -1 for child not found/no parent (according to specification)
 290         sal_Int32 nRet = -1;
 291
 292         try
 293         {
 294
 295             Reference< XAccessibleContext > xParentContext( implGetParentContext() );
 296
 297             //  iterate over parent's children and search for this object
 298             if ( xParentContext.is() )
 299             {
 300                 // our own XAccessible for comparing with the children of our parent
 301                 Reference< XAccessible > xCreator( m_pImpl->getCreator() );
 302
 303                 OSL_ENSURE( xCreator.is(), "OAccessibleContextHelper::getAccessibleIndexInParent: invalid creator!" );
 304                     // two ideas why this could be NULL:
 305                     // * nobody called our late ctor (init), so we never had a creator at all -> bad
 306                     // * the creator is already dead. In this case, we should have been disposed, and
 307                     //   never survived the above OContextEntryGuard.
 308                     // in all other situations the creator should be non-NULL
 309
 310                 if ( xCreator.is() )
 311                 {
 312                     sal_Int32 nChildCount = xParentContext->getAccessibleChildCount();
 313                     for ( sal_Int32 nChild = 0; ( nChild < nChildCount ) && ( -1 == nRet ); ++nChild )
 314                     {
 315                         Reference< XAccessible > xChild( xParentContext->getAccessibleChild( nChild ) );
 316                         if ( xChild.get() == xCreator.get() )
 317                             nRet = nChild;
 318                     }
 319                 }
 320             }
 321         }
 322         catch( const Exception& )
 323         {
 324             OSL_ENSURE( sal_False, "OAccessibleContextHelper::getAccessibleIndexInParent: caught an exception!" );
 325         }
 326
 327         return nRet;
 328     }
 329
 330     //---------------------------------------------------------------------
 331     Locale SAL_CALL OAccessibleContextHelper::getLocale(  ) throw (IllegalAccessibleComponentStateException, RuntimeException)
 332     {
 333         // simply ask the parent
 334         Reference< XAccessible > xParent = getAccessibleParent();
 335         Reference< XAccessibleContext > xParentContext;
 336         if ( xParent.is() )
 337             xParentContext = xParent->getAccessibleContext();
 338
 339         if ( !xParentContext.is() )
 340             throw IllegalAccessibleComponentStateException( ::rtl::OUString(), *this );
 341
 342         return xParentContext->getLocale();
 343     }
 344
 345     //---------------------------------------------------------------------
 346     Reference< XAccessibleContext > OAccessibleContextHelper::implGetParentContext() SAL_THROW( ( RuntimeException ) )
 347     {
 348         Reference< XAccessible > xParent = getAccessibleParent();
 349         Reference< XAccessibleContext > xParentContext;
 350         if ( xParent.is() )
 351             xParentContext = xParent->getAccessibleContext();
 352         return xParentContext;
 353     }
 354
 355 //.........................................................................
 356 }       // namespace comphelper
 357 //.........................................................................
 358
 359