1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_embeddedobj.hxx"
26 
27 #include <oleembobj.hxx>
28 #include <com/sun/star/embed/EmbedStates.hpp>
29 #include <com/sun/star/embed/EmbedVerbs.hpp>
30 #include <com/sun/star/embed/EntryInitModes.hpp>
31 #include <com/sun/star/embed/XStorage.hpp>
32 #include <com/sun/star/embed/ElementModes.hpp>
33 #include <com/sun/star/embed/EmbedUpdateModes.hpp>
34 #include <com/sun/star/embed/Aspects.hpp>
35 #include <com/sun/star/embed/NeedsRunningStateException.hpp>
36 #include <com/sun/star/embed/StateChangeInProgressException.hpp>
37 #include <com/sun/star/embed/EmbedMisc.hpp>
38 #include <com/sun/star/embed/XEmbedObjectCreator.hpp>
39 #include <com/sun/star/io/XSeekable.hpp>
40 #include <com/sun/star/lang/DisposedException.hpp>
41 #include <com/sun/star/beans/NamedValue.hpp>
42 #include <com/sun/star/beans/XPropertySet.hpp>
43 #include <com/sun/star/frame/XLoadable.hpp>
44 #include <com/sun/star/document/XStorageBasedDocument.hpp>
45 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
46 #include <com/sun/star/container/XNameAccess.hpp>
47 #include <com/sun/star/container/XNameContainer.hpp>
48 #include <com/sun/star/system/SystemShellExecute.hpp>
49 #include <com/sun/star/system/SystemShellExecuteFlags.hpp>
50 
51 #include <rtl/logfile.hxx>
52 #include <cppuhelper/interfacecontainer.h>
53 #include <comphelper/mimeconfighelper.hxx>
54 #include <comphelper/storagehelper.hxx>
55 #include <comphelper/processfactory.hxx>
56 
57 #include <targetstatecontrol.hxx>
58 
59 #include <olecomponent.hxx>
60 
61 #include "ownview.hxx"
62 
63 using namespace ::com::sun::star;
64 
65 #ifdef WNT
66 //----------------------------------------------
67 void OleEmbeddedObject::SwitchComponentToRunningState_Impl()
68 {
69 	if ( m_pOleComponent )
70 	{
71 		try
72 		{
73 			m_pOleComponent->RunObject();
74 		}
75 		catch( embed::UnreachableStateException& )
76 		{
77 			GetRidOfComponent();
78 			throw;
79 		}
80 		catch( embed::WrongStateException& )
81 		{
82 			GetRidOfComponent();
83 			throw;
84 		}
85 	}
86 	else
87 	{
88 		throw embed::UnreachableStateException();
89 	}
90 }
91 
92 //----------------------------------------------
93 uno::Sequence< sal_Int32 > OleEmbeddedObject::GetReachableStatesList_Impl(
94 														const uno::Sequence< embed::VerbDescriptor >& aVerbList )
95 {
96 	uno::Sequence< sal_Int32 > aStates(2);
97 	aStates[0] = embed::EmbedStates::LOADED;
98 	aStates[1] = embed::EmbedStates::RUNNING;
99 	for ( sal_Int32 nInd = 0; nInd < aVerbList.getLength(); nInd++ )
100 		if ( aVerbList[nInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
101 		{
102 			aStates.realloc(3);
103 			aStates[2] = embed::EmbedStates::ACTIVE;
104 		}
105 
106 	return aStates;
107 }
108 
109 //----------------------------------------------
110 uno::Sequence< sal_Int32 > OleEmbeddedObject::GetIntermediateVerbsSequence_Impl( sal_Int32 nNewState )
111 {
112 	OSL_ENSURE( m_nObjectState != embed::EmbedStates::LOADED, "Loaded object is switched to running state without verbs using!" );
113 
114 	// actually there will be only one verb
115 	if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
116 	{
117 		uno::Sequence< sal_Int32 > aVerbs( 1 );
118 		aVerbs[0] = embed::EmbedVerbs::MS_OLEVERB_OPEN;
119 	}
120 
121 	return uno::Sequence< sal_Int32 >();
122 }
123 #endif
124 //----------------------------------------------
125 void OleEmbeddedObject::MoveListeners()
126 {
127 	if ( m_pInterfaceContainer )
128 	{
129         // move state change listeners
130         {
131             ::cppu::OInterfaceContainerHelper* pStateChangeContainer =
132                 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< embed::XStateChangeListener >*) NULL ) );
133             if ( pStateChangeContainer != NULL )
134             {
135                 uno::Reference< embed::XStateChangeBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
136                 if ( xWrappedObject.is() )
137                 {
138                     ::cppu::OInterfaceIteratorHelper pIterator( *pStateChangeContainer );
139                     while ( pIterator.hasMoreElements() )
140                     {
141                         try
142                         {
143                             xWrappedObject->addStateChangeListener( (embed::XStateChangeListener*)pIterator.next() );
144                         }
145                         catch( uno::RuntimeException& )
146                         {
147                             pIterator.remove();
148                         }
149                     }
150                 }
151             }
152         }
153 
154         // move event listeners
155         {
156             ::cppu::OInterfaceContainerHelper* pEventContainer =
157                 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< document::XEventListener >*) NULL ) );
158             if ( pEventContainer != NULL )
159             {
160                 uno::Reference< document::XEventBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
161                 if ( xWrappedObject.is() )
162                 {
163                     ::cppu::OInterfaceIteratorHelper pIterator( *pEventContainer );
164                     while ( pIterator.hasMoreElements() )
165                     {
166                         try
167                         {
168                             xWrappedObject->addEventListener( (document::XEventListener*)pIterator.next() );
169                         }
170                         catch( uno::RuntimeException& )
171                         {
172                             pIterator.remove();
173                         }
174                     }
175                 }
176             }
177         }
178 
179         // move close listeners
180         {
181             ::cppu::OInterfaceContainerHelper* pCloseContainer =
182                 m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
183             if ( pCloseContainer != NULL )
184             {
185                 uno::Reference< util::XCloseBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
186                 if ( xWrappedObject.is() )
187                 {
188                     ::cppu::OInterfaceIteratorHelper pIterator( *pCloseContainer );
189                     while ( pIterator.hasMoreElements() )
190                     {
191                         try
192                         {
193                             xWrappedObject->addCloseListener( (util::XCloseListener*)pIterator.next() );
194                         }
195                         catch( uno::RuntimeException& )
196                         {
197                             pIterator.remove();
198                         }
199                     }
200                 }
201             }
202         }
203 
204         delete m_pInterfaceContainer;
205         m_pInterfaceContainer = NULL;
206     }
207 }
208 
209 //----------------------------------------------
210 uno::Reference< embed::XStorage > OleEmbeddedObject::CreateTemporarySubstorage( ::rtl::OUString& o_aStorageName )
211 {
212     uno::Reference< embed::XStorage > xResult;
213 
214     for ( sal_Int32 nInd = 0; nInd < 32000 && !xResult.is(); nInd++ )
215     {
216         ::rtl::OUString aName = ::rtl::OUString::valueOf( nInd );
217         aName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TMPSTOR" ) );
218         aName += m_aEntryName;
219         if ( !m_xParentStorage->hasByName( aName ) )
220         {
221             xResult = m_xParentStorage->openStorageElement( aName, embed::ElementModes::READWRITE );
222             o_aStorageName = aName;
223         }
224     }
225 
226     if ( !xResult.is() )
227     {
228         o_aStorageName = ::rtl::OUString();
229         throw uno::RuntimeException();
230     }
231 
232     return xResult;
233 }
234 
235 //----------------------------------------------
236 ::rtl::OUString OleEmbeddedObject::MoveToTemporarySubstream()
237 {
238     ::rtl::OUString aResult;
239     for ( sal_Int32 nInd = 0; nInd < 32000 && !aResult.getLength(); nInd++ )
240     {
241         ::rtl::OUString aName = ::rtl::OUString::valueOf( nInd );
242         aName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TMPSTREAM" ) );
243         aName += m_aEntryName;
244         if ( !m_xParentStorage->hasByName( aName ) )
245         {
246             m_xParentStorage->renameElement( m_aEntryName, aName );
247             aResult = aName;
248         }
249     }
250 
251     if ( !aResult.getLength() )
252         throw uno::RuntimeException();
253 
254     return aResult;
255 }
256 
257 //----------------------------------------------
258 sal_Bool OleEmbeddedObject::TryToConvertToOOo()
259 {
260     sal_Bool bResult = sal_False;
261 
262     ::rtl::OUString aStorageName;
263     ::rtl::OUString aTmpStreamName;
264     sal_Int32 nStep = 0;
265 
266     if ( m_pOleComponent || m_bReadOnly )
267         return sal_False;
268 
269     try
270     {
271         changeState( embed::EmbedStates::LOADED );
272 
273         // the stream must be seekable
274         uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY_THROW );
275         xSeekable->seek( 0 );
276         ::rtl::OUString aFilterName = OwnView_Impl::GetFilterNameFromExtentionAndInStream( m_xFactory, ::rtl::OUString(), m_xObjectStream->getInputStream() );
277 
278         // use the solution only for OOXML format currently
279         if ( aFilterName.getLength()
280           && ( aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "Calc MS Excel 2007 XML" ) ) )
281             || aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "Impress MS PowerPoint 2007 XML" ) ) )
282             || aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "MS Word 2007 XML" ) ) ) ) )
283         {
284             uno::Reference< container::XNameAccess > xFilterFactory(
285 			    m_xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ),
286 			    uno::UNO_QUERY_THROW );
287 
288             ::rtl::OUString aDocServiceName;
289 		    uno::Any aFilterAnyData = xFilterFactory->getByName( aFilterName );
290 		    uno::Sequence< beans::PropertyValue > aFilterData;
291 		    if ( aFilterAnyData >>= aFilterData )
292 		    {
293 			    for ( sal_Int32 nInd = 0; nInd < aFilterData.getLength(); nInd++ )
294 				    if ( aFilterData[nInd].Name.equalsAscii( "DocumentService" ) )
295 					    aFilterData[nInd].Value >>= aDocServiceName;
296 		    }
297 
298             if ( aDocServiceName.getLength() )
299             {
300                 // create the model
301                 uno::Sequence< uno::Any > aArguments(1);
302                 aArguments[0] <<= beans::NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "EmbeddedObject" ) ), uno::makeAny( (sal_Bool)sal_True ));
303 
304                 uno::Reference< util::XCloseable > xDocument( m_xFactory->createInstanceWithArguments( aDocServiceName, aArguments ), uno::UNO_QUERY_THROW );
305                 uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );
306                 uno::Reference< document::XStorageBasedDocument > xStorDoc( xDocument, uno::UNO_QUERY_THROW );
307 
308                 // let the model behave as embedded one
309                 uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY_THROW );
310 		        uno::Sequence< beans::PropertyValue > aSeq( 1 );
311 		        aSeq[0].Name = ::rtl::OUString::createFromAscii( "SetEmbedded" );
312 		        aSeq[0].Value <<= sal_True;
313 		        xModel->attachResource( ::rtl::OUString(), aSeq );
314 
315                 // load the model from the stream
316 	            uno::Sequence< beans::PropertyValue > aArgs( 5 );
317                 aArgs[0].Name = ::rtl::OUString::createFromAscii( "HierarchicalDocumentName" );
318                 aArgs[0].Value <<= m_aEntryName;
319 	            aArgs[1].Name = ::rtl::OUString::createFromAscii( "ReadOnly" );
320 	            aArgs[1].Value <<= sal_True;
321 	            aArgs[2].Name = ::rtl::OUString::createFromAscii( "FilterName" );
322 	            aArgs[2].Value <<= aFilterName;
323                 aArgs[3].Name = ::rtl::OUString::createFromAscii( "URL" );
324                 aArgs[3].Value <<= ::rtl::OUString::createFromAscii( "private:stream" );
325                 aArgs[4].Name = ::rtl::OUString::createFromAscii( "InputStream" );
326                 aArgs[4].Value <<= m_xObjectStream->getInputStream();
327 
328                 xSeekable->seek( 0 );
329                 xLoadable->load( aArgs );
330 
331                 // the model is successfuly loaded, create a new storage and store the model to the storage
332                 uno::Reference< embed::XStorage > xTmpStorage = CreateTemporarySubstorage( aStorageName );
333                 xStorDoc->storeToStorage( xTmpStorage, uno::Sequence< beans::PropertyValue >() );
334                 xDocument->close( sal_True );
335                 uno::Reference< beans::XPropertySet > xStorProps( xTmpStorage, uno::UNO_QUERY_THROW );
336                 ::rtl::OUString aMediaType;
337                 xStorProps->getPropertyValue( ::rtl::OUString::createFromAscii( "MediaType" ) ) >>= aMediaType;
338                 xTmpStorage->dispose();
339 
340                 // look for the related embedded object factory
341                 ::comphelper::MimeConfigurationHelper aConfigHelper( m_xFactory );
342                 ::rtl::OUString aEmbedFactory;
343 	            if ( aMediaType.getLength() )
344 		            aEmbedFactory = aConfigHelper.GetFactoryNameByMediaType( aMediaType );
345 
346 	            if ( !aEmbedFactory.getLength() )
347                     throw uno::RuntimeException();
348 
349                 uno::Reference< uno::XInterface > xFact = m_xFactory->createInstance( aEmbedFactory );
350 
351 		        uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY_THROW );
352 
353                 // now the object should be adjusted to become the wrapper
354                 nStep = 1;
355 		        uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY_THROW );
356 				xComp->dispose();
357 		        m_xObjectStream = uno::Reference< io::XStream >();
358                 m_nObjectState = -1;
359 
360                 nStep = 2;
361                 aTmpStreamName = MoveToTemporarySubstream();
362 
363                 nStep = 3;
364                 m_xParentStorage->renameElement( aStorageName, m_aEntryName );
365 
366                 nStep = 4;
367 		        m_xWrappedObject.set( xEmbCreator->createInstanceInitFromEntry( m_xParentStorage, m_aEntryName, uno::Sequence< beans::PropertyValue >(), uno::Sequence< beans::PropertyValue >() ), uno::UNO_QUERY_THROW );
368 
369                 bResult = sal_True; // the change is no more revertable
370                 try
371                 {
372                     m_xParentStorage->removeElement( aTmpStreamName );
373                 }
374                 catch( uno::Exception& )
375                 {
376                     // the success of the removing is not so important
377                 }
378             }
379         }
380     }
381     catch( uno::Exception& )
382     {
383         // repair the object if necessary
384         switch( nStep )
385         {
386             case 4:
387             case 3:
388             if ( aTmpStreamName.getLength() && aTmpStreamName != m_aEntryName )
389                 try
390                 {
391                     if ( m_xParentStorage->hasByName( m_aEntryName ) )
392                         m_xParentStorage->removeElement( m_aEntryName );
393                     m_xParentStorage->renameElement( aTmpStreamName, m_aEntryName );
394                 }
395                 catch ( uno::Exception& )
396                 {
397                     try {
398                         close( sal_True );
399                     } catch( uno::Exception& ) {}
400 
401                     m_xParentStorage->dispose(); // ??? the storage has information loss, it should be closed without commiting!
402                     throw uno::RuntimeException(); // the repairing is not possible
403                 }
404             case 2:
405                 try
406                 {
407                     m_xObjectStream = m_xParentStorage->openStreamElement( m_aEntryName, m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE );
408                     m_nObjectState = embed::EmbedStates::LOADED;
409                 }
410                 catch( uno::Exception& )
411                 {
412                     try {
413                         close( sal_True );
414                     } catch( uno::Exception& ) {}
415 
416                     throw uno::RuntimeException(); // the repairing is not possible
417                 }
418                 // no break as designed!
419 
420             case 1:
421             case 0:
422                 if ( aStorageName.getLength() )
423                     try {
424                         m_xParentStorage->removeElement( aStorageName );
425                     } catch( uno::Exception& ) { OSL_ASSERT( "Can not remove temporary storage!" ); }
426                 break;
427         }
428     }
429 
430     if ( bResult )
431     {
432         // the conversion was done successfuly, now the additional initializations should happen
433 
434         MoveListeners();
435         m_xWrappedObject->setClientSite( m_xClientSite );
436         if ( m_xParent.is() )
437         {
438             uno::Reference< container::XChild > xChild( m_xWrappedObject, uno::UNO_QUERY );
439             if ( xChild.is() )
440                 xChild->setParent( m_xParent );
441         }
442 
443     }
444 
445     return bResult;
446 }
447 
448 //----------------------------------------------
449 void SAL_CALL OleEmbeddedObject::changeState( sal_Int32 nNewState )
450 		throw ( embed::UnreachableStateException,
451 				embed::WrongStateException,
452 				uno::Exception,
453 				uno::RuntimeException )
454 {
455 	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::changeState" );
456 
457     // begin wrapping related part ====================
458     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
459     if ( xWrappedObject.is() )
460     {
461         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
462         xWrappedObject->changeState( nNewState );
463         return;
464     }
465     // end wrapping related part ====================
466 
467 	::osl::ResettableMutexGuard aGuard( m_aMutex );
468 
469 	if ( m_bDisposed )
470 		throw lang::DisposedException(); // TODO
471 
472 	if ( m_nObjectState == -1 )
473 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
474 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
475 
476 	// in case the object is already in requested state
477 	if ( m_nObjectState == nNewState )
478 		return;
479 
480 #ifdef WNT
481 	if ( m_pOleComponent )
482 	{
483 		if ( m_nTargetState != -1 )
484 		{
485 			// means that the object is currently trying to reach the target state
486 			throw embed::StateChangeInProgressException( ::rtl::OUString(),
487 														uno::Reference< uno::XInterface >(),
488 														m_nTargetState );
489 		}
490 
491 		TargetStateControl_Impl aControl( m_nTargetState, nNewState );
492 
493 		// TODO: additional verbs can be a problem, since nobody knows how the object
494 		//		 will behave after activation
495 
496 		sal_Int32 nOldState = m_nObjectState;
497 		aGuard.clear();
498 		StateChangeNotification_Impl( sal_True, nOldState, nNewState );
499 		aGuard.reset();
500 
501 		try
502 		{
503 			if ( nNewState == embed::EmbedStates::LOADED )
504 			{
505 				// This means just closing of the current object
506 				// If component can not be closed the object stays in loaded state
507 				// and it holds reference to "incomplete" component
508 				// If the object is switched to running state later
509 				// the component will become "complete"
510 
511 				// the loaded state must be set before, because of notifications!
512 				m_nObjectState = nNewState;
513 
514 				{
515 					VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
516 					m_pOleComponent->CloseObject();
517 				}
518 
519 				// GetRidOfComponent();
520 				aGuard.clear();
521 				StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
522 				aGuard.reset();
523 			}
524 			else if ( nNewState == embed::EmbedStates::RUNNING || nNewState == embed::EmbedStates::ACTIVE )
525 			{
526 				if ( m_nObjectState == embed::EmbedStates::LOADED )
527 				{
528 					// if the target object is in loaded state and a different state is specified
529 					// as a new one the object first must be switched to running state.
530 
531 					// the component can exist already in nonrunning state
532 					// it can be created during loading to detect type of object
533 					CreateOleComponentAndLoad_Impl( m_pOleComponent );
534 
535 					SwitchComponentToRunningState_Impl();
536 					m_nObjectState = embed::EmbedStates::RUNNING;
537 					aGuard.clear();
538 					StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
539 					aGuard.reset();
540 
541 					if ( m_pOleComponent && m_bHasSizeToSet )
542 					{
543 						aGuard.clear();
544 						try {
545 							m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
546 							m_bHasSizeToSet = sal_False;
547 						}
548 						catch( uno::Exception& ) {}
549 						aGuard.reset();
550 					}
551 
552 					if ( m_nObjectState == nNewState )
553 						return;
554 				}
555 
556 				// so now the object is either switched from Active to Running state or vise versa
557 				// the notification about object state change will be done asynchronously
558 				if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
559 				{
560 					// execute OPEN verb, if object does not reach active state it is an object's problem
561 					aGuard.clear();
562 					m_pOleComponent->ExecuteVerb( embed::EmbedVerbs::MS_OLEVERB_OPEN );
563 					aGuard.reset();
564 
565 					// some objects do not allow to set the size even in running state
566 					if ( m_pOleComponent && m_bHasSizeToSet )
567 					{
568 						aGuard.clear();
569 						try {
570 							m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
571 							m_bHasSizeToSet = sal_False;
572 						}
573 						catch( uno::Exception& ) {}
574 						aGuard.reset();
575 					}
576 
577 					m_nObjectState = nNewState;
578 				}
579 				else if ( m_nObjectState == embed::EmbedStates::ACTIVE && nNewState == embed::EmbedStates::RUNNING )
580 				{
581 					aGuard.clear();
582 					m_pOleComponent->CloseObject();
583 					m_pOleComponent->RunObject(); // Should not fail, the object already was active
584 					aGuard.reset();
585 					m_nObjectState = nNewState;
586 				}
587 				else
588 				{
589 					throw embed::UnreachableStateException();
590 				}
591 			}
592 			else
593 				throw embed::UnreachableStateException();
594 		}
595 		catch( uno::Exception& )
596 		{
597 			aGuard.clear();
598 			StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
599 			throw;
600 		}
601 	}
602 	else
603 #endif
604 	{
605 		throw embed::UnreachableStateException();
606 	}
607 }
608 
609 //----------------------------------------------
610 uno::Sequence< sal_Int32 > SAL_CALL OleEmbeddedObject::getReachableStates()
611 		throw ( embed::WrongStateException,
612 				uno::RuntimeException )
613 {
614 	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::getReachableStates" );
615 
616     // begin wrapping related part ====================
617     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
618     if ( xWrappedObject.is() )
619     {
620         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
621         return xWrappedObject->getReachableStates();
622     }
623     // end wrapping related part ====================
624 
625 	::osl::MutexGuard aGuard( m_aMutex );
626 	if ( m_bDisposed )
627 		throw lang::DisposedException(); // TODO
628 
629 	if ( m_nObjectState == -1 )
630 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
631 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
632 
633 #ifdef WNT
634 	if ( m_pOleComponent )
635 	{
636 		if ( m_nObjectState == embed::EmbedStates::LOADED )
637 		{
638 			// the list of supported verbs can be retrieved only when object is in running state
639 			throw embed::NeedsRunningStateException(); // TODO:
640 		}
641 
642 		// the list of states can only be guessed based on standard verbs,
643 		// since there is no way to detect what additional verbs do
644 		return GetReachableStatesList_Impl( m_pOleComponent->GetVerbList() );
645 	}
646 	else
647 #endif
648 	{
649 		return uno::Sequence< sal_Int32 >();
650 	}
651 }
652 
653 //----------------------------------------------
654 sal_Int32 SAL_CALL OleEmbeddedObject::getCurrentState()
655 		throw ( embed::WrongStateException,
656 				uno::RuntimeException )
657 {
658     // begin wrapping related part ====================
659     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
660     if ( xWrappedObject.is() )
661     {
662         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
663         return xWrappedObject->getCurrentState();
664     }
665     // end wrapping related part ====================
666 
667 	::osl::MutexGuard aGuard( m_aMutex );
668 	if ( m_bDisposed )
669 		throw lang::DisposedException(); // TODO
670 
671 	if ( m_nObjectState == -1 )
672 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
673 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
674 
675 	// TODO: Shouldn't we ask object? ( I guess no )
676 	return m_nObjectState;
677 }
678 
679 namespace
680 {
681     bool lcl_CopyStream(uno::Reference<io::XInputStream> xIn, uno::Reference<io::XOutputStream> xOut)
682     {
683         const sal_Int32 nChunkSize = 4096;
684         uno::Sequence< sal_Int8 > aData(nChunkSize);
685         sal_Int32 nTotalRead = 0;
686         sal_Int32 nRead;
687         do
688         {
689             nRead = xIn->readBytes(aData, nChunkSize);
690             nTotalRead += nRead;
691             xOut->writeBytes(aData);
692         } while (nRead == nChunkSize);
693         return nTotalRead != 0;
694     }
695 
696     //Dump the objects content to a tempfile, just the "CONTENTS" stream if
697     //there is one for non-compound documents, otherwise the whole content.
698     //
699     //On success a file is returned which must be removed by the caller
700     rtl::OUString lcl_ExtractObject(::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xFactory,
701         ::com::sun::star::uno::Reference< ::com::sun::star::io::XStream > xObjectStream)
702     {
703         rtl::OUString sUrl;
704 
705         // the solution is only active for Unix systems
706 #ifndef WNT
707         uno::Reference <beans::XPropertySet> xNativeTempFile(
708             xFactory->createInstance(
709                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.TempFile"))), uno::UNO_QUERY_THROW);
710         uno::Reference < io::XStream > xStream(xNativeTempFile, uno::UNO_QUERY_THROW);
711 
712         uno::Sequence< uno::Any > aArgs( 2 );
713         aArgs[0] <<= xObjectStream;
714         aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
715         uno::Reference< container::XNameContainer > xNameContainer(
716             xFactory->createInstanceWithArguments(
717                 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.OLESimpleStorage")),
718                 aArgs ), uno::UNO_QUERY_THROW );
719 
720         uno::Reference< io::XStream > xCONTENTS;
721         xNameContainer->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONTENTS"))) >>= xCONTENTS;
722 
723         sal_Bool bCopied = xCONTENTS.is() && lcl_CopyStream(xCONTENTS->getInputStream(), xStream->getOutputStream());
724 
725         uno::Reference< io::XSeekable > xSeekableStor(xObjectStream, uno::UNO_QUERY);
726         if (xSeekableStor.is())
727             xSeekableStor->seek(0);
728 
729         if (!bCopied)
730             bCopied = lcl_CopyStream(xObjectStream->getInputStream(), xStream->getOutputStream());
731 
732         if (bCopied)
733         {
734             xNativeTempFile->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RemoveFile")),
735                 uno::makeAny(sal_False));
736             uno::Any aUrl = xNativeTempFile->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Uri")));
737             aUrl >>= sUrl;
738 
739             xNativeTempFile = uno::Reference<beans::XPropertySet>();
740 
741             uno::Reference<ucb::XSimpleFileAccess> xSimpleFileAccess(
742                 xFactory->createInstance(
743                     ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.ucb.SimpleFileAccess"))),
744                     uno::UNO_QUERY_THROW);
745 
746             xSimpleFileAccess->setReadOnly(sUrl, sal_True);
747         }
748         else
749         {
750             xNativeTempFile->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RemoveFile")),
751                 uno::makeAny(sal_True));
752         }
753 #endif
754         return sUrl;
755     }
756 }
757 
758 //----------------------------------------------
759 void SAL_CALL OleEmbeddedObject::doVerb( sal_Int32 nVerbID )
760 		throw ( lang::IllegalArgumentException,
761 				embed::WrongStateException,
762 				embed::UnreachableStateException,
763 				uno::Exception,
764 				uno::RuntimeException )
765 {
766 	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::doVerb" );
767 
768     // begin wrapping related part ====================
769     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
770     if ( xWrappedObject.is() )
771     {
772         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
773         xWrappedObject->doVerb( nVerbID );
774         return;
775     }
776     // end wrapping related part ====================
777 
778 	::osl::ResettableMutexGuard aGuard( m_aMutex );
779 	if ( m_bDisposed )
780 		throw lang::DisposedException(); // TODO
781 
782 	if ( m_nObjectState == -1 )
783 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
784 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
785 
786 #ifdef WNT
787 	if ( m_pOleComponent )
788 	{
789 		sal_Int32 nOldState = m_nObjectState;
790 
791 		// TODO/LATER detect target state here and do a notification
792 		// StateChangeNotification_Impl( sal_True, nOldState, nNewState );
793 		if ( m_nObjectState == embed::EmbedStates::LOADED )
794 		{
795 			// if the target object is in loaded state
796 			// it must be switched to running state to execute verb
797 			aGuard.clear();
798 			changeState( embed::EmbedStates::RUNNING );
799 			aGuard.reset();
800 		}
801 
802 		try {
803 			if ( !m_pOleComponent )
804 				throw uno::RuntimeException();
805 
806 			// ==== the STAMPIT related solution =============================
807 			m_aVerbExecutionController.StartControlExecution();
808 			// ===============================================================
809 
810 			m_pOleComponent->ExecuteVerb( nVerbID );
811 
812 			// ==== the STAMPIT related solution =============================
813 			sal_Bool bModifiedOnExecution = m_aVerbExecutionController.EndControlExecution_WasModified();
814 
815 			// this workaround is implemented for STAMPIT object
816 			// if object was modified during verb execution it is saved here
817 			if ( bModifiedOnExecution && m_pOleComponent->IsDirty() )
818 				SaveObject_Impl();
819 			// ===============================================================
820 		}
821 		catch( uno::Exception& )
822 		{
823 			// ==== the STAMPIT related solution =============================
824 			m_aVerbExecutionController.EndControlExecution_WasModified();
825 			// ===============================================================
826 
827 			aGuard.clear();
828 			StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
829 			throw;
830 		}
831 
832 		// the following notification will be done asynchronously
833 		// StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
834 	}
835 	else
836 #endif
837 	{
838 		if ( nVerbID == -9 )
839 		{
840 			// the workaround verb to show the object in case no server is available
841 
842             // if it is possible, the object will be converted to OOo format
843             if ( !m_bTriedConversion )
844             {
845                 m_bTriedConversion = sal_True;
846                 if ( TryToConvertToOOo() )
847                 {
848                     changeState( embed::EmbedStates::UI_ACTIVE );
849                     return;
850                 }
851             }
852 
853 			if ( !m_pOwnView && m_xObjectStream.is() )
854 			{
855 				try {
856 					uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY );
857 					if ( xSeekable.is() )
858 						xSeekable->seek( 0 );
859 
860 					m_pOwnView = new OwnView_Impl( m_xFactory, m_xObjectStream->getInputStream() );
861 					m_pOwnView->acquire();
862 				}
863 				catch( uno::RuntimeException& )
864 				{
865 					throw;
866 				}
867 				catch( uno::Exception& )
868 				{
869 				}
870 			}
871 
872             if ( !m_pOwnView || !m_pOwnView->Open() )
873             {
874                 //Make a RO copy and see if the OS can find something to at
875                 //least display the content for us
876                 if (!m_aTempDumpURL.getLength())
877                     m_aTempDumpURL = lcl_ExtractObject(m_xFactory, m_xObjectStream);
878 
879                 if (m_aTempDumpURL.getLength())
880                 {
881                     uno::Reference< ::com::sun::star::system::XSystemShellExecute > xSystemShellExecute(
882                         ::com::sun::star::system::SystemShellExecute::create(
883                             ::comphelper::getProcessComponentContext() ) );
884                     xSystemShellExecute->execute(m_aTempDumpURL, ::rtl::OUString(), ::com::sun::star::system::SystemShellExecuteFlags::DEFAULTS);
885                 }
886                 else
887                     throw embed::UnreachableStateException();
888             }
889 		}
890 		else
891 		{
892 
893 			throw embed::UnreachableStateException();
894 		}
895 	}
896 }
897 
898 //----------------------------------------------
899 uno::Sequence< embed::VerbDescriptor > SAL_CALL OleEmbeddedObject::getSupportedVerbs()
900 		throw ( embed::WrongStateException,
901 				uno::RuntimeException )
902 {
903 	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::getSupportedVerb" );
904 
905     // begin wrapping related part ====================
906     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
907     if ( xWrappedObject.is() )
908     {
909         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
910         return xWrappedObject->getSupportedVerbs();
911     }
912     // end wrapping related part ====================
913 
914 	::osl::MutexGuard aGuard( m_aMutex );
915 	if ( m_bDisposed )
916 		throw lang::DisposedException(); // TODO
917 
918 	if ( m_nObjectState == -1 )
919 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
920 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
921 #ifdef WNT
922 	if ( m_pOleComponent )
923 	{
924 		// registry could be used in this case
925 		// if ( m_nObjectState == embed::EmbedStates::LOADED )
926 		// {
927 		// 	// the list of supported verbs can be retrieved only when object is in running state
928 		// 	throw embed::NeedsRunningStateException(); // TODO:
929 		// }
930 
931 		return m_pOleComponent->GetVerbList();
932 	}
933 	else
934 #endif
935 	{
936 		return uno::Sequence< embed::VerbDescriptor >();
937 	}
938 }
939 
940 //----------------------------------------------
941 void SAL_CALL OleEmbeddedObject::setClientSite(
942 				const uno::Reference< embed::XEmbeddedClient >& xClient )
943 		throw ( embed::WrongStateException,
944 				uno::RuntimeException )
945 {
946     // begin wrapping related part ====================
947     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
948     if ( xWrappedObject.is() )
949     {
950         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
951         xWrappedObject->setClientSite( xClient );
952         return;
953     }
954     // end wrapping related part ====================
955 
956 	::osl::MutexGuard aGuard( m_aMutex );
957 	if ( m_bDisposed )
958 		throw lang::DisposedException(); // TODO
959 
960 	if ( m_xClientSite != xClient)
961 	{
962 		if ( m_nObjectState != embed::EmbedStates::LOADED && m_nObjectState != embed::EmbedStates::RUNNING )
963 			throw embed::WrongStateException(
964 									::rtl::OUString::createFromAscii( "The client site can not be set currently!\n" ),
965 									uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
966 
967 		m_xClientSite = xClient;
968 	}
969 }
970 
971 //----------------------------------------------
972 uno::Reference< embed::XEmbeddedClient > SAL_CALL OleEmbeddedObject::getClientSite()
973 		throw ( embed::WrongStateException,
974 				uno::RuntimeException )
975 {
976     // begin wrapping related part ====================
977     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
978     if ( xWrappedObject.is() )
979     {
980         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
981         return xWrappedObject->getClientSite();
982     }
983     // end wrapping related part ====================
984 
985 	::osl::MutexGuard aGuard( m_aMutex );
986 	if ( m_bDisposed )
987 		throw lang::DisposedException(); // TODO
988 
989 	if ( m_nObjectState == -1 )
990 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
991 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
992 
993 	return m_xClientSite;
994 }
995 
996 //----------------------------------------------
997 void SAL_CALL OleEmbeddedObject::update()
998 		throw ( embed::WrongStateException,
999 				uno::Exception,
1000 				uno::RuntimeException )
1001 {
1002     // begin wrapping related part ====================
1003     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1004     if ( xWrappedObject.is() )
1005     {
1006         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1007         xWrappedObject->update();
1008         return;
1009     }
1010     // end wrapping related part ====================
1011 
1012 	::osl::MutexGuard aGuard( m_aMutex );
1013 	if ( m_bDisposed )
1014 		throw lang::DisposedException(); // TODO
1015 
1016 	if ( m_nObjectState == -1 )
1017 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
1018 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
1019 
1020 	if ( m_nUpdateMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE )
1021 	{
1022 		// TODO: update view representation
1023 	}
1024 	else
1025 	{
1026 		// the object must be up to date
1027 		OSL_ENSURE( m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE, "Unknown update mode!\n" );
1028 	}
1029 }
1030 
1031 //----------------------------------------------
1032 void SAL_CALL OleEmbeddedObject::setUpdateMode( sal_Int32 nMode )
1033 		throw ( embed::WrongStateException,
1034 				uno::RuntimeException )
1035 {
1036     // begin wrapping related part ====================
1037     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1038     if ( xWrappedObject.is() )
1039     {
1040         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1041         xWrappedObject->setUpdateMode( nMode );
1042         return;
1043     }
1044     // end wrapping related part ====================
1045 
1046 	::osl::MutexGuard aGuard( m_aMutex );
1047 	if ( m_bDisposed )
1048 		throw lang::DisposedException(); // TODO
1049 
1050 	if ( m_nObjectState == -1 )
1051 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
1052 										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
1053 
1054 	OSL_ENSURE( nMode == embed::EmbedUpdateModes::ALWAYS_UPDATE
1055 					|| nMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE,
1056 				"Unknown update mode!\n" );
1057 	m_nUpdateMode = nMode;
1058 }
1059 
1060 //----------------------------------------------
1061 sal_Int64 SAL_CALL OleEmbeddedObject::getStatus( sal_Int64
1062     nAspect
1063 )
1064 		throw ( embed::WrongStateException,
1065 				uno::RuntimeException )
1066 {
1067     // begin wrapping related part ====================
1068     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1069     if ( xWrappedObject.is() )
1070     {
1071         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1072         return xWrappedObject->getStatus( nAspect );
1073     }
1074     // end wrapping related part ====================
1075 
1076 	::osl::MutexGuard aGuard( m_aMutex );
1077 	if ( m_bDisposed )
1078 		throw lang::DisposedException(); // TODO
1079 
1080 	if ( m_nObjectState == -1 )
1081 		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object must be in running state!\n" ),
1082 									uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
1083 
1084 	sal_Int64 nResult = 0;
1085 
1086 #ifdef WNT
1087 	if ( m_bGotStatus && m_nStatusAspect == nAspect )
1088 		nResult = m_nStatus;
1089 	else if ( m_pOleComponent )
1090 	{
1091 		// OLE should allow to get status even in loaded state
1092 		// if ( m_nObjectState == embed::EmbedStates::LOADED )
1093 		//	changeState( m_nObjectState == embed::EmbedStates::RUNNING );
1094 
1095 		m_nStatus = m_pOleComponent->GetMiscStatus( nAspect );
1096 		m_nStatusAspect = nAspect;
1097 		m_bGotStatus = sal_True;
1098 		nResult = m_nStatus;
1099 	}
1100 #endif
1101 
1102 	// this implementation needs size to be provided after object loading/creating to work in optimal way
1103 	return ( nResult | embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD );
1104 }
1105 
1106 //----------------------------------------------
1107 void SAL_CALL OleEmbeddedObject::setContainerName( const ::rtl::OUString& sName )
1108 		throw ( uno::RuntimeException )
1109 {
1110     // begin wrapping related part ====================
1111     uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
1112     if ( xWrappedObject.is() )
1113     {
1114         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
1115         xWrappedObject->setContainerName( sName );
1116         return;
1117     }
1118     // end wrapping related part ====================
1119 
1120 	::osl::MutexGuard aGuard( m_aMutex );
1121 	if ( m_bDisposed )
1122 		throw lang::DisposedException(); // TODO
1123 
1124 	m_aContainerName = sName;
1125 }
1126 
1127 
1128