xref: /aoo41x/main/embeddedobj/source/msole/oleembed.cxx (revision 9807c9de)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_embeddedobj.hxx"

#include <oleembobj.hxx>
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/embed/EmbedVerbs.hpp>
#include <com/sun/star/embed/EntryInitModes.hpp>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/EmbedUpdateModes.hpp>
#include <com/sun/star/embed/Aspects.hpp>
#include <com/sun/star/embed/NeedsRunningStateException.hpp>
#include <com/sun/star/embed/StateChangeInProgressException.hpp>
#include <com/sun/star/embed/EmbedMisc.hpp>
#include <com/sun/star/embed/XEmbedObjectCreator.hpp>
#include <com/sun/star/io/XSeekable.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XLoadable.hpp>
#include <com/sun/star/document/XStorageBasedDocument.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/system/SystemShellExecute.hpp>
#include <com/sun/star/system/SystemShellExecuteFlags.hpp>

#include <rtl/logfile.hxx>
#include <cppuhelper/interfacecontainer.h>
#include <comphelper/mimeconfighelper.hxx>
#include <comphelper/storagehelper.hxx>
#include <comphelper/processfactory.hxx>

#include <targetstatecontrol.hxx>

#include <olecomponent.hxx>

#include "ownview.hxx"

using namespace ::com::sun::star;

#ifdef WNT
//----------------------------------------------
void OleEmbeddedObject::SwitchComponentToRunningState_Impl()
{
	if ( m_pOleComponent )
	{
		try
		{
			m_pOleComponent->RunObject();
		}
		catch( embed::UnreachableStateException& )
		{
			GetRidOfComponent();
			throw;
		}
		catch( embed::WrongStateException& )
		{
			GetRidOfComponent();
			throw;
		}
	}
	else
	{
		throw embed::UnreachableStateException();
	}
}

//----------------------------------------------
uno::Sequence< sal_Int32 > OleEmbeddedObject::GetReachableStatesList_Impl(
														const uno::Sequence< embed::VerbDescriptor >& aVerbList )
{
	uno::Sequence< sal_Int32 > aStates(2);
	aStates[0] = embed::EmbedStates::LOADED;
	aStates[1] = embed::EmbedStates::RUNNING;
	for ( sal_Int32 nInd = 0; nInd < aVerbList.getLength(); nInd++ )
		if ( aVerbList[nInd].VerbID == embed::EmbedVerbs::MS_OLEVERB_OPEN )
		{
			aStates.realloc(3);
			aStates[2] = embed::EmbedStates::ACTIVE;
		}

	return aStates;
}

//----------------------------------------------
uno::Sequence< sal_Int32 > OleEmbeddedObject::GetIntermediateVerbsSequence_Impl( sal_Int32 nNewState )
{
	OSL_ENSURE( m_nObjectState != embed::EmbedStates::LOADED, "Loaded object is switched to running state without verbs using!" );

	// actually there will be only one verb
	if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
	{
		uno::Sequence< sal_Int32 > aVerbs( 1 );
		aVerbs[0] = embed::EmbedVerbs::MS_OLEVERB_OPEN;
	}

	return uno::Sequence< sal_Int32 >();
}
#endif
//----------------------------------------------
void OleEmbeddedObject::MoveListeners()
{
	if ( m_pInterfaceContainer )
	{
        // move state change listeners
        {
            ::cppu::OInterfaceContainerHelper* pStateChangeContainer =
                m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< embed::XStateChangeListener >*) NULL ) );
            if ( pStateChangeContainer != NULL )
            {
                uno::Reference< embed::XStateChangeBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
                if ( xWrappedObject.is() )
                {
                    ::cppu::OInterfaceIteratorHelper pIterator( *pStateChangeContainer );
                    while ( pIterator.hasMoreElements() )
                    {
                        try
                        {
                            xWrappedObject->addStateChangeListener( (embed::XStateChangeListener*)pIterator.next() );
                        }
                        catch( uno::RuntimeException& )
                        {
                            pIterator.remove();
                        }
                    }
                }
            }
        }

        // move event listeners
        {
            ::cppu::OInterfaceContainerHelper* pEventContainer =
                m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< document::XEventListener >*) NULL ) );
            if ( pEventContainer != NULL )
            {
                uno::Reference< document::XEventBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
                if ( xWrappedObject.is() )
                {
                    ::cppu::OInterfaceIteratorHelper pIterator( *pEventContainer );
                    while ( pIterator.hasMoreElements() )
                    {
                        try
                        {
                            xWrappedObject->addEventListener( (document::XEventListener*)pIterator.next() );
                        }
                        catch( uno::RuntimeException& )
                        {
                            pIterator.remove();
                        }
                    }
                }
            }
        }

        // move close listeners
        {
            ::cppu::OInterfaceContainerHelper* pCloseContainer =
                m_pInterfaceContainer->getContainer( ::getCppuType( ( const uno::Reference< util::XCloseListener >*) NULL ) );
            if ( pCloseContainer != NULL )
            {
                uno::Reference< util::XCloseBroadcaster > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
                if ( xWrappedObject.is() )
                {
                    ::cppu::OInterfaceIteratorHelper pIterator( *pCloseContainer );
                    while ( pIterator.hasMoreElements() )
                    {
                        try
                        {
                            xWrappedObject->addCloseListener( (util::XCloseListener*)pIterator.next() );
                        }
                        catch( uno::RuntimeException& )
                        {
                            pIterator.remove();
                        }
                    }
                }
            }
        }

        delete m_pInterfaceContainer;
        m_pInterfaceContainer = NULL;
    }
}

