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