| /************************************************************** | |
| * | |
| * 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 successfully 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 committing! | |
| 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 successfully, 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 ) | |
| { | |
| 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() | |
| { | |
| 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() | |
| { | |
| // 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 ) | |
| { | |
| 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() | |
| { | |
| 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 ) | |
| { | |
| // 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() | |
| { | |
| // 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() | |
| { | |
| // 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 ) | |
| { | |
| // 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 | |
| ) | |
| { | |
| // 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 ) | |
| { | |
| // 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; | |
| } |