//----------------------------------------------
uno::Reference< embed::XStorage > OleEmbeddedObject::CreateTemporarySubstorage( ::rtl::OUString& o_aStorageName )
{
    uno::Reference< embed::XStorage > xResult;

    for ( sal_Int32 nInd = 0; nInd < 32000 && !xResult.is(); nInd++ )
    {
        ::rtl::OUString aName = ::rtl::OUString::valueOf( nInd );
        aName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TMPSTOR" ) );
        aName += m_aEntryName;
        if ( !m_xParentStorage->hasByName( aName ) )
        {
            xResult = m_xParentStorage->openStorageElement( aName, embed::ElementModes::READWRITE );
            o_aStorageName = aName;
        }
    }

    if ( !xResult.is() )
    {
        o_aStorageName = ::rtl::OUString();
        throw uno::RuntimeException();
    }

    return xResult;
}

//----------------------------------------------
::rtl::OUString OleEmbeddedObject::MoveToTemporarySubstream()
{
    ::rtl::OUString aResult;
    for ( sal_Int32 nInd = 0; nInd < 32000 && !aResult.getLength(); nInd++ )
    {
        ::rtl::OUString aName = ::rtl::OUString::valueOf( nInd );
        aName += ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TMPSTREAM" ) );
        aName += m_aEntryName;
        if ( !m_xParentStorage->hasByName( aName ) )
        {
            m_xParentStorage->renameElement( m_aEntryName, aName );
            aResult = aName;
        }
    }

    if ( !aResult.getLength() )
        throw uno::RuntimeException();

    return aResult;
}

