comphelper/source/misc/instancelocker.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
  21 #include "comphelper_module.hxx"
  22 #include "comphelper_services.hxx"
  23 #include <cppuhelper/supportsservice.hxx>
  24
  25 #include <com/sun/star/util/XCloseBroadcaster.hpp>
  26 #include <com/sun/star/util/XCloseable.hpp>
  27 #include <com/sun/star/lang/DisposedException.hpp>
  28 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  29 #include <com/sun/star/frame/XDesktop.hpp>
  30 #include <com/sun/star/frame/DoubleInitializationException.hpp>
  31 #include <com/sun/star/beans/XPropertySet.hpp>
  32
  33 #include "instancelocker.hxx"
  34
  35 using namespace ::com::sun::star;
  36
  37
  38
  39 // OInstanceLocker
  40
  41
  42
  43 OInstanceLocker::OInstanceLocker( const uno::Reference< uno::XComponentContext >& xContext )
  44 : m_xContext( xContext )
  45 , m_pLockListener( NULL )
  46 , m_pListenersContainer( NULL )
  47 , m_bDisposed( false )
  48 , m_bInitialized( false )
  49 {
  50 }
  51
  52
  53 OInstanceLocker::~OInstanceLocker()
  54 {
  55     if ( !m_bDisposed )
  56     {
  57         m_refCount++; // to call dispose
  58         try {
  59             dispose();
  60         }
  61         catch ( uno::RuntimeException& )
  62         {}
  63     }
  64
  65     if ( m_pListenersContainer )
  66     {
  67         delete m_pListenersContainer;
  68         m_pListenersContainer = NULL;
  69     }
  70 }
  71
  72 // XComponent
  73
  74 void SAL_CALL OInstanceLocker::dispose()
  75     throw (uno::RuntimeException, std::exception)
  76 {
  77     ::osl::MutexGuard aGuard( m_aMutex );
  78
  79     if ( m_bDisposed )
  80         throw lang::DisposedException();
  81
  82        lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >(this) );
  83     if ( m_pListenersContainer )
  84         m_pListenersContainer->disposeAndClear( aSource );
  85
  86     if ( m_xLockListener.is() )
  87     {
  88         if ( m_pLockListener )
  89         {
  90             m_pLockListener->Dispose();
  91             m_pLockListener = NULL;
  92         }
  93         m_xLockListener = uno::Reference< uno::XInterface >();
  94     }
  95
  96     m_bDisposed = true;
  97 }
  98
  99
 100 void SAL_CALL OInstanceLocker::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 101     throw (uno::RuntimeException, std::exception)
 102 {
 103     ::osl::MutexGuard aGuard( m_aMutex );
 104     if ( m_bDisposed )
 105         throw lang::DisposedException(); // TODO
 106
 107     if ( !m_pListenersContainer )
 108         m_pListenersContainer = new ::cppu::OInterfaceContainerHelper( m_aMutex );
 109
 110     m_pListenersContainer->addInterface( xListener );
 111 }
 112
 113
 114 void SAL_CALL OInstanceLocker::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
 115     throw (uno::RuntimeException, std::exception)
 116 {
 117     ::osl::MutexGuard aGuard( m_aMutex );
 118     if ( m_pListenersContainer )
 119         m_pListenersContainer->removeInterface( xListener );
 120 }
 121
 122 // XInitialization
 123
 124 void SAL_CALL OInstanceLocker::initialize( const uno::Sequence< uno::Any >& aArguments )
 125     throw (uno::Exception, uno::RuntimeException, std::exception)
 126 {
 127     ::osl::MutexGuard aGuard( m_aMutex );
 128     if ( m_bInitialized )
 129         throw frame::DoubleInitializationException();
 130
 131     if ( m_bDisposed )
 132         throw lang::DisposedException(); // TODO
 133
 134     if ( !m_refCount )
 135         throw uno::RuntimeException(); // the object must be refcounted already!
 136
 137     uno::Reference< uno::XInterface > xInstance;
 138     uno::Reference< embed::XActionsApproval > xApproval;
 139     sal_Int32 nModes = 0;
 140
 141     try
 142     {
 143         sal_Int32 nLen = aArguments.getLength();
 144         if ( nLen < 2 || nLen > 3 )
 145             throw lang::IllegalArgumentException(
 146                             OUString( "Wrong count of parameters!" ),
 147                             uno::Reference< uno::XInterface >(),
 148                             0 );
 149
 150         if ( !( aArguments[0] >>= xInstance ) || !xInstance.is() )
 151             throw lang::IllegalArgumentException(
 152                     OUString( "Nonempty reference is expected as the first argument!" ),
 153                     uno::Reference< uno::XInterface >(),
 154                     0 );
 155
 156         if (
 157             !( aArguments[1] >>= nModes ) ||
 158             (
 159               !( nModes & embed::Actions::PREVENT_CLOSE ) &&
 160               !( nModes & embed::Actions::PREVENT_TERMINATION )
 161             )
 162            )
 163         {
 164             throw lang::IllegalArgumentException(
 165                     OUString("The correct modes set is expected as the second argument!"),
 166                     uno::Reference< uno::XInterface >(),
 167                     0 );
 168         }
 169
 170         if ( nLen == 3 && !( aArguments[2] >>= xApproval ) )
 171             throw lang::IllegalArgumentException(
 172                     OUString( "If the third argument is provided, it must be XActionsApproval implementation!" ),
 173                     uno::Reference< uno::XInterface >(),
 174                     0 );
 175
 176         m_pLockListener = new OLockListener( uno::Reference< lang::XComponent > ( static_cast< lang::XComponent* >( this ) ),
 177                                             xInstance,
 178                                             nModes,
 179                                             xApproval );
 180         m_xLockListener = uno::Reference< uno::XInterface >( static_cast< OWeakObject* >( m_pLockListener ) );
 181         m_pLockListener->Init();
 182     }
 183     catch( uno::Exception& )
 184     {
 185         dispose();
 186         throw;
 187     }
 188
 189     m_bInitialized = true;
 190 }
 191
 192 // XServiceInfo
 193 OUString SAL_CALL OInstanceLocker::getImplementationName(  )
 194     throw (uno::RuntimeException, std::exception)
 195 {
 196     return getImplementationName_static();
 197 }
 198
 199 sal_Bool SAL_CALL OInstanceLocker::supportsService( const OUString& ServiceName )
 200     throw (uno::RuntimeException, std::exception)
 201 {
 202     return cppu::supportsService(this, ServiceName);
 203 }
 204
 205 uno::Sequence< OUString > SAL_CALL OInstanceLocker::getSupportedServiceNames()
 206     throw (uno::RuntimeException, std::exception)
 207 {
 208     return getSupportedServiceNames_static();
 209 }
 210
 211 // Static methods
 212
 213 uno::Sequence< OUString > SAL_CALL OInstanceLocker::getSupportedServiceNames_static()
 214 {
 215     const OUString aServiceName( "com.sun.star.embed.InstanceLocker" );
 216     return uno::Sequence< OUString >( &aServiceName, 1 );
 217 }
 218
 219
 220 OUString SAL_CALL OInstanceLocker::getImplementationName_static()
 221 {
 222     return OUString( "com.sun.star.comp.embed.InstanceLocker" );
 223 }
 224
 225
 226 uno::Reference< uno::XInterface > SAL_CALL OInstanceLocker::Create(
 227                                 const uno::Reference< uno::XComponentContext >& rxContext )
 228 {
 229     return static_cast< cppu::OWeakObject * >( new OInstanceLocker( rxContext ) );
 230 }
 231
 232
 233
 234
 235 // OLockListener
 236
 237
 238
 239 OLockListener::OLockListener( const uno::WeakReference< lang::XComponent >& xWrapper,
 240                     const uno::Reference< uno::XInterface >& xInstance,
 241                     sal_Int32 nMode,
 242                     const uno::Reference< embed::XActionsApproval >& rApproval )
 243 : m_xInstance( xInstance )
 244 , m_xApproval( rApproval )
 245 , m_xWrapper( xWrapper )
 246 , m_bDisposed( false )
 247 , m_bInitialized( false )
 248 , m_nMode( nMode )
 249 {
 250 }
 251
 252
 253 OLockListener::~OLockListener()
 254 {
 255 }
 256
 257
 258 void OLockListener::Dispose()
 259 {
 260     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 261
 262     if ( m_bDisposed )
 263         return;
 264
 265     if ( m_nMode & embed::Actions::PREVENT_CLOSE )
 266     {
 267         try
 268         {
 269             uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xInstance, uno::UNO_QUERY );
 270             if ( xCloseBroadcaster.is() )
 271                 xCloseBroadcaster->removeCloseListener( static_cast< util::XCloseListener* >( this ) );
 272
 273             uno::Reference< util::XCloseable > xCloseable( m_xInstance, uno::UNO_QUERY );
 274             if ( xCloseable.is() )
 275                 xCloseable->close( sal_True );
 276         }
 277         catch( uno::Exception& )
 278         {}
 279     }
 280
 281     if ( m_nMode & embed::Actions::PREVENT_TERMINATION )
 282     {
 283         try
 284         {
 285             uno::Reference< frame::XDesktop > xDesktop( m_xInstance, uno::UNO_QUERY_THROW );
 286             xDesktop->removeTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
 287         }
 288         catch( uno::Exception& )
 289         {}
 290     }
 291
 292     m_xInstance = uno::Reference< uno::XInterface >();
 293     m_bDisposed = true;
 294 }
 295
 296 // XEventListener
 297
 298 void SAL_CALL OLockListener::disposing( const lang::EventObject& aEvent )
 299     throw (uno::RuntimeException, std::exception)
 300 {
 301     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 302
 303     // object is disposed
 304     if ( aEvent.Source == m_xInstance )
 305     {
 306         // the object does not listen for anything any more
 307         m_nMode = 0;
 308
 309         // dispose the wrapper;
 310         uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
 311         aGuard.clear();
 312         if ( xComponent.is() )
 313         {
 314             try { xComponent->dispose(); }
 315             catch( uno::Exception& ){}
 316         }
 317     }
 318 }
 319
 320
 321 // XCloseListener
 322
 323 void SAL_CALL OLockListener::queryClosing( const lang::EventObject& aEvent, sal_Bool )
 324     throw (util::CloseVetoException, uno::RuntimeException, std::exception)
 325 {
 326     // GetsOwnership parameter is always ignored, the user of the service must close the object always
 327     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 328     if ( !m_bDisposed && aEvent.Source == m_xInstance && ( m_nMode & embed::Actions::PREVENT_CLOSE ) )
 329     {
 330         try
 331         {
 332             uno::Reference< embed::XActionsApproval > xApprove = m_xApproval;
 333
 334             // unlock the mutex here
 335             aGuard.clear();
 336
 337             if ( xApprove.is() && xApprove->approveAction( embed::Actions::PREVENT_CLOSE ) )
 338                 throw util::CloseVetoException();
 339         }
 340         catch( util::CloseVetoException& )
 341         {
 342             // rethrow this exception
 343             throw;
 344         }
 345         catch( uno::Exception& )
 346         {
 347             // no action should be done
 348         }
 349     }
 350 }
 351
 352
 353 void SAL_CALL OLockListener::notifyClosing( const lang::EventObject& aEvent )
 354     throw (uno::RuntimeException, std::exception)
 355 {
 356     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 357
 358     // object is closed, no reason to listen
 359     if ( aEvent.Source == m_xInstance )
 360     {
 361         uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( aEvent.Source, uno::UNO_QUERY );
 362         if ( xCloseBroadcaster.is() )
 363         {
 364             xCloseBroadcaster->removeCloseListener( static_cast< util::XCloseListener* >( this ) );
 365             m_nMode &= ~embed::Actions::PREVENT_CLOSE;
 366             if ( !m_nMode )
 367             {
 368                 // dispose the wrapper;
 369                 uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
 370                 aGuard.clear();
 371                 if ( xComponent.is() )
 372                 {
 373                     try { xComponent->dispose(); }
 374                     catch( uno::Exception& ){}
 375                 }
 376             }
 377         }
 378     }
 379 }
 380
 381
 382 // XTerminateListener
 383
 384 void SAL_CALL OLockListener::queryTermination( const lang::EventObject& aEvent )
 385     throw (frame::TerminationVetoException, uno::RuntimeException, std::exception)
 386 {
 387     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 388     if ( aEvent.Source == m_xInstance && ( m_nMode & embed::Actions::PREVENT_TERMINATION ) )
 389     {
 390         try
 391         {
 392             uno::Reference< embed::XActionsApproval > xApprove = m_xApproval;
 393
 394             // unlock the mutex here
 395             aGuard.clear();
 396
 397             if ( xApprove.is() && xApprove->approveAction( embed::Actions::PREVENT_TERMINATION ) )
 398                 throw frame::TerminationVetoException();
 399         }
 400         catch( frame::TerminationVetoException& )
 401         {
 402             // rethrow this exception
 403             throw;
 404         }
 405         catch( uno::Exception& )
 406         {
 407             // no action should be done
 408         }
 409     }
 410 }
 411
 412
 413 void SAL_CALL OLockListener::notifyTermination( const lang::EventObject& aEvent )
 414     throw (uno::RuntimeException, std::exception)
 415 {
 416     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 417
 418     // object is terminated, no reason to listen
 419     if ( aEvent.Source == m_xInstance )
 420     {
 421         uno::Reference< frame::XDesktop > xDesktop( aEvent.Source, uno::UNO_QUERY );
 422         if ( xDesktop.is() )
 423         {
 424             try
 425             {
 426                 xDesktop->removeTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
 427                 m_nMode &= ~embed::Actions::PREVENT_TERMINATION;
 428                 if ( !m_nMode )
 429                 {
 430                     // dispose the wrapper;
 431                     uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
 432                     aGuard.clear();
 433                     if ( xComponent.is() )
 434                     {
 435                         try { xComponent->dispose(); }
 436                         catch( uno::Exception& ){}
 437                     }
 438                 }
 439             }
 440             catch( uno::Exception& )
 441             {}
 442         }
 443     }
 444 }
 445
 446
 447 // XInitialization
 448
 449 bool OLockListener::Init()
 450 {
 451     ::osl::ResettableMutexGuard aGuard( m_aMutex );
 452
 453     if ( m_bDisposed || m_bInitialized )
 454         return false;
 455
 456     try
 457     {
 458         if ( m_nMode & embed::Actions::PREVENT_CLOSE )
 459         {
 460             uno::Reference< util::XCloseBroadcaster > xCloseBroadcaster( m_xInstance, uno::UNO_QUERY_THROW );
 461             xCloseBroadcaster->addCloseListener( static_cast< util::XCloseListener* >( this ) );
 462         }
 463
 464         if ( m_nMode & embed::Actions::PREVENT_TERMINATION )
 465         {
 466             uno::Reference< frame::XDesktop > xDesktop( m_xInstance, uno::UNO_QUERY_THROW );
 467             xDesktop->addTerminateListener( static_cast< frame::XTerminateListener* >( this ) );
 468         }
 469     }
 470     catch( uno::Exception& )
 471     {
 472         // dispose the wrapper;
 473         uno::Reference< lang::XComponent > xComponent( m_xWrapper.get(), uno::UNO_QUERY );
 474         aGuard.clear();
 475         if ( xComponent.is() )
 476         {
 477             try { xComponent->dispose(); }
 478             catch( uno::Exception& ){}
 479         }
 480
 481         throw;
 482     }
 483
 484     m_bInitialized = true;
 485
 486     return true;
 487 }
 488
 489 void createRegistryInfo_OInstanceLocker()
 490 {
 491     static ::comphelper::module::OAutoRegistration< OInstanceLocker > aAutoRegistration;
 492 }
 493
 494 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */