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