//----------------------------------------------
sal_Bool OleEmbeddedObject::TryToConvertToOOo()
{
    sal_Bool bResult = sal_False;

    ::rtl::OUString aStorageName;
    ::rtl::OUString aTmpStreamName;
    sal_Int32 nStep = 0;

    if ( m_pOleComponent || m_bReadOnly )
        return sal_False;

    try
    {
        changeState( embed::EmbedStates::LOADED );

        // the stream must be seekable
        uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY_THROW );
        xSeekable->seek( 0 );
        ::rtl::OUString aFilterName = OwnView_Impl::GetFilterNameFromExtentionAndInStream( m_xFactory, ::rtl::OUString(), m_xObjectStream->getInputStream() );

        // use the solution only for OOXML format currently
        if ( aFilterName.getLength()
          && ( aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "Calc MS Excel 2007 XML" ) ) )
            || aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "Impress MS PowerPoint 2007 XML" ) ) )
            || aFilterName.equals( ::rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM( "MS Word 2007 XML" ) ) ) ) )
        {
            uno::Reference< container::XNameAccess > xFilterFactory(
			    m_xFactory->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.document.FilterFactory" ) ),
			    uno::UNO_QUERY_THROW );

            ::rtl::OUString aDocServiceName;
		    uno::Any aFilterAnyData = xFilterFactory->getByName( aFilterName );
		    uno::Sequence< beans::PropertyValue > aFilterData;
		    if ( aFilterAnyData >>= aFilterData )
		    {
			    for ( sal_Int32 nInd = 0; nInd < aFilterData.getLength(); nInd++ )
				    if ( aFilterData[nInd].Name.equalsAscii( "DocumentService" ) )
					    aFilterData[nInd].Value >>= aDocServiceName;
		    }

            if ( aDocServiceName.getLength() )
            {
                // create the model
                uno::Sequence< uno::Any > aArguments(1);
                aArguments[0] <<= beans::NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "EmbeddedObject" ) ), uno::makeAny( (sal_Bool)sal_True ));

                uno::Reference< util::XCloseable > xDocument( m_xFactory->createInstanceWithArguments( aDocServiceName, aArguments ), uno::UNO_QUERY_THROW );
                uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY_THROW );
                uno::Reference< document::XStorageBasedDocument > xStorDoc( xDocument, uno::UNO_QUERY_THROW );

                // let the model behave as embedded one
                uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY_THROW );
		        uno::Sequence< beans::PropertyValue > aSeq( 1 );
		        aSeq[0].Name = ::rtl::OUString::createFromAscii( "SetEmbedded" );
		        aSeq[0].Value <<= sal_True;
		        xModel->attachResource( ::rtl::OUString(), aSeq );

                // load the model from the stream
	            uno::Sequence< beans::PropertyValue > aArgs( 5 );
                aArgs[0].Name = ::rtl::OUString::createFromAscii( "HierarchicalDocumentName" );
                aArgs[0].Value <<= m_aEntryName;
	            aArgs[1].Name = ::rtl::OUString::createFromAscii( "ReadOnly" );
	            aArgs[1].Value <<= sal_True;
	            aArgs[2].Name = ::rtl::OUString::createFromAscii( "FilterName" );
	            aArgs[2].Value <<= aFilterName;
                aArgs[3].Name = ::rtl::OUString::createFromAscii( "URL" );
                aArgs[3].Value <<= ::rtl::OUString::createFromAscii( "private:stream" );
                aArgs[4].Name = ::rtl::OUString::createFromAscii( "InputStream" );
                aArgs[4].Value <<= m_xObjectStream->getInputStream();

                xSeekable->seek( 0 );
                xLoadable->load( aArgs );

                // the model is successfuly loaded, create a new storage and store the model to the storage
                uno::Reference< embed::XStorage > xTmpStorage = CreateTemporarySubstorage( aStorageName );
                xStorDoc->storeToStorage( xTmpStorage, uno::Sequence< beans::PropertyValue >() );
                xDocument->close( sal_True );
                uno::Reference< beans::XPropertySet > xStorProps( xTmpStorage, uno::UNO_QUERY_THROW );
                ::rtl::OUString aMediaType;
                xStorProps->getPropertyValue( ::rtl::OUString::createFromAscii( "MediaType" ) ) >>= aMediaType;
                xTmpStorage->dispose();

                // look for the related embedded object factory
                ::comphelper::MimeConfigurationHelper aConfigHelper( m_xFactory );
                ::rtl::OUString aEmbedFactory;
	            if ( aMediaType.getLength() )
		            aEmbedFactory = aConfigHelper.GetFactoryNameByMediaType( aMediaType );

	            if ( !aEmbedFactory.getLength() )
                    throw uno::RuntimeException();

                uno::Reference< uno::XInterface > xFact = m_xFactory->createInstance( aEmbedFactory );

		        uno::Reference< embed::XEmbedObjectCreator > xEmbCreator( xFact, uno::UNO_QUERY_THROW );

                // now the object should be adjusted to become the wrapper
                nStep = 1;
		        uno::Reference< lang::XComponent > xComp( m_xObjectStream, uno::UNO_QUERY_THROW );
				xComp->dispose();
		        m_xObjectStream = uno::Reference< io::XStream >();
                m_nObjectState = -1;

                nStep = 2;
                aTmpStreamName = MoveToTemporarySubstream();

                nStep = 3;
                m_xParentStorage->renameElement( aStorageName, m_aEntryName );

                nStep = 4;
		        m_xWrappedObject.set( xEmbCreator->createInstanceInitFromEntry( m_xParentStorage, m_aEntryName, uno::Sequence< beans::PropertyValue >(), uno::Sequence< beans::PropertyValue >() ), uno::UNO_QUERY_THROW );

                bResult = sal_True; // the change is no more revertable
                try
                {
                    m_xParentStorage->removeElement( aTmpStreamName );
                }
                catch( uno::Exception& )
                {
                    // the success of the removing is not so important
                }
            }
        }
    }
    catch( uno::Exception& )
    {
        // repair the object if necessary
        switch( nStep )
        {
            case 4:
            case 3:
            if ( aTmpStreamName.getLength() && aTmpStreamName != m_aEntryName )
                try
                {
                    if ( m_xParentStorage->hasByName( m_aEntryName ) )
                        m_xParentStorage->removeElement( m_aEntryName );
                    m_xParentStorage->renameElement( aTmpStreamName, m_aEntryName );
                }
                catch ( uno::Exception& )
                {
                    try {
                        close( sal_True );
                    } catch( uno::Exception& ) {}

                    m_xParentStorage->dispose(); // ??? the storage has information loss, it should be closed without commiting!
                    throw uno::RuntimeException(); // the repairing is not possible
                }
            case 2:
                try
                {
                    m_xObjectStream = m_xParentStorage->openStreamElement( m_aEntryName, m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE );
                    m_nObjectState = embed::EmbedStates::LOADED;
                }
                catch( uno::Exception& )
                {
                    try {
                        close( sal_True );
                    } catch( uno::Exception& ) {}

                    throw uno::RuntimeException(); // the repairing is not possible
                }
                // no break as designed!

            case 1:
            case 0:
                if ( aStorageName.getLength() )
                    try {
                        m_xParentStorage->removeElement( aStorageName );
                    } catch( uno::Exception& ) { OSL_ASSERT( "Can not remove temporary storage!" ); }
                break;
        }
    }

    if ( bResult )
    {
        // the conversion was done successfuly, now the additional initializations should happen

        MoveListeners();
        m_xWrappedObject->setClientSite( m_xClientSite );
        if ( m_xParent.is() )
        {
            uno::Reference< container::XChild > xChild( m_xWrappedObject, uno::UNO_QUERY );
            if ( xChild.is() )
                xChild->setParent( m_xParent );
        }

    }

    return bResult;
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::changeState( sal_Int32 nNewState )
		throw ( embed::UnreachableStateException,
				embed::WrongStateException,
				uno::Exception,
				uno::RuntimeException )
{
	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::changeState" );

    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->changeState( nNewState );
        return;
    }
    // end wrapping related part ====================

	::osl::ResettableMutexGuard aGuard( m_aMutex );

	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	// in case the object is already in requested state
	if ( m_nObjectState == nNewState )
		return;

