/**************************************************************
*
* 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;
}