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