#ifdef WNT
	if ( m_pOleComponent )
	{
		if ( m_nTargetState != -1 )
		{
			// means that the object is currently trying to reach the target state
			throw embed::StateChangeInProgressException( ::rtl::OUString(),
														uno::Reference< uno::XInterface >(),
														m_nTargetState );
		}

		TargetStateControl_Impl aControl( m_nTargetState, nNewState );

		// TODO: additional verbs can be a problem, since nobody knows how the object
		//		 will behave after activation

		sal_Int32 nOldState = m_nObjectState;
		aGuard.clear();
		StateChangeNotification_Impl( sal_True, nOldState, nNewState );
		aGuard.reset();

		try
		{
			if ( nNewState == embed::EmbedStates::LOADED )
			{
				// This means just closing of the current object
				// If component can not be closed the object stays in loaded state
				// and it holds reference to "incomplete" component
				// If the object is switched to running state later
				// the component will become "complete"

				// the loaded state must be set before, because of notifications!
				m_nObjectState = nNewState;

				{
					VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
					m_pOleComponent->CloseObject();
				}

				// GetRidOfComponent();
				aGuard.clear();
				StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
				aGuard.reset();
			}
			else if ( nNewState == embed::EmbedStates::RUNNING || nNewState == embed::EmbedStates::ACTIVE )
			{
				if ( m_nObjectState == embed::EmbedStates::LOADED )
				{
					// if the target object is in loaded state and a different state is specified
					// as a new one the object first must be switched to running state.

					// the component can exist already in nonrunning state
					// it can be created during loading to detect type of object
					CreateOleComponentAndLoad_Impl( m_pOleComponent );

					SwitchComponentToRunningState_Impl();
					m_nObjectState = embed::EmbedStates::RUNNING;
					aGuard.clear();
					StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
					aGuard.reset();

					if ( m_pOleComponent && m_bHasSizeToSet )
					{
						aGuard.clear();
						try {
							m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
							m_bHasSizeToSet = sal_False;
						}
						catch( uno::Exception& ) {}
						aGuard.reset();
					}

					if ( m_nObjectState == nNewState )
						return;
				}

				// so now the object is either switched from Active to Running state or vise versa
				// the notification about object state change will be done asynchronously
				if ( m_nObjectState == embed::EmbedStates::RUNNING && nNewState == embed::EmbedStates::ACTIVE )
				{
					// execute OPEN verb, if object does not reach active state it is an object's problem
					aGuard.clear();
					m_pOleComponent->ExecuteVerb( embed::EmbedVerbs::MS_OLEVERB_OPEN );
					aGuard.reset();

					// some objects do not allow to set the size even in running state
					if ( m_pOleComponent && m_bHasSizeToSet )
					{
						aGuard.clear();
						try {
							m_pOleComponent->SetExtent( m_aSizeToSet, m_nAspectToSet );
							m_bHasSizeToSet = sal_False;
						}
						catch( uno::Exception& ) {}
						aGuard.reset();
					}

					m_nObjectState = nNewState;
				}
				else if ( m_nObjectState == embed::EmbedStates::ACTIVE && nNewState == embed::EmbedStates::RUNNING )
				{
					aGuard.clear();
					m_pOleComponent->CloseObject();
					m_pOleComponent->RunObject(); // Should not fail, the object already was active
					aGuard.reset();
					m_nObjectState = nNewState;
				}
				else
				{
					throw embed::UnreachableStateException();
				}
			}
			else
				throw embed::UnreachableStateException();
		}
		catch( uno::Exception& )
		{
			aGuard.clear();
			StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
			throw;
		}
	}
	else
