extensions/source/bibliography/loadlisteneradapter.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 "loadlisteneradapter.hxx"
  21 #include <osl/diagnose.h>
  22 #include <rtl/ref.hxx>
  23
  24
  25 namespace bib
  26 {
  27
  28
  29     using namespace ::com::sun::star::uno;
  30     using namespace ::com::sun::star::lang;
  31     using namespace ::com::sun::star::form;
  32
  33     OComponentListener::~OComponentListener()
  34     {
  35         {
  36             ::osl::MutexGuard aGuard( m_rMutex );
  37             if ( m_pAdapter )
  38                 m_pAdapter->dispose();
  39         }
  40     }
  41
  42
  43     void OComponentListener::setAdapter( OComponentAdapterBase* pAdapter )
  44     {
  45         {
  46             ::osl::MutexGuard aGuard( m_rMutex );
  47             if ( m_pAdapter )
  48             {
  49                 m_pAdapter->release();
  50                 m_pAdapter = NULL;
  51             }
  52         }
  53
  54         if ( pAdapter )
  55         {
  56             ::osl::MutexGuard aGuard( m_rMutex );
  57             m_pAdapter = pAdapter;
  58             m_pAdapter->acquire();
  59         }
  60     }
  61
  62     OComponentAdapterBase::OComponentAdapterBase( const Reference< XComponent >& _rxComp, bool _bAutoRelease )
  63         :m_xComponent( _rxComp )
  64         ,m_pListener( NULL )
  65         ,m_nLockCount( 0 )
  66         ,m_bListening( false )
  67         ,m_bAutoRelease( _bAutoRelease )
  68     {
  69         OSL_ENSURE( m_xComponent.is(), "OComponentAdapterBase::OComponentAdapterBase: invalid component!" );
  70     }
  71
  72
  73     void OComponentAdapterBase::Init( OComponentListener* _pListener )
  74     {
  75         OSL_ENSURE( !m_pListener, "OComponentAdapterBase::Init: already initialized!" );
  76         OSL_ENSURE( _pListener, "OComponentAdapterBase::Init: invalid listener!" );
  77
  78         m_pListener = _pListener;
  79         if ( m_pListener )
  80             m_pListener->setAdapter( this );
  81
  82         startComponentListening( );
  83         m_bListening = true;
  84     }
  85
  86
  87     OComponentAdapterBase::~OComponentAdapterBase()
  88     {
  89     }
  90
  91
  92     void OComponentAdapterBase::dispose()
  93     {
  94         if ( m_bListening )
  95         {
  96             ::rtl::Reference< OComponentAdapterBase > xPreventDelete(this);
  97
  98             disposing();
  99
 100             m_pListener->setAdapter(NULL);
 101
 102             m_pListener = NULL;
 103             m_bListening = false;
 104
 105             if (m_bAutoRelease)
 106                 m_xComponent = NULL;
 107         }
 108     }
 109
 110     // XEventListener
 111
 112
 113     void SAL_CALL OComponentAdapterBase::disposing( const EventObject& ) throw( RuntimeException, std::exception )
 114     {
 115         if ( m_pListener )
 116         {
 117             // disconnect the listener
 118             if ( m_pListener )  // may have been reset whilest calling into _disposing
 119                 m_pListener->setAdapter( NULL );
 120         }
 121
 122         m_pListener = NULL;
 123         m_bListening = false;
 124
 125         if ( m_bAutoRelease )
 126             m_xComponent = NULL;
 127     }
 128
 129     OLoadListenerAdapter::OLoadListenerAdapter( const Reference< XLoadable >& _rxLoadable, bool _bAutoRelease )
 130         :OComponentAdapterBase( Reference< XComponent >( _rxLoadable, UNO_QUERY ), _bAutoRelease )
 131     {
 132     }
 133
 134
 135     void OLoadListenerAdapter::startComponentListening()
 136     {
 137         Reference< XLoadable > xLoadable( getComponent(), UNO_QUERY );
 138         OSL_ENSURE( xLoadable.is(), "OLoadListenerAdapter::OLoadListenerAdapter: invalid object!" );
 139         if ( xLoadable.is() )
 140             xLoadable->addLoadListener( this );
 141     }
 142
 143
 144     void SAL_CALL OLoadListenerAdapter::acquire(  ) throw ()
 145     {
 146         OLoadListenerAdapter_Base::acquire();
 147     }
 148
 149
 150     void SAL_CALL OLoadListenerAdapter::release(  ) throw ()
 151     {
 152         OLoadListenerAdapter_Base::release();
 153     }
 154
 155
 156     void SAL_CALL OLoadListenerAdapter::disposing( const  EventObject& _rSource ) throw( RuntimeException, std::exception)
 157     {
 158         OComponentAdapterBase::disposing( _rSource );
 159     }
 160
 161
 162     void OLoadListenerAdapter::disposing()
 163     {
 164         Reference< XLoadable > xLoadable( getComponent(), UNO_QUERY );
 165         if ( xLoadable.is() )
 166             xLoadable->removeLoadListener( this );
 167     }
 168
 169
 170     void SAL_CALL OLoadListenerAdapter::loaded( const EventObject& _rEvent ) throw (RuntimeException, std::exception)
 171     {
 172         if ( !locked() && getLoadListener( ) )
 173             getLoadListener( )->_loaded( _rEvent );
 174     }
 175
 176
 177     void SAL_CALL OLoadListenerAdapter::unloading( const EventObject& _rEvent ) throw (RuntimeException, std::exception)
 178     {
 179         if ( !locked() && getLoadListener( ) )
 180             getLoadListener( )->_unloading( _rEvent );
 181     }
 182
 183
 184     void SAL_CALL OLoadListenerAdapter::unloaded( const EventObject& _rEvent ) throw (RuntimeException, std::exception)
 185     {
 186         if ( !locked() && getLoadListener( ) )
 187             getLoadListener( )->_unloaded( _rEvent );
 188     }
 189
 190
 191     void SAL_CALL OLoadListenerAdapter::reloading( const EventObject& _rEvent ) throw (RuntimeException, std::exception)
 192     {
 193         if ( !locked() && getLoadListener( ) )
 194             getLoadListener( )->_reloading( _rEvent );
 195     }
 196
 197
 198     void SAL_CALL OLoadListenerAdapter::reloaded( const EventObject& _rEvent ) throw (RuntimeException, std::exception)
 199     {
 200         if ( !locked() && getLoadListener( ) )
 201             getLoadListener( )->_reloaded( _rEvent );
 202     }
 203
 204
 205 }   // namespace bib
 206
 207
 208 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */