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_embeddedobj.hxx"
30  #include <com/sun/star/embed/EmbedUpdateModes.hpp>
31  #include <com/sun/star/embed/EmbedStates.hpp>
32  #include <com/sun/star/lang/XComponent.hpp>
33  #include <com/sun/star/lang/DisposedException.hpp>
34  
35  #include <cppuhelper/interfacecontainer.h>
36  
37  #include <oleembobj.hxx>
38  #include <olecomponent.hxx>
39  
40  #include "ownview.hxx"
41  
42  using namespace ::com::sun::star;
43  
44  sal_Bool KillFile_Impl( const ::rtl::OUString& aURL, const uno::Reference< lang::XMultiServiceFactory >& xFactory );
45  
46  
47  //------------------------------------------------------
48  OleEmbeddedObject::OleEmbeddedObject( const uno::Reference< lang::XMultiServiceFactory >& xFactory,
49  									  const uno::Sequence< sal_Int8 >& aClassID,
50  									  const ::rtl::OUString& aClassName )
51  : m_pOleComponent( NULL )
52  , m_pInterfaceContainer( NULL )
53  , m_bReadOnly( sal_False )
54  , m_bDisposed( sal_False )
55  , m_nObjectState( -1 )
56  , m_nTargetState( -1 )
57  , m_nUpdateMode ( embed::EmbedUpdateModes::ALWAYS_UPDATE )
58  , m_xFactory( xFactory )
59  , m_aClassID( aClassID )
60  , m_aClassName( aClassName )
61  , m_bWaitSaveCompleted( sal_False )
62  , m_bNewVisReplInStream( sal_True )
63  , m_bStoreLoaded( sal_False )
64  , m_bVisReplInitialized( sal_False )
65  , m_bVisReplInStream( sal_False )
66  , m_bStoreVisRepl( sal_False )
67  , m_bIsLink( sal_False )
68  , m_bHasCachedSize( sal_False )
69  , m_nCachedAspect( 0 )
70  , m_bHasSizeToSet( sal_False )
71  , m_nAspectToSet( 0 )
72  , m_bGotStatus( sal_False )
73  , m_nStatus( 0 )
74  , m_nStatusAspect( 0 )
75  , m_pOwnView( NULL )
76  , m_bFromClipboard( sal_False )
77  , m_bTriedConversion( sal_False )
78  {
79  }
80  
81  //------------------------------------------------------
82  // In case of loading from persistent entry the classID of the object
83  // will be retrieved from the entry, during construction it is unknown
84  OleEmbeddedObject::OleEmbeddedObject( const uno::Reference< lang::XMultiServiceFactory >& xFactory, sal_Bool bLink )
85  : m_pOleComponent( NULL )
86  , m_pInterfaceContainer( NULL )
87  , m_bReadOnly( sal_False )
88  , m_bDisposed( sal_False )
89  , m_nObjectState( -1 )
90  , m_nTargetState( -1 )
91  , m_nUpdateMode( embed::EmbedUpdateModes::ALWAYS_UPDATE )
92  , m_xFactory( xFactory )
93  , m_bWaitSaveCompleted( sal_False )
94  , m_bNewVisReplInStream( sal_True )
95  , m_bStoreLoaded( sal_False )
96  , m_bVisReplInitialized( sal_False )
97  , m_bVisReplInStream( sal_False )
98  , m_bStoreVisRepl( sal_False )
99  , m_bIsLink( bLink )
100  , m_bHasCachedSize( sal_False )
101  , m_nCachedAspect( 0 )
102  , m_bHasSizeToSet( sal_False )
103  , m_nAspectToSet( 0 )
104  , m_bGotStatus( sal_False )
105  , m_nStatus( 0 )
106  , m_nStatusAspect( 0 )
107  , m_pOwnView( NULL )
108  , m_bFromClipboard( sal_False )
109  , m_bTriedConversion( sal_False )
110  {
111  }
112  #ifdef WNT
113  //------------------------------------------------------
114  // this constructor let object be initialized from clipboard
115  OleEmbeddedObject::OleEmbeddedObject( const uno::Reference< lang::XMultiServiceFactory >& xFactory )
116  : m_pOleComponent( NULL )
117  , m_pInterfaceContainer( NULL )
118  , m_bReadOnly( sal_False )
119  , m_bDisposed( sal_False )
120  , m_nObjectState( -1 )
121  , m_nTargetState( -1 )
122  , m_nUpdateMode( embed::EmbedUpdateModes::ALWAYS_UPDATE )
123  , m_xFactory( xFactory )
124  , m_bWaitSaveCompleted( sal_False )
125  , m_bNewVisReplInStream( sal_True )
126  , m_bStoreLoaded( sal_False )
127  , m_bVisReplInitialized( sal_False )
128  , m_bVisReplInStream( sal_False )
129  , m_bStoreVisRepl( sal_False )
130  , m_bIsLink( sal_False )
131  , m_bHasCachedSize( sal_False )
132  , m_nCachedAspect( 0 )
133  , m_bHasSizeToSet( sal_False )
134  , m_nAspectToSet( 0 )
135  , m_bGotStatus( sal_False )
136  , m_nStatus( 0 )
137  , m_nStatusAspect( 0 )
138  , m_pOwnView( NULL )
139  , m_bFromClipboard( sal_True )
140  , m_bTriedConversion( sal_False )
141  {
142  }
143  #endif
144  //------------------------------------------------------
145  OleEmbeddedObject::~OleEmbeddedObject()
146  {
147  	OSL_ENSURE( !m_pInterfaceContainer && !m_pOleComponent && !m_xObjectStream.is(),
148  					"The object is not closed! DISASTER is possible!" );
149  
150  	if ( m_pOleComponent || m_pInterfaceContainer || m_xObjectStream.is() )
151  	{
152  		// the component must be cleaned during closing
153  		m_refCount++; // to avoid crash
154  		try {
155  			Dispose();
156  		} catch( uno::Exception& ) {}
157  	}
158  
159  	if ( m_aTempURL.getLength() )
160         	KillFile_Impl( m_aTempURL, m_xFactory );
161  
162  	if ( m_aTempDumpURL.getLength() )
163         	KillFile_Impl( m_aTempDumpURL, m_xFactory );
164  }
165  
166  //------------------------------------------------------
167  void OleEmbeddedObject::MakeEventListenerNotification_Impl( const ::rtl::OUString& aEventName )
168  {
169  	if ( m_pInterfaceContainer )
170  	{
171  	   	::cppu::OInterfaceContainerHelper* pContainer =
172  			m_pInterfaceContainer->getContainer(
173  									::getCppuType( ( const uno::Reference< document::XEventListener >*) NULL ) );
174      	if ( pContainer != NULL )
175  		{
176      		document::EventObject aEvent( static_cast< ::cppu::OWeakObject* >( this ), aEventName );
177          	::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
178          	while (pIterator.hasMoreElements())
179          	{
180              	try
181              	{
182                  	((document::XEventListener*)pIterator.next())->notifyEvent( aEvent );
183              	}
184              	catch( uno::RuntimeException& )
185              	{
186              	}
187          	}
188  		}
189  	}
190  }
191  #ifdef WNT
192  //----------------------------------------------
193  void OleEmbeddedObject::StateChangeNotification_Impl( sal_Bool bBeforeChange, sal_Int32 nOldState, sal_Int32 nNewState )
194  {
195  	if ( m_pInterfaceContainer )
196  	{
197      	::cppu::OInterfaceContainerHelper* pContainer = m_pInterfaceContainer->getContainer(
198  							::getCppuType( ( const uno::Reference< embed::XStateChangeListener >*) NULL ) );
199      	if ( pContainer != NULL )
200  		{
201      		lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
202          	::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
203  
204          	while (pIterator.hasMoreElements())
205          	{
206  				if ( bBeforeChange )
207  				{
208              		try
209              		{
210                  		((embed::XStateChangeListener*)pIterator.next())->changingState( aSource, nOldState, nNewState );
211              		}
212              		catch( uno::Exception& )
213              		{
214  						// even if the listener complains ignore it for now
215              		}
216  				}
217  				else
218  				{
219  			   		try
220              		{
221                  		((embed::XStateChangeListener*)pIterator.next())->stateChanged( aSource, nOldState, nNewState );
222              		}
223              		catch( uno::Exception& )
224              		{
225  						// if anything happened it is problem of listener, ignore it
226              		}
227  				}
228          	}
229  		}
230  	}
231  }
232  #endif
233  //------------------------------------------------------
234  void OleEmbeddedObject::GetRidOfComponent()
235  {
236  #ifdef WNT
237  	if ( m_pOleComponent )
238  	{
239  		if ( m_nObjectState != -1 && m_nObjectState != embed::EmbedStates::LOADED )
240  			SaveObject_Impl();
241  
242  		m_pOleComponent->removeCloseListener( m_xClosePreventer );
243  		try
244  		{
245  			m_pOleComponent->close( sal_False );
246  		}
247  		catch( uno::Exception& )
248  		{
249  			// TODO: there should be a special listener to wait for component closing
250  			// 		 and to notify object, may be object itself can be such a listener
251  			m_pOleComponent->addCloseListener( m_xClosePreventer );
252  			throw;
253  		}
254  
255  		m_pOleComponent->disconnectEmbeddedObject();
256  		m_pOleComponent->release();
257  		m_pOleComponent = NULL;
258  	}
259  #endif
260  }
261  
262  //------------------------------------------------------
263  void OleEmbeddedObject::Dispose()
264  {
265  	if ( m_pInterfaceContainer )
266  	{
267      	lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
268  		m_pInterfaceContainer->disposeAndClear( aSource );
269  		delete m_pInterfaceContainer;
270  		m_pInterfaceContainer = NULL;
271  	}
272  
273  	if ( m_pOwnView )
274  	{
275  		m_pOwnView->Close();
276  		m_pOwnView->release();
277  		m_pOwnView = NULL;
278  	}
279  
280  	if ( m_pOleComponent )
281  		try {
282  			GetRidOfComponent();
283  		} catch( uno::Exception& )
284  		{
285  			m_bDisposed = true;
286  			throw; // TODO: there should be a special listener that will close object when
287  					// component is finally closed
288  		}
289  
290  	if ( m_xObjectStream.is() )
291  	{
292  		uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY );
293  		OSL_ENSURE( xComp.is(), "Storage stream doesn't support XComponent!\n" );
294  
295  		if ( xComp.is() )
296  		{
297  			try {
298  				xComp->dispose();
299  			} catch( uno::Exception& ) {}
300  		}
301  		m_xObjectStream = uno::Reference< io::XStream >();
302  	}
303  
304  	m_xParentStorage = uno::Reference< embed::XStorage >();
305  
306  	m_bDisposed = true;
307  }
308  
309  //------------------------------------------------------
310  uno::Sequence< sal_Int8 > SAL_CALL OleEmbeddedObject::getClassID()
311  		throw ( uno::RuntimeException )
312  {
313      // begin wrapping related part ====================
314      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
315      if ( xWrappedObject.is() )
316      {
317          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
318          return xWrappedObject->getClassID();
319      }
320      // end wrapping related part ====================
321  
322  	::osl::MutexGuard aGuard( m_aMutex );
323  	if ( m_bDisposed )
324  		throw lang::DisposedException(); // TODO
325  
326  	return m_aClassID;
327  }
328  
329  //------------------------------------------------------
330  ::rtl::OUString SAL_CALL OleEmbeddedObject::getClassName()
331  		throw ( uno::RuntimeException )
332  {
333      // begin wrapping related part ====================
334      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
335      if ( xWrappedObject.is() )
336      {
337          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
338          return xWrappedObject->getClassName();
339      }
340      // end wrapping related part ====================
341  
342  	::osl::MutexGuard aGuard( m_aMutex );
343  	if ( m_bDisposed )
344  		throw lang::DisposedException(); // TODO
345  
346  	return m_aClassName;
347  }
348  
349  //------------------------------------------------------
350  void SAL_CALL OleEmbeddedObject::setClassInfo(
351  				const uno::Sequence< sal_Int8 >& aClassID, const ::rtl::OUString& aClassName )
352  		throw ( lang::NoSupportException,
353  				uno::RuntimeException )
354  {
355      // begin wrapping related part ====================
356      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
357      if ( xWrappedObject.is() )
358      {
359          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
360          xWrappedObject->setClassInfo( aClassID, aClassName );
361          return;
362      }
363      // end wrapping related part ====================
364  
365  	// the object class info can not be changed explicitly
366  	throw lang::NoSupportException(); //TODO:
367  }
368  
369  //------------------------------------------------------
370  uno::Reference< util::XCloseable > SAL_CALL OleEmbeddedObject::getComponent()
371  		throw ( uno::RuntimeException )
372  {
373      // begin wrapping related part ====================
374      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
375      if ( xWrappedObject.is() )
376      {
377          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
378          return xWrappedObject->getComponent();
379      }
380      // end wrapping related part ====================
381  
382  	::osl::MutexGuard aGuard( m_aMutex );
383  	if ( m_bDisposed )
384  		throw lang::DisposedException(); // TODO
385  
386  	if ( m_nObjectState == -1 ) // || m_nObjectState == embed::EmbedStates::LOADED )
387  	{
388  		// the object is still not running
389  		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object is not loaded!\n" ),
390  										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
391  	}
392  
393  	// if ( m_bWaitSaveCompleted )
394  	// 	throw embed::WrongStateException(
395  	// 				::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ),
396  	// 				uno::Reference< uno::XInterface >( reinterpret_cast< ::cppu::OWeakObject* >(this) ) );
397  
398  	if ( !m_pOleComponent )
399  	{
400  		// TODO/LATER: Is it correct???
401  		return uno::Reference< util::XCloseable >();
402  		// throw uno::RuntimeException(); // TODO
403  	}
404  
405  	return uno::Reference< util::XCloseable >( static_cast< ::cppu::OWeakObject* >( m_pOleComponent ), uno::UNO_QUERY );
406  }
407  
408  //----------------------------------------------
409  void SAL_CALL OleEmbeddedObject::addStateChangeListener( const uno::Reference< embed::XStateChangeListener >& xListener )
410  	throw ( uno::RuntimeException )
411  {
412      // begin wrapping related part ====================
413      uno::Reference< embed::XStateChangeBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
414      if ( xWrappedObject.is() )
415      {
416          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
417          xWrappedObject->addStateChangeListener( xListener );
418          return;
419      }
420      // end wrapping related part ====================
421  
422  	::osl::MutexGuard aGuard( m_aMutex );
423  	if ( m_bDisposed )
424  		throw lang::DisposedException(); // TODO
425  
426  	if ( !m_pInterfaceContainer )
427  		m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
428  
429  	m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ),
430  														xListener );
431  }
432  
433  //----------------------------------------------
434  void SAL_CALL OleEmbeddedObject::removeStateChangeListener(
435  					const uno::Reference< embed::XStateChangeListener >& xListener )
436  	throw (uno::RuntimeException)
437  {
438      // begin wrapping related part ====================
439      uno::Reference< embed::XStateChangeBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
440      if ( xWrappedObject.is() )
441      {
442          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
443          xWrappedObject->removeStateChangeListener( xListener );
444          return;
445      }
446      // end wrapping related part ====================
447  
448  	::osl::MutexGuard aGuard( m_aMutex );
449  	if ( m_pInterfaceContainer )
450  		m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< embed::XStateChangeListener >*)0 ),
451  												xListener );
452  }
453  
454  
455  //----------------------------------------------
456  void SAL_CALL OleEmbeddedObject::close( sal_Bool bDeliverOwnership )
457  	throw ( util::CloseVetoException,
458  			uno::RuntimeException )
459  {
460      // begin wrapping related part ====================
461      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
462      if ( xWrappedObject.is() )
463      {
464          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
465          xWrappedObject->close( bDeliverOwnership );
466          return;
467      }
468      // end wrapping related part ====================
469  
470  	::osl::MutexGuard aGuard( m_aMutex );
471  	if ( m_bDisposed )
472  		throw lang::DisposedException(); // TODO
473  
474      uno::Reference< uno::XInterface > xSelfHold( static_cast< ::cppu::OWeakObject* >( this ) );
475      lang::EventObject aSource( static_cast< ::cppu::OWeakObject* >( this ) );
476  
477  	if ( m_pInterfaceContainer )
478  	{
479      	::cppu::OInterfaceContainerHelper* pContainer =
480  			m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
481      	if ( pContainer != NULL )
482  		{
483          	::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
484          	while (pIterator.hasMoreElements())
485          	{
486              	try
487              	{
488                  	((util::XCloseListener*)pIterator.next())->queryClosing( aSource, bDeliverOwnership );
489              	}
490              	catch( uno::RuntimeException& )
491              	{
492                  	pIterator.remove();
493              	}
494          	}
495  		}
496  
497      	pContainer = m_pInterfaceContainer->getContainer(
498  									::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
499      	if ( pContainer != NULL )
500  		{
501          	::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer);
502          	while (pCloseIterator.hasMoreElements())
503          	{
504              	try
505              	{
506                  	((util::XCloseListener*)pCloseIterator.next())->notifyClosing( aSource );
507              	}
508              	catch( uno::RuntimeException& )
509              	{
510                  	pCloseIterator.remove();
511              	}
512          	}
513  		}
514  	}
515  
516  	Dispose();
517  }
518  
519  //----------------------------------------------
520  void SAL_CALL OleEmbeddedObject::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
521  	throw ( uno::RuntimeException )
522  {
523      // begin wrapping related part ====================
524      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
525      if ( xWrappedObject.is() )
526      {
527          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
528          xWrappedObject->addCloseListener( xListener );
529          return;
530      }
531      // end wrapping related part ====================
532  
533  	::osl::MutexGuard aGuard( m_aMutex );
534  	if ( m_bDisposed )
535  		throw lang::DisposedException(); // TODO
536  
537  	if ( !m_pInterfaceContainer )
538  		m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
539  
540  	m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ), xListener );
541  }
542  
543  //----------------------------------------------
544  void SAL_CALL OleEmbeddedObject::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
545  	throw (uno::RuntimeException)
546  {
547      // begin wrapping related part ====================
548      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
549      if ( xWrappedObject.is() )
550      {
551          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
552          xWrappedObject->removeCloseListener( xListener );
553          return;
554      }
555      // end wrapping related part ====================
556  
557  	::osl::MutexGuard aGuard( m_aMutex );
558  	if ( m_bDisposed )
559  		throw lang::DisposedException(); // TODO
560  
561  	if ( m_pInterfaceContainer )
562  		m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< util::XCloseListener >*)0 ),
563  												xListener );
564  }
565  
566  //------------------------------------------------------
567  void SAL_CALL OleEmbeddedObject::addEventListener( const uno::Reference< document::XEventListener >& xListener )
568  		throw ( uno::RuntimeException )
569  {
570      // begin wrapping related part ====================
571      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
572      if ( xWrappedObject.is() )
573      {
574          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
575          xWrappedObject->addEventListener( xListener );
576          return;
577      }
578      // end wrapping related part ====================
579  
580  	::osl::MutexGuard aGuard( m_aMutex );
581  	if ( m_bDisposed )
582  		throw lang::DisposedException(); // TODO
583  
584  	if ( !m_pInterfaceContainer )
585  		m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
586  
587  	m_pInterfaceContainer->addInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ), xListener );
588  }
589  
590  //------------------------------------------------------
591  void SAL_CALL OleEmbeddedObject::removeEventListener(
592  				const uno::Reference< document::XEventListener >& xListener )
593  		throw ( uno::RuntimeException )
594  {
595      // begin wrapping related part ====================
596      uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
597      if ( xWrappedObject.is() )
598      {
599          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
600          xWrappedObject->removeEventListener( xListener );
601          return;
602      }
603      // end wrapping related part ====================
604  
605  	::osl::MutexGuard aGuard( m_aMutex );
606  	if ( m_bDisposed )
607  		throw lang::DisposedException(); // TODO
608  
609  	if ( m_pInterfaceContainer )
610  		m_pInterfaceContainer->removeInterface( ::getCppuType( (const uno::Reference< document::XEventListener >*)0 ),
611  												xListener );
612  }
613  
614  // XInplaceObject ( wrapper related implementation )
615  //------------------------------------------------------
616  void SAL_CALL OleEmbeddedObject::setObjectRectangles( const awt::Rectangle& aPosRect,
617  										  			 	const awt::Rectangle& aClipRect )
618  		throw ( embed::WrongStateException,
619  				uno::Exception,
620  				uno::RuntimeException )
621  {
622      // begin wrapping related part ====================
623      uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
624      if ( xWrappedObject.is() )
625      {
626          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
627          xWrappedObject->setObjectRectangles( aPosRect, aClipRect );
628          return;
629      }
630      // end wrapping related part ====================
631  
632      throw embed::WrongStateException();
633  }
634  
635  //------------------------------------------------------
636  void SAL_CALL OleEmbeddedObject::enableModeless( sal_Bool bEnable )
637  		throw ( embed::WrongStateException,
638  				uno::Exception,
639  				uno::RuntimeException )
640  {
641      // begin wrapping related part ====================
642      uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
643      if ( xWrappedObject.is() )
644      {
645          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
646          xWrappedObject->enableModeless( bEnable );
647          return;
648      }
649      // end wrapping related part ====================
650  
651      throw embed::WrongStateException();
652  }
653  
654  //------------------------------------------------------
655  void SAL_CALL OleEmbeddedObject::translateAccelerators(
656  					const uno::Sequence< awt::KeyEvent >& aKeys )
657  		throw ( embed::WrongStateException,
658  				uno::RuntimeException )
659  {
660      // begin wrapping related part ====================
661      uno::Reference< embed::XInplaceObject > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
662      if ( xWrappedObject.is() )
663      {
664          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
665          xWrappedObject->translateAccelerators( aKeys );
666          return;
667      }
668      // end wrapping related part ====================
669  
670      // throw embed::WrongStateException();
671  }
672  
673  // XChild
674  //------------------------------------------------------
675  com::sun::star::uno::Reference< com::sun::star::uno::XInterface > SAL_CALL OleEmbeddedObject::getParent() throw (::com::sun::star::uno::RuntimeException)
676  {
677      // begin wrapping related part ====================
678      uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
679      if ( xWrappedObject.is() )
680      {
681          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
682          return xWrappedObject->getParent();
683      }
684      // end wrapping related part ====================
685  
686      return m_xParent;
687  }
688  
689  //------------------------------------------------------
690  void SAL_CALL OleEmbeddedObject::setParent( const com::sun::star::uno::Reference< com::sun::star::uno::XInterface >& xParent ) throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException)
691  {
692      // begin wrapping related part ====================
693      uno::Reference< container::XChild > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
694      if ( xWrappedObject.is() )
695      {
696          // the object was converted to OOo embedded object, the current implementation is now only a wrapper
697          xWrappedObject->setParent( xParent );
698          return;
699      }
700      // end wrapping related part ====================
701  
702      m_xParent = xParent;
703  }
704  
705