#endif
	{
		throw embed::UnreachableStateException();
	}
}

//----------------------------------------------
uno::Sequence< sal_Int32 > SAL_CALL OleEmbeddedObject::getReachableStates()
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::getReachableStates" );

    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getReachableStates();
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

#ifdef WNT
	if ( m_pOleComponent )
	{
		if ( m_nObjectState == embed::EmbedStates::LOADED )
		{
			// the list of supported verbs can be retrieved only when object is in running state
			throw embed::NeedsRunningStateException(); // TODO:
		}

		// the list of states can only be guessed based on standard verbs,
		// since there is no way to detect what additional verbs do
		return GetReachableStatesList_Impl( m_pOleComponent->GetVerbList() );
	}
	else
#endif
	{
		return uno::Sequence< sal_Int32 >();
	}
}

//----------------------------------------------
sal_Int32 SAL_CALL OleEmbeddedObject::getCurrentState()
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getCurrentState();
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	// TODO: Shouldn't we ask object? ( I guess no )
	return m_nObjectState;
}

namespace
{
    bool lcl_CopyStream(uno::Reference<io::XInputStream> xIn, uno::Reference<io::XOutputStream> xOut)
    {
        const sal_Int32 nChunkSize = 4096;
        uno::Sequence< sal_Int8 > aData(nChunkSize);
        sal_Int32 nTotalRead = 0;
        sal_Int32 nRead;
        do
        {
            nRead = xIn->readBytes(aData, nChunkSize);
            nTotalRead += nRead;
            xOut->writeBytes(aData);
        } while (nRead == nChunkSize);
        return nTotalRead != 0;
    }

    //Dump the objects content to a tempfile, just the "CONTENTS" stream if
    //there is one for non-compound documents, otherwise the whole content.
    //
    //On success a file is returned which must be removed by the caller
    rtl::OUString lcl_ExtractObject(::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xFactory,
        ::com::sun::star::uno::Reference< ::com::sun::star::io::XStream > xObjectStream)
    {
        rtl::OUString sUrl;

        // the solution is only active for Unix systems
#ifndef WNT
        uno::Reference <beans::XPropertySet> xNativeTempFile(
            xFactory->createInstance(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.io.TempFile"))), uno::UNO_QUERY_THROW);
        uno::Reference < io::XStream > xStream(xNativeTempFile, uno::UNO_QUERY_THROW);

        uno::Sequence< uno::Any > aArgs( 2 );
        aArgs[0] <<= xObjectStream;
        aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
        uno::Reference< container::XNameContainer > xNameContainer(
            xFactory->createInstanceWithArguments(
                ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.OLESimpleStorage")),
                aArgs ), uno::UNO_QUERY_THROW );

        uno::Reference< io::XStream > xCONTENTS;
        xNameContainer->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONTENTS"))) >>= xCONTENTS;

        sal_Bool bCopied = xCONTENTS.is() && lcl_CopyStream(xCONTENTS->getInputStream(), xStream->getOutputStream());

        uno::Reference< io::XSeekable > xSeekableStor(xObjectStream, uno::UNO_QUERY);
        if (xSeekableStor.is())
            xSeekableStor->seek(0);

        if (!bCopied)
            bCopied = lcl_CopyStream(xObjectStream->getInputStream(), xStream->getOutputStream());

        if (bCopied)
        {
            xNativeTempFile->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RemoveFile")),
                uno::makeAny(sal_False));
            uno::Any aUrl = xNativeTempFile->getPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Uri")));
            aUrl >>= sUrl;

            xNativeTempFile = uno::Reference<beans::XPropertySet>();

            uno::Reference<ucb::XSimpleFileAccess> xSimpleFileAccess(
                xFactory->createInstance(
                    ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.ucb.SimpleFileAccess"))),
                    uno::UNO_QUERY_THROW);

            xSimpleFileAccess->setReadOnly(sUrl, sal_True);
        }
        else
        {
            xNativeTempFile->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RemoveFile")),
                uno::makeAny(sal_True));
        }
#endif
        return sUrl;
    }
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::doVerb( sal_Int32 nVerbID )
		throw ( lang::IllegalArgumentException,
				embed::WrongStateException,
				embed::UnreachableStateException,
				uno::Exception,
				uno::RuntimeException )
{
	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::doVerb" );

    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->doVerb( nVerbID );
        return;
    }
    // end wrapping related part ====================

	::osl::ResettableMutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

#ifdef WNT
	if ( m_pOleComponent )
	{
		sal_Int32 nOldState = m_nObjectState;

		// TODO/LATER detect target state here and do a notification
		// StateChangeNotification_Impl( sal_True, nOldState, nNewState );
		if ( m_nObjectState == embed::EmbedStates::LOADED )
		{
			// if the target object is in loaded state
			// it must be switched to running state to execute verb
			aGuard.clear();
			changeState( embed::EmbedStates::RUNNING );
			aGuard.reset();
		}

		try {
			if ( !m_pOleComponent )
				throw uno::RuntimeException();

			// ==== the STAMPIT related solution =============================
			m_aVerbExecutionController.StartControlExecution();
			// ===============================================================

			m_pOleComponent->ExecuteVerb( nVerbID );

			// ==== the STAMPIT related solution =============================
			sal_Bool bModifiedOnExecution = m_aVerbExecutionController.EndControlExecution_WasModified();

			// this workaround is implemented for STAMPIT object
			// if object was modified during verb execution it is saved here
			if ( bModifiedOnExecution && m_pOleComponent->IsDirty() )
				SaveObject_Impl();
			// ===============================================================
		}
		catch( uno::Exception& )
		{
			// ==== the STAMPIT related solution =============================
			m_aVerbExecutionController.EndControlExecution_WasModified();
			// ===============================================================

			aGuard.clear();
			StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
			throw;
		}

		// the following notification will be done asynchronously
		// StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
	}
	else
#endif
	{
		if ( nVerbID == -9 )
		{
			// the workaround verb to show the object in case no server is available

            // if it is possible, the object will be converted to OOo format
            if ( !m_bTriedConversion )
            {
                m_bTriedConversion = sal_True;
                if ( TryToConvertToOOo() )
                {
                    changeState( embed::EmbedStates::UI_ACTIVE );
                    return;
                }
            }

			if ( !m_pOwnView && m_xObjectStream.is() )
			{
				try {
					uno::Reference< io::XSeekable > xSeekable( m_xObjectStream, uno::UNO_QUERY );
					if ( xSeekable.is() )
						xSeekable->seek( 0 );

					m_pOwnView = new OwnView_Impl( m_xFactory, m_xObjectStream->getInputStream() );
					m_pOwnView->acquire();
				}
				catch( uno::RuntimeException& )
				{
					throw;
				}
				catch( uno::Exception& )
				{
				}
			}

            if ( !m_pOwnView || !m_pOwnView->Open() )
            {
                //Make a RO copy and see if the OS can find something to at
                //least display the content for us
                if (!m_aTempDumpURL.getLength())
                    m_aTempDumpURL = lcl_ExtractObject(m_xFactory, m_xObjectStream);

                if (m_aTempDumpURL.getLength())
                {
                    uno::Reference< ::com::sun::star::system::XSystemShellExecute > xSystemShellExecute(
                        ::com::sun::star::system::SystemShellExecute::create(
                            ::comphelper::getProcessComponentContext() ) );
                    xSystemShellExecute->execute(m_aTempDumpURL, ::rtl::OUString(), ::com::sun::star::system::SystemShellExecuteFlags::DEFAULTS);
                }
                else
                    throw embed::UnreachableStateException();
            }
		}
		else
		{

			throw embed::UnreachableStateException();
		}
	}
}

//----------------------------------------------
uno::Sequence< embed::VerbDescriptor > SAL_CALL OleEmbeddedObject::getSupportedVerbs()
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
	RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OleEmbeddedObject::getSupportedVerb" );

    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getSupportedVerbs();
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
#ifdef WNT
	if ( m_pOleComponent )
	{
		// registry could be used in this case
		// if ( m_nObjectState == embed::EmbedStates::LOADED )
		// {
		// 	// the list of supported verbs can be retrieved only when object is in running state
		// 	throw embed::NeedsRunningStateException(); // TODO:
		// }

		return m_pOleComponent->GetVerbList();
	}
	else
#endif
	{
		return uno::Sequence< embed::VerbDescriptor >();
	}
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::setClientSite(
				const uno::Reference< embed::XEmbeddedClient >& xClient )
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setClientSite( xClient );
        return;
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_xClientSite != xClient)
	{
		if ( m_nObjectState != embed::EmbedStates::LOADED && m_nObjectState != embed::EmbedStates::RUNNING )
			throw embed::WrongStateException(
									::rtl::OUString::createFromAscii( "The client site can not be set currently!\n" ),
									uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

		m_xClientSite = xClient;
	}
}

//----------------------------------------------
uno::Reference< embed::XEmbeddedClient > SAL_CALL OleEmbeddedObject::getClientSite()
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getClientSite();
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	return m_xClientSite;
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::update()
		throw ( embed::WrongStateException,
				uno::Exception,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->update();
        return;
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	if ( m_nUpdateMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE )
	{
		// TODO: update view representation
	}
	else
	{
		// the object must be up to date
		OSL_ENSURE( m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE, "Unknown update mode!\n" );
	}
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::setUpdateMode( sal_Int32 nMode )
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setUpdateMode( nMode );
        return;
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object has no persistence!\n" ),
										uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	OSL_ENSURE( nMode == embed::EmbedUpdateModes::ALWAYS_UPDATE
					|| nMode == embed::EmbedUpdateModes::EXPLICIT_UPDATE,
				"Unknown update mode!\n" );
	m_nUpdateMode = nMode;
}

//----------------------------------------------
sal_Int64 SAL_CALL OleEmbeddedObject::getStatus( sal_Int64
    nAspect
)
		throw ( embed::WrongStateException,
				uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        return xWrappedObject->getStatus( nAspect );
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	if ( m_nObjectState == -1 )
		throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object must be in running state!\n" ),
									uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );

	sal_Int64 nResult = 0;

#ifdef WNT
	if ( m_bGotStatus && m_nStatusAspect == nAspect )
		nResult = m_nStatus;
	else if ( m_pOleComponent )
	{
		// OLE should allow to get status even in loaded state
		// if ( m_nObjectState == embed::EmbedStates::LOADED )
		//	changeState( m_nObjectState == embed::EmbedStates::RUNNING );

		m_nStatus = m_pOleComponent->GetMiscStatus( nAspect );
		m_nStatusAspect = nAspect;
		m_bGotStatus = sal_True;
		nResult = m_nStatus;
	}
#endif

	// this implementation needs size to be provided after object loading/creating to work in optimal way
	return ( nResult | embed::EmbedMisc::EMBED_NEEDSSIZEONLOAD );
}

//----------------------------------------------
void SAL_CALL OleEmbeddedObject::setContainerName( const ::rtl::OUString& sName )
		throw ( uno::RuntimeException )
{
    // begin wrapping related part ====================
    uno::Reference< embed::XEmbeddedObject > xWrappedObject = m_xWrappedObject;
    if ( xWrappedObject.is() )
    {
        // the object was converted to OOo embedded object, the current implementation is now only a wrapper
        xWrappedObject->setContainerName( sName );
        return;
    }
    // end wrapping related part ====================

	::osl::MutexGuard aGuard( m_aMutex );
	if ( m_bDisposed )
		throw lang::DisposedException(); // TODO

	m_aContainerName = sName;
}