1bfd08df8SAndrew Rist /************************************************************** 2cdf0e10cSrcweir * 3bfd08df8SAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one 4bfd08df8SAndrew Rist * or more contributor license agreements. See the NOTICE file 5bfd08df8SAndrew Rist * distributed with this work for additional information 6bfd08df8SAndrew Rist * regarding copyright ownership. The ASF licenses this file 7bfd08df8SAndrew Rist * to you under the Apache License, Version 2.0 (the 8bfd08df8SAndrew Rist * "License"); you may not use this file except in compliance 9bfd08df8SAndrew Rist * with the License. You may obtain a copy of the License at 10bfd08df8SAndrew Rist * 11bfd08df8SAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0 12bfd08df8SAndrew Rist * 13bfd08df8SAndrew Rist * Unless required by applicable law or agreed to in writing, 14bfd08df8SAndrew Rist * software distributed under the License is distributed on an 15bfd08df8SAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16bfd08df8SAndrew Rist * KIND, either express or implied. See the License for the 17bfd08df8SAndrew Rist * specific language governing permissions and limitations 18bfd08df8SAndrew Rist * under the License. 19bfd08df8SAndrew Rist * 20bfd08df8SAndrew Rist *************************************************************/ 21bfd08df8SAndrew Rist 22bfd08df8SAndrew Rist 23cdf0e10cSrcweir 24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove 25cdf0e10cSrcweir #include "precompiled_embeddedobj.hxx" 26cdf0e10cSrcweir 27cdf0e10cSrcweir #include <commonembobj.hxx> 28cdf0e10cSrcweir #include <com/sun/star/embed/Aspects.hpp> 29cdf0e10cSrcweir #include <com/sun/star/document/XStorageBasedDocument.hpp> 30cdf0e10cSrcweir #include <com/sun/star/embed/EmbedStates.hpp> 31cdf0e10cSrcweir #include <com/sun/star/embed/EmbedVerbs.hpp> 32cdf0e10cSrcweir #include <com/sun/star/embed/EntryInitModes.hpp> 33cdf0e10cSrcweir #include <com/sun/star/embed/XStorage.hpp> 34cdf0e10cSrcweir #include <com/sun/star/embed/XOptimizedStorage.hpp> 35cdf0e10cSrcweir #include <com/sun/star/embed/ElementModes.hpp> 36cdf0e10cSrcweir #include <com/sun/star/embed/EmbedUpdateModes.hpp> 37cdf0e10cSrcweir #include <com/sun/star/frame/XModel.hpp> 38cdf0e10cSrcweir #include <com/sun/star/frame/XStorable.hpp> 39cdf0e10cSrcweir #include <com/sun/star/frame/XLoadable.hpp> 40cdf0e10cSrcweir #include <com/sun/star/frame/XComponentLoader.hpp> 41cdf0e10cSrcweir #include <com/sun/star/frame/XModule.hpp> 42cdf0e10cSrcweir #include <com/sun/star/lang/XMultiServiceFactory.hpp> 43cdf0e10cSrcweir #include <com/sun/star/lang/XSingleServiceFactory.hpp> 44cdf0e10cSrcweir #include <com/sun/star/lang/DisposedException.hpp> 45cdf0e10cSrcweir #include <com/sun/star/util/XModifiable.hpp> 46cdf0e10cSrcweir 47cdf0e10cSrcweir #ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCEESS_HPP_ 48cdf0e10cSrcweir #include <com/sun/star/container/XNameAccess.hpp> 49cdf0e10cSrcweir #endif 50cdf0e10cSrcweir #include <com/sun/star/container/XChild.hpp> 51cdf0e10cSrcweir #include <com/sun/star/util/XCloseable.hpp> 52cdf0e10cSrcweir #include <com/sun/star/beans/XPropertySet.hpp> 53cdf0e10cSrcweir #include <com/sun/star/beans/IllegalTypeException.hpp> 54cdf0e10cSrcweir #include <com/sun/star/chart2/XChartDocument.hpp> 55cdf0e10cSrcweir 56cdf0e10cSrcweir #include <comphelper/fileformat.h> 57cdf0e10cSrcweir #include <comphelper/storagehelper.hxx> 58cdf0e10cSrcweir #include <comphelper/mimeconfighelper.hxx> 59cdf0e10cSrcweir #include <comphelper/namedvaluecollection.hxx> 60cdf0e10cSrcweir 61cdf0e10cSrcweir #include <rtl/logfile.hxx> 62cdf0e10cSrcweir 63cdf0e10cSrcweir #include <tools/diagnose_ex.h> 64cdf0e10cSrcweir 65cdf0e10cSrcweir #define USE_STORAGEBASED_DOCUMENT 66cdf0e10cSrcweir 67cdf0e10cSrcweir using namespace ::com::sun::star; 68cdf0e10cSrcweir 69cdf0e10cSrcweir 70cdf0e10cSrcweir //------------------------------------------------------ 71cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > GetValuableArgs_Impl( const uno::Sequence< beans::PropertyValue >& aMedDescr, 72cdf0e10cSrcweir sal_Bool bCanUseDocumentBaseURL ) 73cdf0e10cSrcweir { 74cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aResult; 75cdf0e10cSrcweir sal_Int32 nResLen = 0; 76cdf0e10cSrcweir 77cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < aMedDescr.getLength(); nInd++ ) 78cdf0e10cSrcweir { 79cdf0e10cSrcweir if ( aMedDescr[nInd].Name.equalsAscii( "ComponentData" ) 80cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "DocumentTitle" ) 81cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "InteractionHandler" ) 82cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "JumpMark" ) 83cdf0e10cSrcweir // || aMedDescr[nInd].Name.equalsAscii( "Password" ) makes no sence for embedded objects 84cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "Preview" ) 85cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "ReadOnly" ) 86cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "StartPresentation" ) 87cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "RepairPackage" ) 88cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "StatusIndicator" ) 89cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "ViewData" ) 90cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "ViewId" ) 91cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "MacroExecutionMode" ) 92cdf0e10cSrcweir || aMedDescr[nInd].Name.equalsAscii( "UpdateDocMode" ) 93cdf0e10cSrcweir || (aMedDescr[nInd].Name.equalsAscii( "DocumentBaseURL" ) && bCanUseDocumentBaseURL) ) 94cdf0e10cSrcweir { 95cdf0e10cSrcweir aResult.realloc( ++nResLen ); 96cdf0e10cSrcweir aResult[nResLen-1] = aMedDescr[nInd]; 97cdf0e10cSrcweir } 98cdf0e10cSrcweir } 99cdf0e10cSrcweir 100cdf0e10cSrcweir return aResult; 101cdf0e10cSrcweir } 102cdf0e10cSrcweir 103cdf0e10cSrcweir //------------------------------------------------------ 104cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > addAsTemplate( const uno::Sequence< beans::PropertyValue >& aOrig ) 105cdf0e10cSrcweir { 106cdf0e10cSrcweir sal_Bool bAsTemplateSet = sal_False; 107cdf0e10cSrcweir sal_Int32 nLength = aOrig.getLength(); 108cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aResult( nLength ); 109cdf0e10cSrcweir 110cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < nLength; nInd++ ) 111cdf0e10cSrcweir { 112cdf0e10cSrcweir aResult[nInd].Name = aOrig[nInd].Name; 113cdf0e10cSrcweir if ( aResult[nInd].Name.equalsAscii( "AsTemplate" ) ) 114cdf0e10cSrcweir { 115cdf0e10cSrcweir aResult[nInd].Value <<= sal_True; 116cdf0e10cSrcweir bAsTemplateSet = sal_True; 117cdf0e10cSrcweir } 118cdf0e10cSrcweir else 119cdf0e10cSrcweir aResult[nInd].Value = aOrig[nInd].Value; 120cdf0e10cSrcweir } 121cdf0e10cSrcweir 122cdf0e10cSrcweir if ( !bAsTemplateSet ) 123cdf0e10cSrcweir { 124cdf0e10cSrcweir aResult.realloc( nLength + 1 ); 125cdf0e10cSrcweir aResult[nLength].Name = ::rtl::OUString::createFromAscii( "AsTemplate" ); 126cdf0e10cSrcweir aResult[nLength].Value <<= sal_True; 127cdf0e10cSrcweir } 128cdf0e10cSrcweir 129cdf0e10cSrcweir return aResult; 130cdf0e10cSrcweir } 131cdf0e10cSrcweir 132cdf0e10cSrcweir //------------------------------------------------------ 133cdf0e10cSrcweir uno::Reference< io::XInputStream > createTempInpStreamFromStor( 134cdf0e10cSrcweir const uno::Reference< embed::XStorage >& xStorage, 135cdf0e10cSrcweir const uno::Reference< lang::XMultiServiceFactory >& xFactory ) 136cdf0e10cSrcweir { 137cdf0e10cSrcweir OSL_ENSURE( xStorage.is(), "The storage can not be empty!" ); 138cdf0e10cSrcweir 139cdf0e10cSrcweir uno::Reference< io::XInputStream > xResult; 140cdf0e10cSrcweir 141cdf0e10cSrcweir const ::rtl::OUString aServiceName ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.io.TempFile" ) ); 142cdf0e10cSrcweir uno::Reference < io::XStream > xTempStream = uno::Reference < io::XStream > ( 143cdf0e10cSrcweir xFactory->createInstance ( aServiceName ), 144cdf0e10cSrcweir uno::UNO_QUERY ); 145cdf0e10cSrcweir if ( xTempStream.is() ) 146cdf0e10cSrcweir { 147cdf0e10cSrcweir uno::Reference < lang::XSingleServiceFactory > xStorageFactory( 148cdf0e10cSrcweir xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.embed.StorageFactory" ) ), 149cdf0e10cSrcweir uno::UNO_QUERY ); 150cdf0e10cSrcweir 151cdf0e10cSrcweir uno::Sequence< uno::Any > aArgs( 2 ); 152cdf0e10cSrcweir aArgs[0] <<= xTempStream; 153cdf0e10cSrcweir aArgs[1] <<= embed::ElementModes::READWRITE; 154cdf0e10cSrcweir uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ), 155cdf0e10cSrcweir uno::UNO_QUERY ); 156cdf0e10cSrcweir if ( !xTempStorage.is() ) 157cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: 158cdf0e10cSrcweir 159cdf0e10cSrcweir try 160cdf0e10cSrcweir { 161cdf0e10cSrcweir xStorage->copyToStorage( xTempStorage ); 162cdf0e10cSrcweir } catch( uno::Exception& e ) 163cdf0e10cSrcweir { 164cdf0e10cSrcweir throw embed::StorageWrappedTargetException( 165cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "Can't copy storage!" ), 166cdf0e10cSrcweir uno::Reference< uno::XInterface >(), 167cdf0e10cSrcweir uno::makeAny( e ) ); 168cdf0e10cSrcweir } 169cdf0e10cSrcweir 170cdf0e10cSrcweir try { 171cdf0e10cSrcweir uno::Reference< lang::XComponent > xComponent( xTempStorage, uno::UNO_QUERY ); 172cdf0e10cSrcweir OSL_ENSURE( xComponent.is(), "Wrong storage implementation!" ); 173cdf0e10cSrcweir if ( xComponent.is() ) 174cdf0e10cSrcweir xComponent->dispose(); 175cdf0e10cSrcweir } 176cdf0e10cSrcweir catch ( uno::Exception& ) 177cdf0e10cSrcweir { 178cdf0e10cSrcweir } 179cdf0e10cSrcweir 180cdf0e10cSrcweir try { 181cdf0e10cSrcweir uno::Reference< io::XOutputStream > xTempOut = xTempStream->getOutputStream(); 182cdf0e10cSrcweir if ( xTempOut.is() ) 183cdf0e10cSrcweir xTempOut->closeOutput(); 184cdf0e10cSrcweir } 185cdf0e10cSrcweir catch ( uno::Exception& ) 186cdf0e10cSrcweir { 187cdf0e10cSrcweir } 188cdf0e10cSrcweir 189cdf0e10cSrcweir xResult = xTempStream->getInputStream(); 190cdf0e10cSrcweir } 191cdf0e10cSrcweir 192cdf0e10cSrcweir return xResult; 193cdf0e10cSrcweir 194cdf0e10cSrcweir } 195cdf0e10cSrcweir 196cdf0e10cSrcweir //------------------------------------------------------ 197cdf0e10cSrcweir static void TransferMediaType( const uno::Reference< embed::XStorage >& i_rSource, const uno::Reference< embed::XStorage >& i_rTarget ) 198cdf0e10cSrcweir { 199cdf0e10cSrcweir try 200cdf0e10cSrcweir { 201cdf0e10cSrcweir const uno::Reference< beans::XPropertySet > xSourceProps( i_rSource, uno::UNO_QUERY_THROW ); 202cdf0e10cSrcweir const uno::Reference< beans::XPropertySet > xTargetProps( i_rTarget, uno::UNO_QUERY_THROW ); 203cdf0e10cSrcweir const ::rtl::OUString sMediaTypePropName( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ); 204cdf0e10cSrcweir xTargetProps->setPropertyValue( sMediaTypePropName, xSourceProps->getPropertyValue( sMediaTypePropName ) ); 205cdf0e10cSrcweir } 206cdf0e10cSrcweir catch( const uno::Exception& ) 207cdf0e10cSrcweir { 208cdf0e10cSrcweir DBG_UNHANDLED_EXCEPTION(); 209cdf0e10cSrcweir } 210cdf0e10cSrcweir } 211cdf0e10cSrcweir 212cdf0e10cSrcweir //------------------------------------------------------ 213cdf0e10cSrcweir static uno::Reference< util::XCloseable > CreateDocument( const uno::Reference< lang::XMultiServiceFactory >& _rxFactory, 214cdf0e10cSrcweir const ::rtl::OUString& _rDocumentServiceName, bool _bEmbeddedScriptSupport, const bool i_bDocumentRecoverySupport ) 215cdf0e10cSrcweir { 216cdf0e10cSrcweir ::comphelper::NamedValueCollection aArguments; 217cdf0e10cSrcweir aArguments.put( "EmbeddedObject", (sal_Bool)sal_True ); 218cdf0e10cSrcweir aArguments.put( "EmbeddedScriptSupport", (sal_Bool)_bEmbeddedScriptSupport ); 219cdf0e10cSrcweir aArguments.put( "DocumentRecoverySupport", (sal_Bool)i_bDocumentRecoverySupport ); 220cdf0e10cSrcweir 221cdf0e10cSrcweir uno::Reference< uno::XInterface > xDocument; 222cdf0e10cSrcweir try 223cdf0e10cSrcweir { 224cdf0e10cSrcweir xDocument = _rxFactory->createInstanceWithArguments( _rDocumentServiceName, aArguments.getWrappedPropertyValues() ); 225cdf0e10cSrcweir } 226cdf0e10cSrcweir catch( const uno::Exception& ) 227cdf0e10cSrcweir { 228cdf0e10cSrcweir // if an embedded object implementation does not support XInitialization, 229cdf0e10cSrcweir // the default factory from cppuhelper will throw an 230cdf0e10cSrcweir // IllegalArgumentException when we try to create the instance with arguments. 231cdf0e10cSrcweir // Okay, so we fall back to creating the instance without any arguments. 232cdf0e10cSrcweir OSL_ASSERT("Consider implementing interface XInitialization to avoid duplicate construction"); 233cdf0e10cSrcweir xDocument = _rxFactory->createInstance( _rDocumentServiceName ); 234cdf0e10cSrcweir } 235cdf0e10cSrcweir 236cdf0e10cSrcweir return uno::Reference< util::XCloseable >( xDocument, uno::UNO_QUERY ); 237cdf0e10cSrcweir } 238cdf0e10cSrcweir 239cdf0e10cSrcweir //------------------------------------------------------ 240cdf0e10cSrcweir static void SetDocToEmbedded( const uno::Reference< frame::XModel > xDocument, const ::rtl::OUString& aModuleName ) 241cdf0e10cSrcweir { 242cdf0e10cSrcweir if ( xDocument.is() ) 243cdf0e10cSrcweir { 244cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aSeq( 1 ); 245cdf0e10cSrcweir aSeq[0].Name = ::rtl::OUString::createFromAscii( "SetEmbedded" ); 246cdf0e10cSrcweir aSeq[0].Value <<= sal_True; 247cdf0e10cSrcweir xDocument->attachResource( ::rtl::OUString(), aSeq ); 248cdf0e10cSrcweir 249cdf0e10cSrcweir if ( aModuleName.getLength() ) 250cdf0e10cSrcweir { 251cdf0e10cSrcweir try 252cdf0e10cSrcweir { 253cdf0e10cSrcweir uno::Reference< frame::XModule > xModule( xDocument, uno::UNO_QUERY_THROW ); 254cdf0e10cSrcweir xModule->setIdentifier( aModuleName ); 255cdf0e10cSrcweir } 256cdf0e10cSrcweir catch( uno::Exception& ) 257cdf0e10cSrcweir {} 258cdf0e10cSrcweir } 259cdf0e10cSrcweir } 260cdf0e10cSrcweir } 261cdf0e10cSrcweir 262cdf0e10cSrcweir //------------------------------------------------------ 263cdf0e10cSrcweir void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage, 264cdf0e10cSrcweir const uno::Reference< embed::XStorage >& xNewObjectStorage, 265cdf0e10cSrcweir const ::rtl::OUString& aNewName ) 266cdf0e10cSrcweir { 267cdf0e10cSrcweir if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) ) 268cdf0e10cSrcweir { 269cdf0e10cSrcweir OSL_ENSURE( xNewObjectStorage == m_xObjectStorage, "The storage must be the same!\n" ); 270cdf0e10cSrcweir return; 271cdf0e10cSrcweir } 272cdf0e10cSrcweir 273cdf0e10cSrcweir uno::Reference< lang::XComponent > xComponent( m_xObjectStorage, uno::UNO_QUERY ); 274cdf0e10cSrcweir OSL_ENSURE( !m_xObjectStorage.is() || xComponent.is(), "Wrong storage implementation!" ); 275cdf0e10cSrcweir 276cdf0e10cSrcweir m_xObjectStorage = xNewObjectStorage; 277cdf0e10cSrcweir m_xParentStorage = xNewParentStorage; 278cdf0e10cSrcweir m_aEntryName = aNewName; 279cdf0e10cSrcweir 280cdf0e10cSrcweir #ifdef USE_STORAGEBASED_DOCUMENT 281cdf0e10cSrcweir // the linked document should not be switched 282cdf0e10cSrcweir if ( !m_bIsLink ) 283cdf0e10cSrcweir { 284cdf0e10cSrcweir uno::Reference< document::XStorageBasedDocument > xDoc( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 285cdf0e10cSrcweir if ( xDoc.is() ) 286cdf0e10cSrcweir SwitchDocToStorage_Impl( xDoc, m_xObjectStorage ); 287cdf0e10cSrcweir } 288cdf0e10cSrcweir #endif 289cdf0e10cSrcweir 290cdf0e10cSrcweir try { 291cdf0e10cSrcweir if ( xComponent.is() ) 292cdf0e10cSrcweir xComponent->dispose(); 293cdf0e10cSrcweir } 294cdf0e10cSrcweir catch ( uno::Exception& ) 295cdf0e10cSrcweir { 296cdf0e10cSrcweir } 297cdf0e10cSrcweir } 298cdf0e10cSrcweir 299cdf0e10cSrcweir //------------------------------------------------------ 300cdf0e10cSrcweir void OCommonEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage, 301cdf0e10cSrcweir const ::rtl::OUString& aNewName ) 302cdf0e10cSrcweir { 303cdf0e10cSrcweir if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) ) 304cdf0e10cSrcweir return; 305cdf0e10cSrcweir 306cdf0e10cSrcweir sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE; 307cdf0e10cSrcweir 308cdf0e10cSrcweir uno::Reference< embed::XStorage > xNewOwnStorage = xNewParentStorage->openStorageElement( aNewName, nStorageMode ); 309cdf0e10cSrcweir OSL_ENSURE( xNewOwnStorage.is(), "The method can not return empty reference!" ); 310cdf0e10cSrcweir 311cdf0e10cSrcweir SwitchOwnPersistence( xNewParentStorage, xNewOwnStorage, aNewName ); 312cdf0e10cSrcweir } 313cdf0e10cSrcweir 314cdf0e10cSrcweir //------------------------------------------------------ 315cdf0e10cSrcweir void OCommonEmbeddedObject::EmbedAndReparentDoc_Impl( const uno::Reference< util::XCloseable >& i_rxDocument ) const 316cdf0e10cSrcweir { 317cdf0e10cSrcweir SetDocToEmbedded( uno::Reference< frame::XModel >( i_rxDocument, uno::UNO_QUERY ), m_aModuleName ); 318cdf0e10cSrcweir 319cdf0e10cSrcweir try 320cdf0e10cSrcweir { 321cdf0e10cSrcweir uno::Reference < container::XChild > xChild( i_rxDocument, uno::UNO_QUERY ); 322cdf0e10cSrcweir if ( xChild.is() ) 323cdf0e10cSrcweir xChild->setParent( m_xParent ); 324cdf0e10cSrcweir } 325cdf0e10cSrcweir catch( const lang::NoSupportException & ) 326cdf0e10cSrcweir { 327cdf0e10cSrcweir OSL_ENSURE( false, "OCommonEmbeddedObject::EmbedAndReparentDoc: cannot set parent at document!" ); 328cdf0e10cSrcweir } 329cdf0e10cSrcweir } 330cdf0e10cSrcweir 331cdf0e10cSrcweir //------------------------------------------------------ 332cdf0e10cSrcweir uno::Reference< util::XCloseable > OCommonEmbeddedObject::InitNewDocument_Impl() 333cdf0e10cSrcweir { 334cdf0e10cSrcweir uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xFactory, GetDocumentServiceName(), 335cdf0e10cSrcweir m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) ); 336cdf0e10cSrcweir 337cdf0e10cSrcweir uno::Reference< frame::XModel > xModel( xDocument, uno::UNO_QUERY ); 338cdf0e10cSrcweir uno::Reference< frame::XLoadable > xLoadable( xModel, uno::UNO_QUERY ); 339cdf0e10cSrcweir if ( !xLoadable.is() ) 340cdf0e10cSrcweir throw uno::RuntimeException(); 341cdf0e10cSrcweir 342cdf0e10cSrcweir try 343cdf0e10cSrcweir { 344cdf0e10cSrcweir // set the document mode to embedded as the first action on document!!! 345cdf0e10cSrcweir EmbedAndReparentDoc_Impl( xDocument ); 346cdf0e10cSrcweir 347cdf0e10cSrcweir // if we have a storage to recover the document from, do not use initNew, but instead load from that storage 348cdf0e10cSrcweir bool bInitNew = true; 349cdf0e10cSrcweir if ( m_xRecoveryStorage.is() ) 350cdf0e10cSrcweir { 351cdf0e10cSrcweir uno::Reference< document::XStorageBasedDocument > xDoc( xLoadable, uno::UNO_QUERY ); 352cdf0e10cSrcweir OSL_ENSURE( xDoc.is(), "OCommonEmbeddedObject::InitNewDocument_Impl: cannot recover from a storage when the document is not storage based!" ); 353cdf0e10cSrcweir if ( xDoc.is() ) 354cdf0e10cSrcweir { 355cdf0e10cSrcweir ::comphelper::NamedValueCollection aLoadArgs; 356cdf0e10cSrcweir FillDefaultLoadArgs_Impl( m_xRecoveryStorage, aLoadArgs ); 357cdf0e10cSrcweir 358cdf0e10cSrcweir xDoc->loadFromStorage( m_xRecoveryStorage, aLoadArgs.getPropertyValues() ); 359cdf0e10cSrcweir SwitchDocToStorage_Impl( xDoc, m_xObjectStorage ); 360cdf0e10cSrcweir bInitNew = false; 361cdf0e10cSrcweir } 362cdf0e10cSrcweir } 363cdf0e10cSrcweir 364cdf0e10cSrcweir if ( bInitNew ) 365cdf0e10cSrcweir { 366cdf0e10cSrcweir // init document as a new 367cdf0e10cSrcweir xLoadable->initNew(); 368cdf0e10cSrcweir } 369cdf0e10cSrcweir xModel->attachResource( xModel->getURL(), m_aDocMediaDescriptor ); 370cdf0e10cSrcweir } 371cdf0e10cSrcweir catch( uno::Exception& ) 372cdf0e10cSrcweir { 373cdf0e10cSrcweir uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY ); 374cdf0e10cSrcweir if ( xCloseable.is() ) 375cdf0e10cSrcweir { 376cdf0e10cSrcweir try 377cdf0e10cSrcweir { 378cdf0e10cSrcweir xCloseable->close( sal_True ); 379cdf0e10cSrcweir } 380cdf0e10cSrcweir catch( uno::Exception& ) 381cdf0e10cSrcweir { 382cdf0e10cSrcweir } 383cdf0e10cSrcweir } 384cdf0e10cSrcweir 385cdf0e10cSrcweir throw; // TODO 386cdf0e10cSrcweir } 387cdf0e10cSrcweir 388cdf0e10cSrcweir return xDocument; 389cdf0e10cSrcweir } 390cdf0e10cSrcweir 391cdf0e10cSrcweir //------------------------------------------------------ 392cdf0e10cSrcweir uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadLink_Impl() 393cdf0e10cSrcweir { 394cdf0e10cSrcweir uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xFactory, GetDocumentServiceName(), 395cdf0e10cSrcweir m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) ); 396cdf0e10cSrcweir 397cdf0e10cSrcweir uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY ); 398cdf0e10cSrcweir if ( !xLoadable.is() ) 399cdf0e10cSrcweir throw uno::RuntimeException(); 400cdf0e10cSrcweir 401cdf0e10cSrcweir sal_Int32 nLen = 2; 402cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aArgs( nLen ); 403cdf0e10cSrcweir aArgs[0].Name = ::rtl::OUString::createFromAscii( "URL" ); 404cdf0e10cSrcweir aArgs[0].Value <<= m_aLinkURL; 405cdf0e10cSrcweir aArgs[1].Name = ::rtl::OUString::createFromAscii( "FilterName" ); 406cdf0e10cSrcweir aArgs[1].Value <<= m_aLinkFilterName; 407cdf0e10cSrcweir if ( m_bLinkHasPassword ) 408cdf0e10cSrcweir { 409cdf0e10cSrcweir aArgs.realloc( ++nLen ); 410cdf0e10cSrcweir aArgs[nLen-1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Password" ) ); 411cdf0e10cSrcweir aArgs[nLen-1].Value <<= m_aLinkPassword; 412cdf0e10cSrcweir } 413cdf0e10cSrcweir 414cdf0e10cSrcweir aArgs.realloc( m_aDocMediaDescriptor.getLength() + nLen ); 415cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < m_aDocMediaDescriptor.getLength(); nInd++ ) 416cdf0e10cSrcweir { 417cdf0e10cSrcweir aArgs[nInd+nLen].Name = m_aDocMediaDescriptor[nInd].Name; 418cdf0e10cSrcweir aArgs[nInd+nLen].Value = m_aDocMediaDescriptor[nInd].Value; 419cdf0e10cSrcweir } 420cdf0e10cSrcweir 421cdf0e10cSrcweir try 422cdf0e10cSrcweir { 423cdf0e10cSrcweir // the document is not really an embedded one, it is a link 424cdf0e10cSrcweir EmbedAndReparentDoc_Impl( xDocument ); 425cdf0e10cSrcweir 426cdf0e10cSrcweir // load the document 427cdf0e10cSrcweir xLoadable->load( aArgs ); 428cdf0e10cSrcweir 429cdf0e10cSrcweir if ( !m_bLinkHasPassword ) 430cdf0e10cSrcweir { 431cdf0e10cSrcweir // check if there is a password to cache 432cdf0e10cSrcweir uno::Reference< frame::XModel > xModel( xLoadable, uno::UNO_QUERY_THROW ); 433cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aProps = xModel->getArgs(); 434cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < aProps.getLength(); nInd++ ) 435cdf0e10cSrcweir if ( aProps[nInd].Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Password" ) ) ) 436cdf0e10cSrcweir && ( aProps[nInd].Value >>= m_aLinkPassword ) ) 437cdf0e10cSrcweir { 438cdf0e10cSrcweir m_bLinkHasPassword = sal_True; 439cdf0e10cSrcweir break; 440cdf0e10cSrcweir } 441cdf0e10cSrcweir } 442cdf0e10cSrcweir } 443cdf0e10cSrcweir catch( uno::Exception& ) 444cdf0e10cSrcweir { 445cdf0e10cSrcweir uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY ); 446cdf0e10cSrcweir if ( xCloseable.is() ) 447cdf0e10cSrcweir { 448cdf0e10cSrcweir try 449cdf0e10cSrcweir { 450cdf0e10cSrcweir xCloseable->close( sal_True ); 451cdf0e10cSrcweir } 452cdf0e10cSrcweir catch( uno::Exception& ) 453cdf0e10cSrcweir { 454cdf0e10cSrcweir } 455cdf0e10cSrcweir } 456cdf0e10cSrcweir 457cdf0e10cSrcweir throw; // TODO 458cdf0e10cSrcweir } 459cdf0e10cSrcweir 460cdf0e10cSrcweir return xDocument; 461cdf0e10cSrcweir 462cdf0e10cSrcweir } 463cdf0e10cSrcweir 464cdf0e10cSrcweir //------------------------------------------------------ 465cdf0e10cSrcweir ::rtl::OUString OCommonEmbeddedObject::GetFilterName( sal_Int32 nVersion ) const 466cdf0e10cSrcweir { 467cdf0e10cSrcweir ::rtl::OUString aFilterName = GetPresetFilterName(); 468cdf0e10cSrcweir if ( !aFilterName.getLength() ) 469cdf0e10cSrcweir { 470cdf0e10cSrcweir try { 471cdf0e10cSrcweir ::comphelper::MimeConfigurationHelper aHelper( m_xFactory ); 472cdf0e10cSrcweir aFilterName = aHelper.GetDefaultFilterFromServiceName( GetDocumentServiceName(), nVersion ); 473cdf0e10cSrcweir } catch( uno::Exception& ) 474cdf0e10cSrcweir {} 475cdf0e10cSrcweir } 476cdf0e10cSrcweir 477cdf0e10cSrcweir return aFilterName; 478cdf0e10cSrcweir } 479cdf0e10cSrcweir 480cdf0e10cSrcweir //------------------------------------------------------ 481cdf0e10cSrcweir void OCommonEmbeddedObject::FillDefaultLoadArgs_Impl( const uno::Reference< embed::XStorage >& i_rxStorage, 482cdf0e10cSrcweir ::comphelper::NamedValueCollection& o_rLoadArgs ) const 483cdf0e10cSrcweir { 484cdf0e10cSrcweir o_rLoadArgs.put( "DocumentBaseURL", GetBaseURL_Impl() ); 485cdf0e10cSrcweir o_rLoadArgs.put( "HierarchicalDocumentName", m_aEntryName ); 486cdf0e10cSrcweir o_rLoadArgs.put( "ReadOnly", m_bReadOnly ); 487cdf0e10cSrcweir 488cdf0e10cSrcweir ::rtl::OUString aFilterName = GetFilterName( ::comphelper::OStorageHelper::GetXStorageFormat( i_rxStorage ) ); 489cdf0e10cSrcweir OSL_ENSURE( aFilterName.getLength(), "OCommonEmbeddedObject::FillDefaultLoadArgs_Impl: Wrong document service name!" ); 490cdf0e10cSrcweir if ( !aFilterName.getLength() ) 491cdf0e10cSrcweir throw io::IOException(); // TODO: error message/code 492cdf0e10cSrcweir 493cdf0e10cSrcweir o_rLoadArgs.put( "FilterName", aFilterName ); 494cdf0e10cSrcweir } 495cdf0e10cSrcweir 496cdf0e10cSrcweir //------------------------------------------------------ 497cdf0e10cSrcweir uno::Reference< util::XCloseable > OCommonEmbeddedObject::LoadDocumentFromStorage_Impl() 498cdf0e10cSrcweir { 499cdf0e10cSrcweir ENSURE_OR_THROW( m_xObjectStorage.is(), "no object storage" ); 500cdf0e10cSrcweir 501cdf0e10cSrcweir const uno::Reference< embed::XStorage > xSourceStorage( m_xRecoveryStorage.is() ? m_xRecoveryStorage : m_xObjectStorage ); 502cdf0e10cSrcweir 503cdf0e10cSrcweir uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xFactory, GetDocumentServiceName(), 504cdf0e10cSrcweir m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) ); 505cdf0e10cSrcweir 506cdf0e10cSrcweir //#i103460# ODF: take the size given from the parent frame as default 507cdf0e10cSrcweir uno::Reference< chart2::XChartDocument > xChart( xDocument, uno::UNO_QUERY ); 508cdf0e10cSrcweir if( xChart.is() ) 509cdf0e10cSrcweir { 510cdf0e10cSrcweir uno::Reference< embed::XVisualObject > xChartVisualObject( xChart, uno::UNO_QUERY ); 511cdf0e10cSrcweir if( xChartVisualObject.is() ) 512cdf0e10cSrcweir xChartVisualObject->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, m_aDefaultSizeForChart_In_100TH_MM ); 513cdf0e10cSrcweir } 514cdf0e10cSrcweir 515cdf0e10cSrcweir uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY ); 516cdf0e10cSrcweir uno::Reference< document::XStorageBasedDocument > xDoc 517cdf0e10cSrcweir #ifdef USE_STORAGEBASED_DOCUMENT 518cdf0e10cSrcweir ( xDocument, uno::UNO_QUERY ) 519cdf0e10cSrcweir #endif 520cdf0e10cSrcweir ; 521cdf0e10cSrcweir if ( !xDoc.is() && !xLoadable.is() ) ///BUG: This should be || instead of && ? 522cdf0e10cSrcweir throw uno::RuntimeException(); 523cdf0e10cSrcweir 524cdf0e10cSrcweir ::comphelper::NamedValueCollection aLoadArgs; 525cdf0e10cSrcweir FillDefaultLoadArgs_Impl( xSourceStorage, aLoadArgs ); 526cdf0e10cSrcweir 527cdf0e10cSrcweir uno::Reference< io::XInputStream > xTempInpStream; 528cdf0e10cSrcweir if ( !xDoc.is() ) 529cdf0e10cSrcweir { 530cdf0e10cSrcweir xTempInpStream = createTempInpStreamFromStor( xSourceStorage, m_xFactory ); 531cdf0e10cSrcweir if ( !xTempInpStream.is() ) 532cdf0e10cSrcweir throw uno::RuntimeException(); 533cdf0e10cSrcweir 534cdf0e10cSrcweir ::rtl::OUString aTempFileURL; 535cdf0e10cSrcweir try 536cdf0e10cSrcweir { 537cdf0e10cSrcweir // no need to let the file stay after the stream is removed since the embedded document 538cdf0e10cSrcweir // can not be stored directly 539cdf0e10cSrcweir uno::Reference< beans::XPropertySet > xTempStreamProps( xTempInpStream, uno::UNO_QUERY_THROW ); 540cdf0e10cSrcweir xTempStreamProps->getPropertyValue( ::rtl::OUString::createFromAscii( "Uri" ) ) >>= aTempFileURL; 541cdf0e10cSrcweir } 542cdf0e10cSrcweir catch( uno::Exception& ) 543cdf0e10cSrcweir { 544cdf0e10cSrcweir } 545cdf0e10cSrcweir 546cdf0e10cSrcweir OSL_ENSURE( aTempFileURL.getLength(), "Coudn't retrieve temporary file URL!\n" ); 547cdf0e10cSrcweir 548cdf0e10cSrcweir aLoadArgs.put( "URL", aTempFileURL ); 549cdf0e10cSrcweir aLoadArgs.put( "InputStream", xTempInpStream ); 550cdf0e10cSrcweir } 551cdf0e10cSrcweir 552cdf0e10cSrcweir // aLoadArgs.put( "AsTemplate", sal_True ); 553cdf0e10cSrcweir 554cdf0e10cSrcweir aLoadArgs.merge( m_aDocMediaDescriptor, true ); 555cdf0e10cSrcweir 556cdf0e10cSrcweir try 557cdf0e10cSrcweir { 558cdf0e10cSrcweir // set the document mode to embedded as the first step!!! 559cdf0e10cSrcweir EmbedAndReparentDoc_Impl( xDocument ); 560cdf0e10cSrcweir 561cdf0e10cSrcweir if ( xDoc.is() ) 562cdf0e10cSrcweir { 563cdf0e10cSrcweir xDoc->loadFromStorage( xSourceStorage, aLoadArgs.getPropertyValues() ); 564cdf0e10cSrcweir if ( xSourceStorage != m_xObjectStorage ) 565cdf0e10cSrcweir SwitchDocToStorage_Impl( xDoc, m_xObjectStorage ); 566cdf0e10cSrcweir } 567cdf0e10cSrcweir else 568cdf0e10cSrcweir xLoadable->load( aLoadArgs.getPropertyValues() ); 569cdf0e10cSrcweir } 570cdf0e10cSrcweir catch( uno::Exception& ) 571cdf0e10cSrcweir { 572cdf0e10cSrcweir uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY ); 573cdf0e10cSrcweir if ( xCloseable.is() ) 574cdf0e10cSrcweir { 575cdf0e10cSrcweir try 576cdf0e10cSrcweir { 577cdf0e10cSrcweir xCloseable->close( sal_True ); 578cdf0e10cSrcweir } 579cdf0e10cSrcweir catch( uno::Exception& ) 580cdf0e10cSrcweir { 581cdf0e10cSrcweir DBG_UNHANDLED_EXCEPTION(); 582cdf0e10cSrcweir } 583cdf0e10cSrcweir } 584cdf0e10cSrcweir 585cdf0e10cSrcweir throw; // TODO 586cdf0e10cSrcweir } 587cdf0e10cSrcweir 588cdf0e10cSrcweir return xDocument; 589cdf0e10cSrcweir } 590cdf0e10cSrcweir 591cdf0e10cSrcweir //------------------------------------------------------ 592cdf0e10cSrcweir uno::Reference< io::XInputStream > OCommonEmbeddedObject::StoreDocumentToTempStream_Impl( 593cdf0e10cSrcweir sal_Int32 nStorageFormat, 594cdf0e10cSrcweir const ::rtl::OUString& aBaseURL, 595cdf0e10cSrcweir const ::rtl::OUString& aHierarchName ) 596cdf0e10cSrcweir { 597cdf0e10cSrcweir uno::Reference < io::XOutputStream > xTempOut( 598cdf0e10cSrcweir m_xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.io.TempFile" ) ), 599cdf0e10cSrcweir uno::UNO_QUERY ); 600cdf0e10cSrcweir uno::Reference< io::XInputStream > aResult( xTempOut, uno::UNO_QUERY ); 601cdf0e10cSrcweir 602cdf0e10cSrcweir if ( !xTempOut.is() || !aResult.is() ) 603cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: 604cdf0e10cSrcweir 605cdf0e10cSrcweir uno::Reference< frame::XStorable > xStorable; 606cdf0e10cSrcweir { 607cdf0e10cSrcweir osl::MutexGuard aGuard( m_aMutex ); 608cdf0e10cSrcweir if ( m_pDocHolder ) 609cdf0e10cSrcweir xStorable = uno::Reference< frame::XStorable > ( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 610cdf0e10cSrcweir } 611cdf0e10cSrcweir 612cdf0e10cSrcweir if( !xStorable.is() ) 613cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: 614cdf0e10cSrcweir 615cdf0e10cSrcweir ::rtl::OUString aFilterName = GetFilterName( nStorageFormat ); 616cdf0e10cSrcweir 617cdf0e10cSrcweir OSL_ENSURE( aFilterName.getLength(), "Wrong document service name!" ); 618cdf0e10cSrcweir if ( !aFilterName.getLength() ) 619cdf0e10cSrcweir throw io::IOException(); // TODO: 620cdf0e10cSrcweir 621cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aArgs( 4 ); 622cdf0e10cSrcweir aArgs[0].Name = ::rtl::OUString::createFromAscii( "FilterName" ); 623cdf0e10cSrcweir aArgs[0].Value <<= aFilterName; 624cdf0e10cSrcweir aArgs[1].Name = ::rtl::OUString::createFromAscii( "OutputStream" ); 625cdf0e10cSrcweir aArgs[1].Value <<= xTempOut; 626cdf0e10cSrcweir aArgs[2].Name = ::rtl::OUString::createFromAscii( "DocumentBaseURL" ); 627cdf0e10cSrcweir aArgs[2].Value <<= aBaseURL; 628cdf0e10cSrcweir aArgs[3].Name = ::rtl::OUString::createFromAscii( "HierarchicalDocumentName" ); 629cdf0e10cSrcweir aArgs[3].Value <<= aHierarchName; 630cdf0e10cSrcweir 631cdf0e10cSrcweir xStorable->storeToURL( ::rtl::OUString::createFromAscii( "private:stream" ), aArgs ); 632cdf0e10cSrcweir try 633cdf0e10cSrcweir { 634cdf0e10cSrcweir xTempOut->closeOutput(); 635cdf0e10cSrcweir } 636cdf0e10cSrcweir catch( uno::Exception& ) 637cdf0e10cSrcweir { 638cdf0e10cSrcweir OSL_ENSURE( sal_False, "Looks like stream was closed already" ); 639cdf0e10cSrcweir } 640cdf0e10cSrcweir 641cdf0e10cSrcweir return aResult; 642cdf0e10cSrcweir } 643cdf0e10cSrcweir 644cdf0e10cSrcweir //------------------------------------------------------ 645cdf0e10cSrcweir void OCommonEmbeddedObject::SaveObject_Impl() 646cdf0e10cSrcweir { 647cdf0e10cSrcweir if ( m_xClientSite.is() ) 648cdf0e10cSrcweir { 649cdf0e10cSrcweir try 650cdf0e10cSrcweir { 651cdf0e10cSrcweir // check whether the component is modified, 652cdf0e10cSrcweir // if not there is no need for storing 653cdf0e10cSrcweir uno::Reference< util::XModifiable > xModifiable( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 654cdf0e10cSrcweir if ( xModifiable.is() && !xModifiable->isModified() ) 655cdf0e10cSrcweir return; 656cdf0e10cSrcweir } 657cdf0e10cSrcweir catch( uno::Exception& ) 658cdf0e10cSrcweir {} 659cdf0e10cSrcweir 660cdf0e10cSrcweir try { 661cdf0e10cSrcweir m_xClientSite->saveObject(); 662cdf0e10cSrcweir } 663cdf0e10cSrcweir catch( uno::Exception& ) 664cdf0e10cSrcweir { 665cdf0e10cSrcweir OSL_ENSURE( sal_False, "The object was not stored!\n" ); 666cdf0e10cSrcweir } 667cdf0e10cSrcweir } 668cdf0e10cSrcweir } 669cdf0e10cSrcweir 670cdf0e10cSrcweir //------------------------------------------------------ 671cdf0e10cSrcweir ::rtl::OUString OCommonEmbeddedObject::GetBaseURL_Impl() const 672cdf0e10cSrcweir { 673cdf0e10cSrcweir ::rtl::OUString aBaseURL; 674cdf0e10cSrcweir sal_Int32 nInd = 0; 675cdf0e10cSrcweir 676cdf0e10cSrcweir if ( m_xClientSite.is() ) 677cdf0e10cSrcweir { 678cdf0e10cSrcweir try 679cdf0e10cSrcweir { 680cdf0e10cSrcweir uno::Reference< frame::XModel > xParentModel( m_xClientSite->getComponent(), uno::UNO_QUERY_THROW ); 681cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aModelProps = xParentModel->getArgs(); 682cdf0e10cSrcweir for ( nInd = 0; nInd < aModelProps.getLength(); nInd++ ) 683cdf0e10cSrcweir if ( aModelProps[nInd].Name.equals( 684cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DocumentBaseURL" ) ) ) ) 685cdf0e10cSrcweir { 686cdf0e10cSrcweir aModelProps[nInd].Value >>= aBaseURL; 687cdf0e10cSrcweir break; 688cdf0e10cSrcweir } 689cdf0e10cSrcweir 690cdf0e10cSrcweir 691cdf0e10cSrcweir } 692cdf0e10cSrcweir catch( uno::Exception& ) 693cdf0e10cSrcweir {} 694cdf0e10cSrcweir } 695cdf0e10cSrcweir 696cdf0e10cSrcweir if ( !aBaseURL.getLength() ) 697cdf0e10cSrcweir { 698cdf0e10cSrcweir for ( nInd = 0; nInd < m_aDocMediaDescriptor.getLength(); nInd++ ) 699cdf0e10cSrcweir if ( m_aDocMediaDescriptor[nInd].Name.equals( 700cdf0e10cSrcweir ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DocumentBaseURL" ) ) ) ) 701cdf0e10cSrcweir { 702cdf0e10cSrcweir m_aDocMediaDescriptor[nInd].Value >>= aBaseURL; 703cdf0e10cSrcweir break; 704cdf0e10cSrcweir } 705cdf0e10cSrcweir } 706cdf0e10cSrcweir 707cdf0e10cSrcweir if ( !aBaseURL.getLength() ) 708cdf0e10cSrcweir aBaseURL = m_aDefaultParentBaseURL; 709cdf0e10cSrcweir 710cdf0e10cSrcweir return aBaseURL; 711cdf0e10cSrcweir } 712cdf0e10cSrcweir 713cdf0e10cSrcweir //------------------------------------------------------ 714cdf0e10cSrcweir ::rtl::OUString OCommonEmbeddedObject::GetBaseURLFrom_Impl( 715cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lArguments, 716cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lObjArgs ) 717cdf0e10cSrcweir { 718cdf0e10cSrcweir ::rtl::OUString aBaseURL; 719cdf0e10cSrcweir sal_Int32 nInd = 0; 720cdf0e10cSrcweir 721cdf0e10cSrcweir for ( nInd = 0; nInd < lArguments.getLength(); nInd++ ) 722cdf0e10cSrcweir if ( lArguments[nInd].Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DocumentBaseURL" ) ) ) ) 723cdf0e10cSrcweir { 724cdf0e10cSrcweir lArguments[nInd].Value >>= aBaseURL; 725cdf0e10cSrcweir break; 726cdf0e10cSrcweir } 727cdf0e10cSrcweir 728cdf0e10cSrcweir if ( !aBaseURL.getLength() ) 729cdf0e10cSrcweir { 730cdf0e10cSrcweir for ( nInd = 0; nInd < lObjArgs.getLength(); nInd++ ) 731cdf0e10cSrcweir if ( lObjArgs[nInd].Name.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DefaultParentBaseURL" ) ) ) ) 732cdf0e10cSrcweir { 733cdf0e10cSrcweir lObjArgs[nInd].Value >>= aBaseURL; 734cdf0e10cSrcweir break; 735cdf0e10cSrcweir } 736cdf0e10cSrcweir } 737cdf0e10cSrcweir 738cdf0e10cSrcweir return aBaseURL; 739cdf0e10cSrcweir } 740cdf0e10cSrcweir 741cdf0e10cSrcweir 742cdf0e10cSrcweir //------------------------------------------------------ 743cdf0e10cSrcweir void OCommonEmbeddedObject::SwitchDocToStorage_Impl( const uno::Reference< document::XStorageBasedDocument >& xDoc, const uno::Reference< embed::XStorage >& xStorage ) 744cdf0e10cSrcweir { 745cdf0e10cSrcweir xDoc->switchToStorage( xStorage ); 746cdf0e10cSrcweir 747cdf0e10cSrcweir uno::Reference< util::XModifiable > xModif( xDoc, uno::UNO_QUERY ); 748cdf0e10cSrcweir if ( xModif.is() ) 749cdf0e10cSrcweir xModif->setModified( sal_False ); 750cdf0e10cSrcweir 751cdf0e10cSrcweir if ( m_xRecoveryStorage.is() ) 752cdf0e10cSrcweir m_xRecoveryStorage.clear(); 753cdf0e10cSrcweir } 754cdf0e10cSrcweir 755cdf0e10cSrcweir //------------------------------------------------------ 756cdf0e10cSrcweir void OCommonEmbeddedObject::StoreDocToStorage_Impl( const uno::Reference< embed::XStorage >& xStorage, 757cdf0e10cSrcweir sal_Int32 nStorageFormat, 758cdf0e10cSrcweir const ::rtl::OUString& aBaseURL, 759cdf0e10cSrcweir const ::rtl::OUString& aHierarchName, 760cdf0e10cSrcweir sal_Bool bAttachToTheStorage ) 761cdf0e10cSrcweir { 762cdf0e10cSrcweir OSL_ENSURE( xStorage.is(), "No storage is provided for storing!" ); 763cdf0e10cSrcweir 764cdf0e10cSrcweir if ( !xStorage.is() ) 765cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: 766cdf0e10cSrcweir 767cdf0e10cSrcweir #ifdef USE_STORAGEBASED_DOCUMENT 768cdf0e10cSrcweir uno::Reference< document::XStorageBasedDocument > xDoc; 769cdf0e10cSrcweir { 770cdf0e10cSrcweir osl::MutexGuard aGuard( m_aMutex ); 771cdf0e10cSrcweir if ( m_pDocHolder ) 772cdf0e10cSrcweir xDoc = uno::Reference< document::XStorageBasedDocument >( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 773cdf0e10cSrcweir } 774cdf0e10cSrcweir 775cdf0e10cSrcweir if ( xDoc.is() ) 776cdf0e10cSrcweir { 777cdf0e10cSrcweir ::rtl::OUString aFilterName = GetFilterName( nStorageFormat ); 778cdf0e10cSrcweir 779cdf0e10cSrcweir OSL_ENSURE( aFilterName.getLength(), "Wrong document service name!" ); 780cdf0e10cSrcweir if ( !aFilterName.getLength() ) 781cdf0e10cSrcweir throw io::IOException(); // TODO: 782cdf0e10cSrcweir 783cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aArgs( 3 ); 784cdf0e10cSrcweir aArgs[0].Name = ::rtl::OUString::createFromAscii( "FilterName" ); 785cdf0e10cSrcweir aArgs[0].Value <<= aFilterName; 786cdf0e10cSrcweir aArgs[2].Name = ::rtl::OUString::createFromAscii( "DocumentBaseURL" ); 787cdf0e10cSrcweir aArgs[2].Value <<= aBaseURL; 788cdf0e10cSrcweir aArgs[1].Name = ::rtl::OUString::createFromAscii( "HierarchicalDocumentName" ); 789cdf0e10cSrcweir aArgs[1].Value <<= aHierarchName; 790cdf0e10cSrcweir 791cdf0e10cSrcweir xDoc->storeToStorage( xStorage, aArgs ); 792cdf0e10cSrcweir if ( bAttachToTheStorage ) 793cdf0e10cSrcweir SwitchDocToStorage_Impl( xDoc, xStorage ); 794cdf0e10cSrcweir } 795cdf0e10cSrcweir else 796cdf0e10cSrcweir #endif 797cdf0e10cSrcweir { 798cdf0e10cSrcweir // store document to temporary stream based on temporary file 799cdf0e10cSrcweir uno::Reference < io::XInputStream > xTempIn = StoreDocumentToTempStream_Impl( nStorageFormat, aBaseURL, aHierarchName ); 800cdf0e10cSrcweir 801cdf0e10cSrcweir OSL_ENSURE( xTempIn.is(), "The stream reference can not be empty!\n" ); 802cdf0e10cSrcweir 803cdf0e10cSrcweir // open storage based on document temporary file for reading 804cdf0e10cSrcweir uno::Reference < lang::XSingleServiceFactory > xStorageFactory( 805cdf0e10cSrcweir m_xFactory->createInstance ( ::rtl::OUString::createFromAscii( "com.sun.star.embed.StorageFactory" ) ), 806cdf0e10cSrcweir uno::UNO_QUERY ); 807cdf0e10cSrcweir 808cdf0e10cSrcweir uno::Sequence< uno::Any > aArgs(1); 809cdf0e10cSrcweir aArgs[0] <<= xTempIn; 810cdf0e10cSrcweir uno::Reference< embed::XStorage > xTempStorage( xStorageFactory->createInstanceWithArguments( aArgs ), 811cdf0e10cSrcweir uno::UNO_QUERY ); 812cdf0e10cSrcweir if ( !xTempStorage.is() ) 813cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: 814cdf0e10cSrcweir 815cdf0e10cSrcweir // object storage must be commited automatically 816cdf0e10cSrcweir xTempStorage->copyToStorage( xStorage ); 817cdf0e10cSrcweir } 818cdf0e10cSrcweir } 819cdf0e10cSrcweir 820cdf0e10cSrcweir //------------------------------------------------------ 821cdf0e10cSrcweir uno::Reference< util::XCloseable > OCommonEmbeddedObject::CreateDocFromMediaDescr_Impl( 822cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& aMedDescr ) 823cdf0e10cSrcweir { 824cdf0e10cSrcweir uno::Reference< util::XCloseable > xDocument( CreateDocument( m_xFactory, GetDocumentServiceName(), 825cdf0e10cSrcweir m_bEmbeddedScriptSupport, m_bDocumentRecoverySupport ) ); 826cdf0e10cSrcweir 827cdf0e10cSrcweir uno::Reference< frame::XLoadable > xLoadable( xDocument, uno::UNO_QUERY ); 828cdf0e10cSrcweir if ( !xLoadable.is() ) 829cdf0e10cSrcweir throw uno::RuntimeException(); 830cdf0e10cSrcweir 831cdf0e10cSrcweir try 832cdf0e10cSrcweir { 833cdf0e10cSrcweir // set the document mode to embedded as the first action on the document!!! 834cdf0e10cSrcweir EmbedAndReparentDoc_Impl( xDocument ); 835cdf0e10cSrcweir 836cdf0e10cSrcweir xLoadable->load( addAsTemplate( aMedDescr ) ); 837cdf0e10cSrcweir } 838cdf0e10cSrcweir catch( uno::Exception& ) 839cdf0e10cSrcweir { 840cdf0e10cSrcweir uno::Reference< util::XCloseable > xCloseable( xDocument, uno::UNO_QUERY ); 841cdf0e10cSrcweir if ( xCloseable.is() ) 842cdf0e10cSrcweir { 843cdf0e10cSrcweir try 844cdf0e10cSrcweir { 845cdf0e10cSrcweir xCloseable->close( sal_True ); 846cdf0e10cSrcweir } 847cdf0e10cSrcweir catch( uno::Exception& ) 848cdf0e10cSrcweir { 849cdf0e10cSrcweir } 850cdf0e10cSrcweir } 851cdf0e10cSrcweir 852cdf0e10cSrcweir throw; // TODO 853cdf0e10cSrcweir } 854cdf0e10cSrcweir 855cdf0e10cSrcweir return xDocument; 856cdf0e10cSrcweir } 857cdf0e10cSrcweir 858cdf0e10cSrcweir //------------------------------------------------------ 859cdf0e10cSrcweir uno::Reference< util::XCloseable > OCommonEmbeddedObject::CreateTempDocFromLink_Impl() 860cdf0e10cSrcweir { 861cdf0e10cSrcweir uno::Reference< util::XCloseable > xResult; 862cdf0e10cSrcweir 863cdf0e10cSrcweir OSL_ENSURE( m_bIsLink, "The object is not a linked one!\n" ); 864cdf0e10cSrcweir 865cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aTempMediaDescr; 866cdf0e10cSrcweir 867cdf0e10cSrcweir sal_Int32 nStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 868cdf0e10cSrcweir try { 869cdf0e10cSrcweir nStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage ); 870cdf0e10cSrcweir } 871cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 872cdf0e10cSrcweir { 873cdf0e10cSrcweir // the container just has an unknown type, use current file format 874cdf0e10cSrcweir } 875cdf0e10cSrcweir catch ( uno::Exception& ) 876cdf0e10cSrcweir { 877cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve storage media type!\n" ); 878cdf0e10cSrcweir } 879cdf0e10cSrcweir 880cdf0e10cSrcweir if ( m_pDocHolder->GetComponent().is() ) 881cdf0e10cSrcweir { 882cdf0e10cSrcweir aTempMediaDescr.realloc( 4 ); 883cdf0e10cSrcweir 884cdf0e10cSrcweir // TODO/LATER: may be private:stream should be used as target URL 885cdf0e10cSrcweir ::rtl::OUString aTempFileURL; 886cdf0e10cSrcweir uno::Reference< io::XInputStream > xTempStream = StoreDocumentToTempStream_Impl( SOFFICE_FILEFORMAT_CURRENT, 887cdf0e10cSrcweir ::rtl::OUString(), 888cdf0e10cSrcweir ::rtl::OUString() ); 889cdf0e10cSrcweir try 890cdf0e10cSrcweir { 891cdf0e10cSrcweir // no need to let the file stay after the stream is removed since the embedded document 892cdf0e10cSrcweir // can not be stored directly 893cdf0e10cSrcweir uno::Reference< beans::XPropertySet > xTempStreamProps( xTempStream, uno::UNO_QUERY_THROW ); 894cdf0e10cSrcweir xTempStreamProps->getPropertyValue( ::rtl::OUString::createFromAscii( "Uri" ) ) >>= aTempFileURL; 895cdf0e10cSrcweir } 896cdf0e10cSrcweir catch( uno::Exception& ) 897cdf0e10cSrcweir { 898cdf0e10cSrcweir } 899cdf0e10cSrcweir 900cdf0e10cSrcweir OSL_ENSURE( aTempFileURL.getLength(), "Coudn't retrieve temporary file URL!\n" ); 901cdf0e10cSrcweir 902cdf0e10cSrcweir aTempMediaDescr[0].Name = ::rtl::OUString::createFromAscii( "URL" ); 903cdf0e10cSrcweir aTempMediaDescr[0].Value <<= aTempFileURL; 904cdf0e10cSrcweir aTempMediaDescr[1].Name = ::rtl::OUString::createFromAscii( "InputStream" ); 905cdf0e10cSrcweir aTempMediaDescr[1].Value <<= xTempStream; 906cdf0e10cSrcweir aTempMediaDescr[2].Name = ::rtl::OUString::createFromAscii( "FilterName" ); 907cdf0e10cSrcweir aTempMediaDescr[2].Value <<= GetFilterName( nStorageFormat ); 908cdf0e10cSrcweir aTempMediaDescr[3].Name = ::rtl::OUString::createFromAscii( "AsTemplate" ); 909cdf0e10cSrcweir aTempMediaDescr[3].Value <<= sal_True; 910cdf0e10cSrcweir } 911cdf0e10cSrcweir else 912cdf0e10cSrcweir { 913cdf0e10cSrcweir aTempMediaDescr.realloc( 2 ); 914cdf0e10cSrcweir aTempMediaDescr[0].Name = ::rtl::OUString::createFromAscii( "URL" ); 915cdf0e10cSrcweir aTempMediaDescr[0].Value <<= m_aLinkURL; 916cdf0e10cSrcweir aTempMediaDescr[1].Name = ::rtl::OUString::createFromAscii( "FilterName" ); 917cdf0e10cSrcweir aTempMediaDescr[1].Value <<= m_aLinkFilterName; 918cdf0e10cSrcweir // aTempMediaDescr[2].Name = ::rtl::OUString::createFromAscii( "AsTemplate" ); 919cdf0e10cSrcweir // aTempMediaDescr[2].Value <<= sal_True; 920cdf0e10cSrcweir } 921cdf0e10cSrcweir 922cdf0e10cSrcweir xResult = CreateDocFromMediaDescr_Impl( aTempMediaDescr ); 923cdf0e10cSrcweir 924cdf0e10cSrcweir return xResult; 925cdf0e10cSrcweir } 926cdf0e10cSrcweir 927cdf0e10cSrcweir //------------------------------------------------------ 928cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::setPersistentEntry( 929cdf0e10cSrcweir const uno::Reference< embed::XStorage >& xStorage, 930cdf0e10cSrcweir const ::rtl::OUString& sEntName, 931cdf0e10cSrcweir sal_Int32 nEntryConnectionMode, 932cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lArguments, 933cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lObjArgs ) 934cdf0e10cSrcweir throw ( lang::IllegalArgumentException, 935cdf0e10cSrcweir embed::WrongStateException, 936cdf0e10cSrcweir io::IOException, 937cdf0e10cSrcweir uno::Exception, 938cdf0e10cSrcweir uno::RuntimeException ) 939cdf0e10cSrcweir { 940cdf0e10cSrcweir RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OCommonEmbeddedObject::setPersistentEntry" ); 941cdf0e10cSrcweir 942cdf0e10cSrcweir // the type of the object must be already set 943cdf0e10cSrcweir // a kind of typedetection should be done in the factory 944cdf0e10cSrcweir 945cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 946cdf0e10cSrcweir if ( m_bDisposed ) 947cdf0e10cSrcweir throw lang::DisposedException(); // TODO 948cdf0e10cSrcweir 949cdf0e10cSrcweir if ( !xStorage.is() ) 950cdf0e10cSrcweir throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "No parent storage is provided!\n" ), 951cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 952cdf0e10cSrcweir 1 ); 953cdf0e10cSrcweir 954cdf0e10cSrcweir if ( !sEntName.getLength() ) 955cdf0e10cSrcweir throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Empty element name is provided!\n" ), 956cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 957cdf0e10cSrcweir 2 ); 958cdf0e10cSrcweir 959cdf0e10cSrcweir // May be LOADED should be forbidden here ??? 960cdf0e10cSrcweir if ( ( m_nObjectState != -1 || nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 961cdf0e10cSrcweir && ( m_nObjectState == -1 || nEntryConnectionMode != embed::EntryInitModes::NO_INIT ) ) 962cdf0e10cSrcweir { 963cdf0e10cSrcweir // if the object is not loaded 964*07a3d7f1SPedro Giffuni // it can not get persistent representation without initialization 965cdf0e10cSrcweir 966cdf0e10cSrcweir // if the object is loaded 967*07a3d7f1SPedro Giffuni // it can switch persistent representation only without initialization 968cdf0e10cSrcweir 969cdf0e10cSrcweir throw embed::WrongStateException( 970*07a3d7f1SPedro Giffuni ::rtl::OUString::createFromAscii( "Can't change persistent representation of activated object!\n" ), 971cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 972cdf0e10cSrcweir } 973cdf0e10cSrcweir 974cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 975cdf0e10cSrcweir { 976cdf0e10cSrcweir if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 977cdf0e10cSrcweir { 978cdf0e10cSrcweir // saveCompleted is expected, handle it accordingly 979cdf0e10cSrcweir if ( m_xNewParentStorage == xStorage && m_aNewEntryName.equals( sEntName ) ) 980cdf0e10cSrcweir { 981cdf0e10cSrcweir saveCompleted( sal_True ); 982cdf0e10cSrcweir return; 983cdf0e10cSrcweir } 984cdf0e10cSrcweir 985cdf0e10cSrcweir // if a completely different entry is provided, switch first back to the old persistence in saveCompleted 986cdf0e10cSrcweir // and then switch to the target persistence 987cdf0e10cSrcweir sal_Bool bSwitchFurther = ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) ); 988cdf0e10cSrcweir saveCompleted( sal_False ); 989cdf0e10cSrcweir if ( !bSwitchFurther ) 990cdf0e10cSrcweir return; 991cdf0e10cSrcweir } 992cdf0e10cSrcweir else 993cdf0e10cSrcweir throw embed::WrongStateException( 994cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 995cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 996cdf0e10cSrcweir } 997cdf0e10cSrcweir 998cdf0e10cSrcweir // for now support of this interface is required to allow breaking of links and converting them to normal embedded 999cdf0e10cSrcweir // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used ) 1000cdf0e10cSrcweir // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" ); 1001cdf0e10cSrcweir if ( m_bIsLink ) 1002cdf0e10cSrcweir { 1003cdf0e10cSrcweir m_aEntryName = sEntName; 1004cdf0e10cSrcweir return; 1005cdf0e10cSrcweir } 1006cdf0e10cSrcweir 1007cdf0e10cSrcweir uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY ); 1008cdf0e10cSrcweir if ( !xNameAccess.is() ) 1009cdf0e10cSrcweir throw uno::RuntimeException(); //TODO 1010cdf0e10cSrcweir 1011cdf0e10cSrcweir // detect entry existence 1012cdf0e10cSrcweir sal_Bool bElExists = xNameAccess->hasByName( sEntName ); 1013cdf0e10cSrcweir 1014cdf0e10cSrcweir m_aDocMediaDescriptor = GetValuableArgs_Impl( lArguments, 1015cdf0e10cSrcweir nEntryConnectionMode != embed::EntryInitModes::MEDIA_DESCRIPTOR_INIT ); 1016cdf0e10cSrcweir 1017cdf0e10cSrcweir m_bReadOnly = sal_False; 1018cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ ) 1019cdf0e10cSrcweir if ( lArguments[nInd].Name.equalsAscii( "ReadOnly" ) ) 1020cdf0e10cSrcweir lArguments[nInd].Value >>= m_bReadOnly; 1021cdf0e10cSrcweir 1022cdf0e10cSrcweir // TODO: use lObjArgs for StoreVisualReplacement 1023cdf0e10cSrcweir for ( sal_Int32 nObjInd = 0; nObjInd < lObjArgs.getLength(); nObjInd++ ) 1024cdf0e10cSrcweir if ( lObjArgs[nObjInd].Name.equalsAscii( "OutplaceDispatchInterceptor" ) ) 1025cdf0e10cSrcweir { 1026cdf0e10cSrcweir uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor; 1027cdf0e10cSrcweir if ( lObjArgs[nObjInd].Value >>= xDispatchInterceptor ) 1028cdf0e10cSrcweir m_pDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor ); 1029cdf0e10cSrcweir } 1030cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "DefaultParentBaseURL" ) ) 1031cdf0e10cSrcweir { 1032cdf0e10cSrcweir lObjArgs[nObjInd].Value >>= m_aDefaultParentBaseURL; 1033cdf0e10cSrcweir } 1034cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "Parent" ) ) 1035cdf0e10cSrcweir { 1036cdf0e10cSrcweir lObjArgs[nObjInd].Value >>= m_xParent; 1037cdf0e10cSrcweir } 1038cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "IndividualMiscStatus" ) ) 1039cdf0e10cSrcweir { 1040cdf0e10cSrcweir sal_Int64 nMiscStatus=0; 1041cdf0e10cSrcweir lObjArgs[nObjInd].Value >>= nMiscStatus; 1042cdf0e10cSrcweir m_nMiscStatus |= nMiscStatus; 1043cdf0e10cSrcweir } 1044cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "CloneFrom" ) ) 1045cdf0e10cSrcweir { 1046cdf0e10cSrcweir uno::Reference < embed::XEmbeddedObject > xObj; 1047cdf0e10cSrcweir lObjArgs[nObjInd].Value >>= xObj; 1048cdf0e10cSrcweir if ( xObj.is() ) 1049cdf0e10cSrcweir { 1050cdf0e10cSrcweir m_bHasClonedSize = sal_True; 1051cdf0e10cSrcweir m_aClonedSize = xObj->getVisualAreaSize( embed::Aspects::MSOLE_CONTENT ); 1052cdf0e10cSrcweir m_nClonedMapUnit = xObj->getMapUnit( embed::Aspects::MSOLE_CONTENT ); 1053cdf0e10cSrcweir } 1054cdf0e10cSrcweir } 1055cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "OutplaceFrameProperties" ) ) 1056cdf0e10cSrcweir { 1057cdf0e10cSrcweir uno::Sequence< uno::Any > aOutFrameProps; 1058cdf0e10cSrcweir uno::Sequence< beans::NamedValue > aOutFramePropsTyped; 1059cdf0e10cSrcweir if ( lObjArgs[nObjInd].Value >>= aOutFrameProps ) 1060cdf0e10cSrcweir { 1061cdf0e10cSrcweir m_pDocHolder->SetOutplaceFrameProperties( aOutFrameProps ); 1062cdf0e10cSrcweir } 1063cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Value >>= aOutFramePropsTyped ) 1064cdf0e10cSrcweir { 1065cdf0e10cSrcweir aOutFrameProps.realloc( aOutFramePropsTyped.getLength() ); 1066cdf0e10cSrcweir uno::Any* pProp = aOutFrameProps.getArray(); 1067cdf0e10cSrcweir for ( const beans::NamedValue* pTypedProp = aOutFramePropsTyped.getConstArray(); 1068cdf0e10cSrcweir pTypedProp != aOutFramePropsTyped.getConstArray() + aOutFramePropsTyped.getLength(); 1069cdf0e10cSrcweir ++pTypedProp, ++pProp 1070cdf0e10cSrcweir ) 1071cdf0e10cSrcweir { 1072cdf0e10cSrcweir *pProp <<= *pTypedProp; 1073cdf0e10cSrcweir } 1074cdf0e10cSrcweir m_pDocHolder->SetOutplaceFrameProperties( aOutFrameProps ); 1075cdf0e10cSrcweir } 1076cdf0e10cSrcweir else 1077cdf0e10cSrcweir OSL_ENSURE( false, "OCommonEmbeddedObject::setPersistentEntry: illegal type for argument 'OutplaceFrameProperties'!" ); 1078cdf0e10cSrcweir } 1079cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "ModuleName" ) ) 1080cdf0e10cSrcweir { 1081cdf0e10cSrcweir lObjArgs[nObjInd].Value >>= m_aModuleName; 1082cdf0e10cSrcweir } 1083cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "EmbeddedScriptSupport" ) ) 1084cdf0e10cSrcweir { 1085cdf0e10cSrcweir OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_bEmbeddedScriptSupport ); 1086cdf0e10cSrcweir } 1087cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "DocumentRecoverySupport" ) ) 1088cdf0e10cSrcweir { 1089cdf0e10cSrcweir OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_bDocumentRecoverySupport ); 1090cdf0e10cSrcweir } 1091cdf0e10cSrcweir else if ( lObjArgs[nObjInd].Name.equalsAscii( "RecoveryStorage" ) ) 1092cdf0e10cSrcweir { 1093cdf0e10cSrcweir OSL_VERIFY( lObjArgs[nObjInd].Value >>= m_xRecoveryStorage ); 1094cdf0e10cSrcweir } 1095cdf0e10cSrcweir 1096cdf0e10cSrcweir 1097cdf0e10cSrcweir sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE; 1098cdf0e10cSrcweir 1099cdf0e10cSrcweir SwitchOwnPersistence( xStorage, sEntName ); 1100cdf0e10cSrcweir 1101cdf0e10cSrcweir if ( nEntryConnectionMode == embed::EntryInitModes::DEFAULT_INIT ) 1102cdf0e10cSrcweir { 1103cdf0e10cSrcweir if ( bElExists ) 1104cdf0e10cSrcweir { 1105cdf0e10cSrcweir // the initialization from existing storage allows to leave object in loaded state 1106cdf0e10cSrcweir m_nObjectState = embed::EmbedStates::LOADED; 1107cdf0e10cSrcweir } 1108cdf0e10cSrcweir else 1109cdf0e10cSrcweir { 1110cdf0e10cSrcweir m_pDocHolder->SetComponent( InitNewDocument_Impl(), m_bReadOnly ); 1111cdf0e10cSrcweir if ( !m_pDocHolder->GetComponent().is() ) 1112cdf0e10cSrcweir throw io::IOException(); // TODO: can not create document 1113cdf0e10cSrcweir 1114cdf0e10cSrcweir m_nObjectState = embed::EmbedStates::RUNNING; 1115cdf0e10cSrcweir } 1116cdf0e10cSrcweir } 1117cdf0e10cSrcweir else 1118cdf0e10cSrcweir { 1119cdf0e10cSrcweir if ( ( nStorageMode & embed::ElementModes::READWRITE ) != embed::ElementModes::READWRITE ) 1120cdf0e10cSrcweir throw io::IOException(); 1121cdf0e10cSrcweir 1122cdf0e10cSrcweir if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT ) 1123cdf0e10cSrcweir { 1124cdf0e10cSrcweir // the document just already changed its storage to store to 1125cdf0e10cSrcweir // the links to OOo documents for now ignore this call 1126cdf0e10cSrcweir // TODO: OOo links will have persistence so it will be switched here 1127cdf0e10cSrcweir } 1128cdf0e10cSrcweir else if ( nEntryConnectionMode == embed::EntryInitModes::TRUNCATE_INIT ) 1129cdf0e10cSrcweir { 1130cdf0e10cSrcweir if ( m_xRecoveryStorage.is() ) 1131cdf0e10cSrcweir TransferMediaType( m_xRecoveryStorage, m_xObjectStorage ); 1132cdf0e10cSrcweir 1133cdf0e10cSrcweir // TODO: 1134cdf0e10cSrcweir m_pDocHolder->SetComponent( InitNewDocument_Impl(), m_bReadOnly ); 1135cdf0e10cSrcweir 1136cdf0e10cSrcweir if ( !m_pDocHolder->GetComponent().is() ) 1137cdf0e10cSrcweir throw io::IOException(); // TODO: can not create document 1138cdf0e10cSrcweir 1139cdf0e10cSrcweir m_nObjectState = embed::EmbedStates::RUNNING; 1140cdf0e10cSrcweir } 1141cdf0e10cSrcweir else if ( nEntryConnectionMode == embed::EntryInitModes::MEDIA_DESCRIPTOR_INIT ) 1142cdf0e10cSrcweir { 1143cdf0e10cSrcweir m_pDocHolder->SetComponent( CreateDocFromMediaDescr_Impl( lArguments ), m_bReadOnly ); 1144cdf0e10cSrcweir m_nObjectState = embed::EmbedStates::RUNNING; 1145cdf0e10cSrcweir } 1146cdf0e10cSrcweir //else if ( nEntryConnectionMode == embed::EntryInitModes::TRANSFERABLE_INIT ) 1147cdf0e10cSrcweir //{ 1148cdf0e10cSrcweir //TODO: 1149cdf0e10cSrcweir //} 1150cdf0e10cSrcweir else 1151cdf0e10cSrcweir throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Wrong connection mode is provided!\n" ), 1152cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 1153cdf0e10cSrcweir 3 ); 1154cdf0e10cSrcweir } 1155cdf0e10cSrcweir } 1156cdf0e10cSrcweir 1157cdf0e10cSrcweir //------------------------------------------------------ 1158cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::storeToEntry( const uno::Reference< embed::XStorage >& xStorage, 1159cdf0e10cSrcweir const ::rtl::OUString& sEntName, 1160cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lArguments, 1161cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lObjArgs ) 1162cdf0e10cSrcweir throw ( lang::IllegalArgumentException, 1163cdf0e10cSrcweir embed::WrongStateException, 1164cdf0e10cSrcweir io::IOException, 1165cdf0e10cSrcweir uno::Exception, 1166cdf0e10cSrcweir uno::RuntimeException ) 1167cdf0e10cSrcweir { 1168cdf0e10cSrcweir RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OCommonEmbeddedObject::storeToEntry" ); 1169cdf0e10cSrcweir 1170cdf0e10cSrcweir ::osl::ResettableMutexGuard aGuard( m_aMutex ); 1171cdf0e10cSrcweir if ( m_bDisposed ) 1172cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1173cdf0e10cSrcweir 1174cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1175cdf0e10cSrcweir { 1176cdf0e10cSrcweir // the object is still not loaded 1177cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Can't store object without persistence!\n" ), 1178cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1179cdf0e10cSrcweir } 1180cdf0e10cSrcweir 1181cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1182cdf0e10cSrcweir throw embed::WrongStateException( 1183cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1184cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1185cdf0e10cSrcweir 1186cdf0e10cSrcweir // for now support of this interface is required to allow breaking of links and converting them to normal embedded 1187cdf0e10cSrcweir // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used ) 1188cdf0e10cSrcweir // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" ); 1189cdf0e10cSrcweir if ( m_bIsLink ) 1190cdf0e10cSrcweir return; 1191cdf0e10cSrcweir 1192cdf0e10cSrcweir OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" ); 1193cdf0e10cSrcweir 1194cdf0e10cSrcweir sal_Int32 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 1195cdf0e10cSrcweir sal_Int32 nOriginalStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 1196cdf0e10cSrcweir try { 1197cdf0e10cSrcweir nTargetStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( xStorage ); 1198cdf0e10cSrcweir } 1199cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 1200cdf0e10cSrcweir { 1201cdf0e10cSrcweir // the container just has an unknown type, use current file format 1202cdf0e10cSrcweir } 1203cdf0e10cSrcweir catch ( uno::Exception& ) 1204cdf0e10cSrcweir { 1205cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve target storage media type!\n" ); 1206cdf0e10cSrcweir } 1207cdf0e10cSrcweir 1208cdf0e10cSrcweir try 1209cdf0e10cSrcweir { 1210cdf0e10cSrcweir nOriginalStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage ); 1211cdf0e10cSrcweir } 1212cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 1213cdf0e10cSrcweir { 1214cdf0e10cSrcweir // the container just has an unknown type, use current file format 1215cdf0e10cSrcweir } 1216cdf0e10cSrcweir catch ( uno::Exception& ) 1217cdf0e10cSrcweir { 1218cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve own storage media type!\n" ); 1219cdf0e10cSrcweir } 1220cdf0e10cSrcweir 1221cdf0e10cSrcweir sal_Bool bTryOptimization = sal_False; 1222cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ ) 1223cdf0e10cSrcweir { 1224cdf0e10cSrcweir // StoreVisualReplacement and VisualReplacement args have no sence here 1225cdf0e10cSrcweir if ( lObjArgs[nInd].Name.equalsAscii( "CanTryOptimization" ) ) 1226cdf0e10cSrcweir lObjArgs[nInd].Value >>= bTryOptimization; 1227cdf0e10cSrcweir } 1228cdf0e10cSrcweir 1229cdf0e10cSrcweir sal_Bool bSwitchBackToLoaded = sal_False; 1230cdf0e10cSrcweir 1231cdf0e10cSrcweir // Storing to different format can be done only in running state. 1232cdf0e10cSrcweir if ( m_nObjectState == embed::EmbedStates::LOADED ) 1233cdf0e10cSrcweir { 1234cdf0e10cSrcweir // TODO/LATER: copying is not legal for documents with relative links. 1235cdf0e10cSrcweir if ( nTargetStorageFormat == nOriginalStorageFormat ) 1236cdf0e10cSrcweir { 1237cdf0e10cSrcweir sal_Bool bOptimizationWorks = sal_False; 1238cdf0e10cSrcweir if ( bTryOptimization ) 1239cdf0e10cSrcweir { 1240cdf0e10cSrcweir try 1241cdf0e10cSrcweir { 1242cdf0e10cSrcweir // try to use optimized copying 1243cdf0e10cSrcweir uno::Reference< embed::XOptimizedStorage > xSource( m_xParentStorage, uno::UNO_QUERY_THROW ); 1244cdf0e10cSrcweir uno::Reference< embed::XOptimizedStorage > xTarget( xStorage, uno::UNO_QUERY_THROW ); 1245cdf0e10cSrcweir xSource->copyElementDirectlyTo( m_aEntryName, xTarget, sEntName ); 1246cdf0e10cSrcweir bOptimizationWorks = sal_True; 1247cdf0e10cSrcweir } 1248cdf0e10cSrcweir catch( uno::Exception& ) 1249cdf0e10cSrcweir { 1250cdf0e10cSrcweir } 1251cdf0e10cSrcweir } 1252cdf0e10cSrcweir 1253cdf0e10cSrcweir if ( !bOptimizationWorks ) 1254cdf0e10cSrcweir m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName ); 1255cdf0e10cSrcweir } 1256cdf0e10cSrcweir else 1257cdf0e10cSrcweir { 1258cdf0e10cSrcweir changeState( embed::EmbedStates::RUNNING ); 1259cdf0e10cSrcweir bSwitchBackToLoaded = sal_True; 1260cdf0e10cSrcweir } 1261cdf0e10cSrcweir } 1262cdf0e10cSrcweir 1263cdf0e10cSrcweir if ( m_nObjectState != embed::EmbedStates::LOADED ) 1264cdf0e10cSrcweir { 1265cdf0e10cSrcweir uno::Reference< embed::XStorage > xSubStorage = 1266cdf0e10cSrcweir xStorage->openStorageElement( sEntName, embed::ElementModes::READWRITE ); 1267cdf0e10cSrcweir 1268cdf0e10cSrcweir if ( !xSubStorage.is() ) 1269cdf0e10cSrcweir throw uno::RuntimeException(); //TODO 1270cdf0e10cSrcweir 1271cdf0e10cSrcweir aGuard.clear(); 1272cdf0e10cSrcweir // TODO/LATER: support hierarchical name for embedded objects in embedded objects 1273cdf0e10cSrcweir StoreDocToStorage_Impl( xSubStorage, nTargetStorageFormat, GetBaseURLFrom_Impl( lArguments, lObjArgs ), sEntName, sal_False ); 1274cdf0e10cSrcweir aGuard.reset(); 1275cdf0e10cSrcweir 1276cdf0e10cSrcweir if ( bSwitchBackToLoaded ) 1277cdf0e10cSrcweir changeState( embed::EmbedStates::LOADED ); 1278cdf0e10cSrcweir } 1279cdf0e10cSrcweir 1280cdf0e10cSrcweir // TODO: should the listener notification be done? 1281cdf0e10cSrcweir } 1282cdf0e10cSrcweir 1283cdf0e10cSrcweir //------------------------------------------------------ 1284cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::storeAsEntry( const uno::Reference< embed::XStorage >& xStorage, 1285cdf0e10cSrcweir const ::rtl::OUString& sEntName, 1286cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lArguments, 1287cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lObjArgs ) 1288cdf0e10cSrcweir throw ( lang::IllegalArgumentException, 1289cdf0e10cSrcweir embed::WrongStateException, 1290cdf0e10cSrcweir io::IOException, 1291cdf0e10cSrcweir uno::Exception, 1292cdf0e10cSrcweir uno::RuntimeException ) 1293cdf0e10cSrcweir { 1294cdf0e10cSrcweir RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OCommonEmbeddedObject::storeAsEntry" ); 1295cdf0e10cSrcweir 1296cdf0e10cSrcweir // TODO: use lObjArgs 1297cdf0e10cSrcweir 1298cdf0e10cSrcweir ::osl::ResettableMutexGuard aGuard( m_aMutex ); 1299cdf0e10cSrcweir if ( m_bDisposed ) 1300cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1301cdf0e10cSrcweir 1302cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1303cdf0e10cSrcweir { 1304cdf0e10cSrcweir // the object is still not loaded 1305cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Can't store object without persistence!\n" ), 1306cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1307cdf0e10cSrcweir } 1308cdf0e10cSrcweir 1309cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1310cdf0e10cSrcweir throw embed::WrongStateException( 1311cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1312cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1313cdf0e10cSrcweir 1314cdf0e10cSrcweir // for now support of this interface is required to allow breaking of links and converting them to normal embedded 1315cdf0e10cSrcweir // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used ) 1316cdf0e10cSrcweir // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" ); 1317cdf0e10cSrcweir if ( m_bIsLink ) 1318cdf0e10cSrcweir { 1319cdf0e10cSrcweir m_aNewEntryName = sEntName; 1320cdf0e10cSrcweir return; 1321cdf0e10cSrcweir } 1322cdf0e10cSrcweir 1323cdf0e10cSrcweir OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" ); 1324cdf0e10cSrcweir 1325cdf0e10cSrcweir sal_Int32 nTargetStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 1326cdf0e10cSrcweir sal_Int32 nOriginalStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 1327cdf0e10cSrcweir try { 1328cdf0e10cSrcweir nTargetStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( xStorage ); 1329cdf0e10cSrcweir } 1330cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 1331cdf0e10cSrcweir { 1332cdf0e10cSrcweir // the container just has an unknown type, use current file format 1333cdf0e10cSrcweir } 1334cdf0e10cSrcweir catch ( uno::Exception& ) 1335cdf0e10cSrcweir { 1336cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve target storage media type!\n" ); 1337cdf0e10cSrcweir } 1338cdf0e10cSrcweir 1339cdf0e10cSrcweir try 1340cdf0e10cSrcweir { 1341cdf0e10cSrcweir nOriginalStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage ); 1342cdf0e10cSrcweir } 1343cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 1344cdf0e10cSrcweir { 1345cdf0e10cSrcweir // the container just has an unknown type, use current file format 1346cdf0e10cSrcweir } 1347cdf0e10cSrcweir catch ( uno::Exception& ) 1348cdf0e10cSrcweir { 1349cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve own storage media type!\n" ); 1350cdf0e10cSrcweir } 1351cdf0e10cSrcweir 1352cdf0e10cSrcweir PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSaveAs" ) ); 1353cdf0e10cSrcweir 1354cdf0e10cSrcweir sal_Bool bTryOptimization = sal_False; 1355cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ ) 1356cdf0e10cSrcweir { 1357cdf0e10cSrcweir // StoreVisualReplacement and VisualReplacement args have no sence here 1358cdf0e10cSrcweir if ( lObjArgs[nInd].Name.equalsAscii( "CanTryOptimization" ) ) 1359cdf0e10cSrcweir lObjArgs[nInd].Value >>= bTryOptimization; 1360cdf0e10cSrcweir } 1361cdf0e10cSrcweir 1362cdf0e10cSrcweir sal_Bool bSwitchBackToLoaded = sal_False; 1363cdf0e10cSrcweir 1364cdf0e10cSrcweir // Storing to different format can be done only in running state. 1365cdf0e10cSrcweir if ( m_nObjectState == embed::EmbedStates::LOADED ) 1366cdf0e10cSrcweir { 1367cdf0e10cSrcweir // TODO/LATER: copying is not legal for documents with relative links. 1368cdf0e10cSrcweir if ( nTargetStorageFormat == nOriginalStorageFormat ) 1369cdf0e10cSrcweir { 1370cdf0e10cSrcweir sal_Bool bOptimizationWorks = sal_False; 1371cdf0e10cSrcweir if ( bTryOptimization ) 1372cdf0e10cSrcweir { 1373cdf0e10cSrcweir try 1374cdf0e10cSrcweir { 1375cdf0e10cSrcweir // try to use optimized copying 1376cdf0e10cSrcweir uno::Reference< embed::XOptimizedStorage > xSource( m_xParentStorage, uno::UNO_QUERY_THROW ); 1377cdf0e10cSrcweir uno::Reference< embed::XOptimizedStorage > xTarget( xStorage, uno::UNO_QUERY_THROW ); 1378cdf0e10cSrcweir xSource->copyElementDirectlyTo( m_aEntryName, xTarget, sEntName ); 1379cdf0e10cSrcweir bOptimizationWorks = sal_True; 1380cdf0e10cSrcweir } 1381cdf0e10cSrcweir catch( uno::Exception& ) 1382cdf0e10cSrcweir { 1383cdf0e10cSrcweir } 1384cdf0e10cSrcweir } 1385cdf0e10cSrcweir 1386cdf0e10cSrcweir if ( !bOptimizationWorks ) 1387cdf0e10cSrcweir m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName ); 1388cdf0e10cSrcweir } 1389cdf0e10cSrcweir else 1390cdf0e10cSrcweir { 1391cdf0e10cSrcweir changeState( embed::EmbedStates::RUNNING ); 1392cdf0e10cSrcweir bSwitchBackToLoaded = sal_True; 1393cdf0e10cSrcweir } 1394cdf0e10cSrcweir } 1395cdf0e10cSrcweir 1396cdf0e10cSrcweir uno::Reference< embed::XStorage > xSubStorage = 1397cdf0e10cSrcweir xStorage->openStorageElement( sEntName, embed::ElementModes::READWRITE ); 1398cdf0e10cSrcweir 1399cdf0e10cSrcweir if ( !xSubStorage.is() ) 1400cdf0e10cSrcweir throw uno::RuntimeException(); //TODO 1401cdf0e10cSrcweir 1402cdf0e10cSrcweir if ( m_nObjectState != embed::EmbedStates::LOADED ) 1403cdf0e10cSrcweir { 1404cdf0e10cSrcweir aGuard.clear(); 1405cdf0e10cSrcweir // TODO/LATER: support hierarchical name for embedded objects in embedded objects 1406cdf0e10cSrcweir StoreDocToStorage_Impl( xSubStorage, nTargetStorageFormat, GetBaseURLFrom_Impl( lArguments, lObjArgs ), sEntName, sal_False ); 1407cdf0e10cSrcweir aGuard.reset(); 1408cdf0e10cSrcweir 1409cdf0e10cSrcweir if ( bSwitchBackToLoaded ) 1410cdf0e10cSrcweir changeState( embed::EmbedStates::LOADED ); 1411cdf0e10cSrcweir } 1412cdf0e10cSrcweir 1413cdf0e10cSrcweir m_bWaitSaveCompleted = sal_True; 1414cdf0e10cSrcweir m_xNewObjectStorage = xSubStorage; 1415cdf0e10cSrcweir m_xNewParentStorage = xStorage; 1416cdf0e10cSrcweir m_aNewEntryName = sEntName; 1417cdf0e10cSrcweir m_aNewDocMediaDescriptor = GetValuableArgs_Impl( lArguments, sal_True ); 1418cdf0e10cSrcweir 1419cdf0e10cSrcweir // TODO: register listeners for storages above, in case thay are disposed 1420cdf0e10cSrcweir // an exception will be thrown on saveCompleted( true ) 1421cdf0e10cSrcweir 1422cdf0e10cSrcweir // TODO: should the listener notification be done here or in saveCompleted? 1423cdf0e10cSrcweir } 1424cdf0e10cSrcweir 1425cdf0e10cSrcweir //------------------------------------------------------ 1426cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::saveCompleted( sal_Bool bUseNew ) 1427cdf0e10cSrcweir throw ( embed::WrongStateException, 1428cdf0e10cSrcweir uno::Exception, 1429cdf0e10cSrcweir uno::RuntimeException ) 1430cdf0e10cSrcweir { 1431cdf0e10cSrcweir RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OCommonEmbeddedObject::saveCompleted" ); 1432cdf0e10cSrcweir 1433cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1434cdf0e10cSrcweir if ( m_bDisposed ) 1435cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1436cdf0e10cSrcweir 1437cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1438cdf0e10cSrcweir { 1439cdf0e10cSrcweir // the object is still not loaded 1440cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Can't store object without persistence!\n" ), 1441cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1442cdf0e10cSrcweir } 1443cdf0e10cSrcweir 1444cdf0e10cSrcweir // for now support of this interface is required to allow breaking of links and converting them to normal embedded 1445cdf0e10cSrcweir // objects, so the persist name must be handled correctly ( althowgh no real persist entry is used ) 1446cdf0e10cSrcweir // OSL_ENSURE( !m_bIsLink, "This method implementation must not be used for links!\n" ); 1447cdf0e10cSrcweir if ( m_bIsLink ) 1448cdf0e10cSrcweir { 1449cdf0e10cSrcweir if ( bUseNew ) 1450cdf0e10cSrcweir m_aEntryName = m_aNewEntryName; 1451cdf0e10cSrcweir m_aNewEntryName = ::rtl::OUString(); 1452cdf0e10cSrcweir return; 1453cdf0e10cSrcweir } 1454cdf0e10cSrcweir 1455cdf0e10cSrcweir // it is allowed to call saveCompleted( false ) for nonstored objects 1456cdf0e10cSrcweir if ( !m_bWaitSaveCompleted && !bUseNew ) 1457cdf0e10cSrcweir return; 1458cdf0e10cSrcweir 1459cdf0e10cSrcweir OSL_ENSURE( m_bWaitSaveCompleted, "Unexpected saveCompleted() call!\n" ); 1460cdf0e10cSrcweir if ( !m_bWaitSaveCompleted ) 1461cdf0e10cSrcweir throw io::IOException(); // TODO: illegal call 1462cdf0e10cSrcweir 1463cdf0e10cSrcweir OSL_ENSURE( m_xNewObjectStorage.is() && m_xNewParentStorage.is() , "Internal object information is broken!\n" ); 1464cdf0e10cSrcweir if ( !m_xNewObjectStorage.is() || !m_xNewParentStorage.is() ) 1465cdf0e10cSrcweir throw uno::RuntimeException(); // TODO: broken internal information 1466cdf0e10cSrcweir 1467cdf0e10cSrcweir if ( bUseNew ) 1468cdf0e10cSrcweir { 1469cdf0e10cSrcweir SwitchOwnPersistence( m_xNewParentStorage, m_xNewObjectStorage, m_aNewEntryName ); 1470cdf0e10cSrcweir m_aDocMediaDescriptor = m_aNewDocMediaDescriptor; 1471cdf0e10cSrcweir 1472cdf0e10cSrcweir uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 1473cdf0e10cSrcweir if ( xModif.is() ) 1474cdf0e10cSrcweir xModif->setModified( sal_False ); 1475cdf0e10cSrcweir 1476cdf0e10cSrcweir PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSaveAsDone" ) ); 1477cdf0e10cSrcweir } 1478cdf0e10cSrcweir else 1479cdf0e10cSrcweir { 1480cdf0e10cSrcweir try { 1481cdf0e10cSrcweir uno::Reference< lang::XComponent > xComponent( m_xNewObjectStorage, uno::UNO_QUERY ); 1482cdf0e10cSrcweir OSL_ENSURE( xComponent.is(), "Wrong storage implementation!" ); 1483cdf0e10cSrcweir if ( xComponent.is() ) 1484cdf0e10cSrcweir xComponent->dispose(); 1485cdf0e10cSrcweir } 1486cdf0e10cSrcweir catch ( uno::Exception& ) 1487cdf0e10cSrcweir { 1488cdf0e10cSrcweir } 1489cdf0e10cSrcweir } 1490cdf0e10cSrcweir 1491cdf0e10cSrcweir m_xNewObjectStorage = uno::Reference< embed::XStorage >(); 1492cdf0e10cSrcweir m_xNewParentStorage = uno::Reference< embed::XStorage >(); 1493cdf0e10cSrcweir m_aNewEntryName = ::rtl::OUString(); 1494cdf0e10cSrcweir m_aNewDocMediaDescriptor.realloc( 0 ); 1495cdf0e10cSrcweir m_bWaitSaveCompleted = sal_False; 1496cdf0e10cSrcweir 1497cdf0e10cSrcweir if ( bUseNew ) 1498cdf0e10cSrcweir { 1499cdf0e10cSrcweir // TODO: notify listeners 1500cdf0e10cSrcweir 1501cdf0e10cSrcweir if ( m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE ) 1502cdf0e10cSrcweir { 1503cdf0e10cSrcweir // TODO: update visual representation 1504cdf0e10cSrcweir } 1505cdf0e10cSrcweir } 1506cdf0e10cSrcweir } 1507cdf0e10cSrcweir 1508cdf0e10cSrcweir //------------------------------------------------------ 1509cdf0e10cSrcweir sal_Bool SAL_CALL OCommonEmbeddedObject::hasEntry() 1510cdf0e10cSrcweir throw ( embed::WrongStateException, 1511cdf0e10cSrcweir uno::RuntimeException ) 1512cdf0e10cSrcweir { 1513cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1514cdf0e10cSrcweir if ( m_bDisposed ) 1515cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1516cdf0e10cSrcweir 1517cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1518cdf0e10cSrcweir throw embed::WrongStateException( 1519cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1520cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1521cdf0e10cSrcweir 1522cdf0e10cSrcweir if ( m_xObjectStorage.is() ) 1523cdf0e10cSrcweir return sal_True; 1524cdf0e10cSrcweir 1525cdf0e10cSrcweir return sal_False; 1526cdf0e10cSrcweir } 1527cdf0e10cSrcweir 1528cdf0e10cSrcweir //------------------------------------------------------ 1529cdf0e10cSrcweir ::rtl::OUString SAL_CALL OCommonEmbeddedObject::getEntryName() 1530cdf0e10cSrcweir throw ( embed::WrongStateException, 1531cdf0e10cSrcweir uno::RuntimeException ) 1532cdf0e10cSrcweir { 1533cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1534cdf0e10cSrcweir if ( m_bDisposed ) 1535cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1536cdf0e10cSrcweir 1537cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1538cdf0e10cSrcweir { 1539cdf0e10cSrcweir // the object is still not loaded 1540cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object persistence is not initialized!\n" ), 1541cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1542cdf0e10cSrcweir } 1543cdf0e10cSrcweir 1544cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1545cdf0e10cSrcweir throw embed::WrongStateException( 1546cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1547cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1548cdf0e10cSrcweir 1549cdf0e10cSrcweir return m_aEntryName; 1550cdf0e10cSrcweir } 1551cdf0e10cSrcweir 1552cdf0e10cSrcweir //------------------------------------------------------ 1553cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::storeOwn() 1554cdf0e10cSrcweir throw ( embed::WrongStateException, 1555cdf0e10cSrcweir io::IOException, 1556cdf0e10cSrcweir uno::Exception, 1557cdf0e10cSrcweir uno::RuntimeException ) 1558cdf0e10cSrcweir { 1559cdf0e10cSrcweir RTL_LOGFILE_CONTEXT( aLog, "embeddedobj (mv76033) OCommonEmbeddedObject::storeOwn" ); 1560cdf0e10cSrcweir 1561cdf0e10cSrcweir // during switching from Activated to Running and from Running to Loaded states the object will 1562cdf0e10cSrcweir // ask container to store the object, the container has to make decision 1563cdf0e10cSrcweir // to do so or not 1564cdf0e10cSrcweir 1565cdf0e10cSrcweir ::osl::ResettableMutexGuard aGuard( m_aMutex ); 1566cdf0e10cSrcweir if ( m_bDisposed ) 1567cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1568cdf0e10cSrcweir 1569cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1570cdf0e10cSrcweir { 1571cdf0e10cSrcweir // the object is still not loaded 1572cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "Can't store object without persistence!\n" ), 1573cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1574cdf0e10cSrcweir } 1575cdf0e10cSrcweir 1576cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1577cdf0e10cSrcweir throw embed::WrongStateException( 1578cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1579cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1580cdf0e10cSrcweir 1581cdf0e10cSrcweir if ( m_bReadOnly ) 1582cdf0e10cSrcweir throw io::IOException(); // TODO: access denied 1583cdf0e10cSrcweir 1584cdf0e10cSrcweir // nothing to do, if the object is in loaded state 1585cdf0e10cSrcweir if ( m_nObjectState == embed::EmbedStates::LOADED ) 1586cdf0e10cSrcweir return; 1587cdf0e10cSrcweir 1588cdf0e10cSrcweir PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSave" ) ); 1589cdf0e10cSrcweir 1590cdf0e10cSrcweir OSL_ENSURE( m_pDocHolder->GetComponent().is(), "If an object is activated or in running state it must have a document!\n" ); 1591cdf0e10cSrcweir if ( !m_pDocHolder->GetComponent().is() ) 1592cdf0e10cSrcweir throw uno::RuntimeException(); 1593cdf0e10cSrcweir 1594cdf0e10cSrcweir if ( m_bIsLink ) 1595cdf0e10cSrcweir { 1596cdf0e10cSrcweir // TODO: just store the document to it's location 1597cdf0e10cSrcweir uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 1598cdf0e10cSrcweir if ( !xStorable.is() ) 1599cdf0e10cSrcweir throw uno::RuntimeException(); // TODO 1600cdf0e10cSrcweir 1601cdf0e10cSrcweir // free the main mutex for the storing time 1602cdf0e10cSrcweir aGuard.clear(); 1603cdf0e10cSrcweir 1604cdf0e10cSrcweir xStorable->store(); 1605cdf0e10cSrcweir 1606cdf0e10cSrcweir aGuard.reset(); 1607cdf0e10cSrcweir } 1608cdf0e10cSrcweir else 1609cdf0e10cSrcweir { 1610cdf0e10cSrcweir OSL_ENSURE( m_xParentStorage.is() && m_xObjectStorage.is(), "The object has no valid persistence!\n" ); 1611cdf0e10cSrcweir 1612cdf0e10cSrcweir if ( !m_xObjectStorage.is() ) 1613cdf0e10cSrcweir throw io::IOException(); //TODO: access denied 1614cdf0e10cSrcweir 1615cdf0e10cSrcweir sal_Int32 nStorageFormat = SOFFICE_FILEFORMAT_CURRENT; 1616cdf0e10cSrcweir try { 1617cdf0e10cSrcweir nStorageFormat = ::comphelper::OStorageHelper::GetXStorageFormat( m_xParentStorage ); 1618cdf0e10cSrcweir } 1619cdf0e10cSrcweir catch ( beans::IllegalTypeException& ) 1620cdf0e10cSrcweir { 1621cdf0e10cSrcweir // the container just has an unknown type, use current file format 1622cdf0e10cSrcweir } 1623cdf0e10cSrcweir catch ( uno::Exception& ) 1624cdf0e10cSrcweir { 1625cdf0e10cSrcweir OSL_ENSURE( sal_False, "Can not retrieve storage media type!\n" ); 1626cdf0e10cSrcweir } 1627cdf0e10cSrcweir 1628cdf0e10cSrcweir aGuard.clear(); 1629cdf0e10cSrcweir StoreDocToStorage_Impl( m_xObjectStorage, nStorageFormat, GetBaseURL_Impl(), m_aEntryName, sal_True ); 1630cdf0e10cSrcweir aGuard.reset(); 1631cdf0e10cSrcweir } 1632cdf0e10cSrcweir 1633cdf0e10cSrcweir uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 1634cdf0e10cSrcweir if ( xModif.is() ) 1635cdf0e10cSrcweir xModif->setModified( sal_False ); 1636cdf0e10cSrcweir 1637cdf0e10cSrcweir PostEvent_Impl( ::rtl::OUString::createFromAscii( "OnSaveDone" ) ); 1638cdf0e10cSrcweir } 1639cdf0e10cSrcweir 1640cdf0e10cSrcweir //------------------------------------------------------ 1641cdf0e10cSrcweir sal_Bool SAL_CALL OCommonEmbeddedObject::isReadonly() 1642cdf0e10cSrcweir throw ( embed::WrongStateException, 1643cdf0e10cSrcweir uno::RuntimeException ) 1644cdf0e10cSrcweir { 1645cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1646cdf0e10cSrcweir if ( m_bDisposed ) 1647cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1648cdf0e10cSrcweir 1649cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1650cdf0e10cSrcweir { 1651cdf0e10cSrcweir // the object is still not loaded 1652cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object persistence is not initialized!\n" ), 1653cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1654cdf0e10cSrcweir } 1655cdf0e10cSrcweir 1656cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1657cdf0e10cSrcweir throw embed::WrongStateException( 1658cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1659cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1660cdf0e10cSrcweir 1661cdf0e10cSrcweir return m_bReadOnly; 1662cdf0e10cSrcweir } 1663cdf0e10cSrcweir 1664cdf0e10cSrcweir //------------------------------------------------------ 1665cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::reload( 1666cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lArguments, 1667cdf0e10cSrcweir const uno::Sequence< beans::PropertyValue >& lObjArgs ) 1668cdf0e10cSrcweir throw ( lang::IllegalArgumentException, 1669cdf0e10cSrcweir embed::WrongStateException, 1670cdf0e10cSrcweir io::IOException, 1671cdf0e10cSrcweir uno::Exception, 1672cdf0e10cSrcweir uno::RuntimeException ) 1673cdf0e10cSrcweir { 1674cdf0e10cSrcweir // TODO: use lObjArgs 1675cdf0e10cSrcweir // for now this method is used only to switch readonly state 1676cdf0e10cSrcweir 1677cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1678cdf0e10cSrcweir if ( m_bDisposed ) 1679cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1680cdf0e10cSrcweir 1681cdf0e10cSrcweir if ( m_nObjectState == -1 ) 1682cdf0e10cSrcweir { 1683cdf0e10cSrcweir // the object is still not loaded 1684cdf0e10cSrcweir throw embed::WrongStateException( ::rtl::OUString::createFromAscii( "The object persistence is not initialized!\n" ), 1685cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1686cdf0e10cSrcweir } 1687cdf0e10cSrcweir 1688cdf0e10cSrcweir if ( m_nObjectState != embed::EmbedStates::LOADED ) 1689cdf0e10cSrcweir { 1690cdf0e10cSrcweir // the object is still not loaded 1691cdf0e10cSrcweir throw embed::WrongStateException( 1692cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object must be in loaded state to be reloaded!\n" ), 1693cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1694cdf0e10cSrcweir } 1695cdf0e10cSrcweir 1696cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1697cdf0e10cSrcweir throw embed::WrongStateException( 1698cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1699cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1700cdf0e10cSrcweir 1701cdf0e10cSrcweir if ( m_bIsLink ) 1702cdf0e10cSrcweir { 1703cdf0e10cSrcweir // reload of the link 1704cdf0e10cSrcweir ::rtl::OUString aOldLinkFilter = m_aLinkFilterName; 1705cdf0e10cSrcweir 1706cdf0e10cSrcweir ::rtl::OUString aNewLinkFilter; 1707cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ ) 1708cdf0e10cSrcweir { 1709cdf0e10cSrcweir if ( lArguments[nInd].Name.equalsAscii( "URL" ) ) 1710cdf0e10cSrcweir { 1711cdf0e10cSrcweir // the new URL 1712cdf0e10cSrcweir lArguments[nInd].Value >>= m_aLinkURL; 1713cdf0e10cSrcweir m_aLinkFilterName = ::rtl::OUString(); 1714cdf0e10cSrcweir } 1715cdf0e10cSrcweir else if ( lArguments[nInd].Name.equalsAscii( "FilterName" ) ) 1716cdf0e10cSrcweir { 1717cdf0e10cSrcweir lArguments[nInd].Value >>= aNewLinkFilter; 1718cdf0e10cSrcweir m_aLinkFilterName = ::rtl::OUString(); 1719cdf0e10cSrcweir } 1720cdf0e10cSrcweir } 1721cdf0e10cSrcweir 1722cdf0e10cSrcweir ::comphelper::MimeConfigurationHelper aHelper( m_xFactory ); 1723cdf0e10cSrcweir if ( !m_aLinkFilterName.getLength() ) 1724cdf0e10cSrcweir { 1725cdf0e10cSrcweir if ( aNewLinkFilter.getLength() ) 1726cdf0e10cSrcweir m_aLinkFilterName = aNewLinkFilter; 1727cdf0e10cSrcweir else 1728cdf0e10cSrcweir { 1729cdf0e10cSrcweir uno::Sequence< beans::PropertyValue > aArgs( 1 ); 1730cdf0e10cSrcweir aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ); 1731cdf0e10cSrcweir aArgs[0].Value <<= m_aLinkURL; 1732cdf0e10cSrcweir m_aLinkFilterName = aHelper.UpdateMediaDescriptorWithFilterName( aArgs, sal_False ); 1733cdf0e10cSrcweir } 1734cdf0e10cSrcweir } 1735cdf0e10cSrcweir 1736cdf0e10cSrcweir if ( !aOldLinkFilter.equals( m_aLinkFilterName ) ) 1737cdf0e10cSrcweir { 1738cdf0e10cSrcweir uno::Sequence< beans::NamedValue > aObject = aHelper.GetObjectPropsByFilter( m_aLinkFilterName ); 1739cdf0e10cSrcweir 1740cdf0e10cSrcweir // TODO/LATER: probably the document holder could be cleaned explicitly as in the destructor 1741cdf0e10cSrcweir m_pDocHolder->release(); 1742cdf0e10cSrcweir m_pDocHolder = NULL; 1743cdf0e10cSrcweir 1744cdf0e10cSrcweir LinkInit_Impl( aObject, lArguments, lObjArgs ); 1745cdf0e10cSrcweir } 1746cdf0e10cSrcweir } 1747cdf0e10cSrcweir 1748cdf0e10cSrcweir m_aDocMediaDescriptor = GetValuableArgs_Impl( lArguments, sal_True ); 1749cdf0e10cSrcweir 1750cdf0e10cSrcweir // TODO: use lObjArgs for StoreVisualReplacement 1751cdf0e10cSrcweir for ( sal_Int32 nObjInd = 0; nObjInd < lObjArgs.getLength(); nObjInd++ ) 1752cdf0e10cSrcweir if ( lObjArgs[nObjInd].Name.equalsAscii( "OutplaceDispatchInterceptor" ) ) 1753cdf0e10cSrcweir { 1754cdf0e10cSrcweir uno::Reference< frame::XDispatchProviderInterceptor > xDispatchInterceptor; 1755cdf0e10cSrcweir if ( lObjArgs[nObjInd].Value >>= xDispatchInterceptor ) 1756cdf0e10cSrcweir m_pDocHolder->SetOutplaceDispatchInterceptor( xDispatchInterceptor ); 1757cdf0e10cSrcweir 1758cdf0e10cSrcweir break; 1759cdf0e10cSrcweir } 1760cdf0e10cSrcweir 1761cdf0e10cSrcweir // TODO: 1762cdf0e10cSrcweir // when document allows reloading through API the object can be reloaded not only in loaded state 1763cdf0e10cSrcweir 1764cdf0e10cSrcweir sal_Bool bOldReadOnlyValue = m_bReadOnly; 1765cdf0e10cSrcweir 1766cdf0e10cSrcweir m_bReadOnly = sal_False; 1767cdf0e10cSrcweir for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ ) 1768cdf0e10cSrcweir if ( lArguments[nInd].Name.equalsAscii( "ReadOnly" ) ) 1769cdf0e10cSrcweir lArguments[nInd].Value >>= m_bReadOnly; 1770cdf0e10cSrcweir 1771cdf0e10cSrcweir if ( bOldReadOnlyValue != m_bReadOnly && !m_bIsLink ) 1772cdf0e10cSrcweir { 1773cdf0e10cSrcweir // close own storage 1774cdf0e10cSrcweir try { 1775cdf0e10cSrcweir uno::Reference< lang::XComponent > xComponent( m_xObjectStorage, uno::UNO_QUERY ); 1776cdf0e10cSrcweir OSL_ENSURE( !m_xObjectStorage.is() || xComponent.is(), "Wrong storage implementation!" ); 1777cdf0e10cSrcweir if ( xComponent.is() ) 1778cdf0e10cSrcweir xComponent->dispose(); 1779cdf0e10cSrcweir } 1780cdf0e10cSrcweir catch ( uno::Exception& ) 1781cdf0e10cSrcweir { 1782cdf0e10cSrcweir } 1783cdf0e10cSrcweir 1784cdf0e10cSrcweir sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE; 1785cdf0e10cSrcweir m_xObjectStorage = m_xParentStorage->openStorageElement( m_aEntryName, nStorageMode ); 1786cdf0e10cSrcweir } 1787cdf0e10cSrcweir } 1788cdf0e10cSrcweir 1789cdf0e10cSrcweir //------------------------------------------------------ 1790cdf0e10cSrcweir void SAL_CALL OCommonEmbeddedObject::breakLink( const uno::Reference< embed::XStorage >& xStorage, 1791cdf0e10cSrcweir const ::rtl::OUString& sEntName ) 1792cdf0e10cSrcweir throw ( lang::IllegalArgumentException, 1793cdf0e10cSrcweir embed::WrongStateException, 1794cdf0e10cSrcweir io::IOException, 1795cdf0e10cSrcweir uno::Exception, 1796cdf0e10cSrcweir uno::RuntimeException ) 1797cdf0e10cSrcweir { 1798cdf0e10cSrcweir ::osl::ResettableMutexGuard aGuard( m_aMutex ); 1799cdf0e10cSrcweir if ( m_bDisposed ) 1800cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1801cdf0e10cSrcweir 1802cdf0e10cSrcweir if ( !m_bIsLink ) 1803cdf0e10cSrcweir { 1804cdf0e10cSrcweir // it must be a linked initialized object 1805cdf0e10cSrcweir throw embed::WrongStateException( 1806cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object is not a valid linked object!\n" ), 1807cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1808cdf0e10cSrcweir } 1809cdf0e10cSrcweir #if 0 1810cdf0e10cSrcweir else 1811cdf0e10cSrcweir { 1812cdf0e10cSrcweir // the current implementation of OOo links does not implement this method since it does not implement 1813cdf0e10cSrcweir // all the set of interfaces required for OOo embedded object ( XEmbedPersist is not supported ). 1814cdf0e10cSrcweir throw io::IOException(); // TODO: 1815cdf0e10cSrcweir } 1816cdf0e10cSrcweir #endif 1817cdf0e10cSrcweir 1818cdf0e10cSrcweir if ( !xStorage.is() ) 1819cdf0e10cSrcweir throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "No parent storage is provided!\n" ), 1820cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 1821cdf0e10cSrcweir 1 ); 1822cdf0e10cSrcweir 1823cdf0e10cSrcweir if ( !sEntName.getLength() ) 1824cdf0e10cSrcweir throw lang::IllegalArgumentException( ::rtl::OUString::createFromAscii( "Empty element name is provided!\n" ), 1825cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ), 1826cdf0e10cSrcweir 2 ); 1827cdf0e10cSrcweir 1828cdf0e10cSrcweir if ( !m_bIsLink || m_nObjectState == -1 ) 1829cdf0e10cSrcweir { 1830cdf0e10cSrcweir // it must be a linked initialized object 1831cdf0e10cSrcweir throw embed::WrongStateException( 1832cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object is not a valid linked object!\n" ), 1833cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1834cdf0e10cSrcweir } 1835cdf0e10cSrcweir 1836cdf0e10cSrcweir if ( m_bWaitSaveCompleted ) 1837cdf0e10cSrcweir throw embed::WrongStateException( 1838cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1839cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1840cdf0e10cSrcweir 1841cdf0e10cSrcweir uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY ); 1842cdf0e10cSrcweir if ( !xNameAccess.is() ) 1843cdf0e10cSrcweir throw uno::RuntimeException(); //TODO 1844cdf0e10cSrcweir 1845cdf0e10cSrcweir // detect entry existence 1846cdf0e10cSrcweir /*sal_Bool bElExists =*/ xNameAccess->hasByName( sEntName ); 1847cdf0e10cSrcweir 1848cdf0e10cSrcweir m_bReadOnly = sal_False; 1849cdf0e10cSrcweir // sal_Int32 nStorageMode = embed::ElementModes::READWRITE; 1850cdf0e10cSrcweir 1851cdf0e10cSrcweir if ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) ) 1852cdf0e10cSrcweir SwitchOwnPersistence( xStorage, sEntName ); 1853cdf0e10cSrcweir 1854cdf0e10cSrcweir // for linked object it means that it becomes embedded object 1855cdf0e10cSrcweir // the document must switch it's persistence also 1856cdf0e10cSrcweir 1857cdf0e10cSrcweir // TODO/LATER: handle the case when temp doc can not be created 1858cdf0e10cSrcweir // the document is a new embedded object so it must be marked as modified 1859cdf0e10cSrcweir uno::Reference< util::XCloseable > xDocument = CreateTempDocFromLink_Impl(); 1860cdf0e10cSrcweir uno::Reference< util::XModifiable > xModif( m_pDocHolder->GetComponent(), uno::UNO_QUERY ); 1861cdf0e10cSrcweir if ( !xModif.is() ) 1862cdf0e10cSrcweir throw uno::RuntimeException(); 1863cdf0e10cSrcweir try 1864cdf0e10cSrcweir { 1865cdf0e10cSrcweir xModif->setModified( sal_True ); 1866cdf0e10cSrcweir } 1867cdf0e10cSrcweir catch( uno::Exception& ) 1868cdf0e10cSrcweir {} 1869cdf0e10cSrcweir 1870cdf0e10cSrcweir m_pDocHolder->SetComponent( xDocument, m_bReadOnly ); 1871*07a3d7f1SPedro Giffuni OSL_ENSURE( m_pDocHolder->GetComponent().is(), "If document can't be created, an exception must be thrown!\n" ); 1872cdf0e10cSrcweir 1873cdf0e10cSrcweir if ( m_nObjectState == embed::EmbedStates::LOADED ) 1874cdf0e10cSrcweir { 1875cdf0e10cSrcweir // the state is changed and can not be switched to loaded state back without saving 1876cdf0e10cSrcweir m_nObjectState = embed::EmbedStates::RUNNING; 1877cdf0e10cSrcweir StateChangeNotification_Impl( sal_False, embed::EmbedStates::LOADED, m_nObjectState, aGuard ); 1878cdf0e10cSrcweir } 1879cdf0e10cSrcweir else if ( m_nObjectState == embed::EmbedStates::ACTIVE ) 1880cdf0e10cSrcweir m_pDocHolder->Show(); 1881cdf0e10cSrcweir 1882cdf0e10cSrcweir m_bIsLink = sal_False; 1883cdf0e10cSrcweir m_aLinkFilterName = ::rtl::OUString(); 1884cdf0e10cSrcweir m_aLinkURL = ::rtl::OUString(); 1885cdf0e10cSrcweir } 1886cdf0e10cSrcweir 1887cdf0e10cSrcweir //------------------------------------------------------ 1888cdf0e10cSrcweir sal_Bool SAL_CALL OCommonEmbeddedObject::isLink() 1889cdf0e10cSrcweir throw ( embed::WrongStateException, 1890cdf0e10cSrcweir uno::RuntimeException ) 1891cdf0e10cSrcweir { 1892cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1893cdf0e10cSrcweir if ( m_bDisposed ) 1894cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1895cdf0e10cSrcweir 1896cdf0e10cSrcweir // Actually this information is clear even in case object is wayting for saveCompleted 1897cdf0e10cSrcweir // if ( m_bWaitSaveCompleted ) 1898cdf0e10cSrcweir // throw embed::WrongStateException( 1899cdf0e10cSrcweir // ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1900cdf0e10cSrcweir // uno::Reference< uno::XInterface >( reinterpret_cast< ::cppu::OWeakObject* >(this) ) ); 1901cdf0e10cSrcweir 1902cdf0e10cSrcweir return m_bIsLink; 1903cdf0e10cSrcweir } 1904cdf0e10cSrcweir 1905cdf0e10cSrcweir //------------------------------------------------------ 1906cdf0e10cSrcweir ::rtl::OUString SAL_CALL OCommonEmbeddedObject::getLinkURL() 1907cdf0e10cSrcweir throw ( embed::WrongStateException, 1908cdf0e10cSrcweir uno::Exception, 1909cdf0e10cSrcweir uno::RuntimeException ) 1910cdf0e10cSrcweir { 1911cdf0e10cSrcweir ::osl::MutexGuard aGuard( m_aMutex ); 1912cdf0e10cSrcweir if ( m_bDisposed ) 1913cdf0e10cSrcweir throw lang::DisposedException(); // TODO 1914cdf0e10cSrcweir 1915cdf0e10cSrcweir // Actually this information is clear even in case object is wayting for saveCompleted 1916cdf0e10cSrcweir // if ( m_bWaitSaveCompleted ) 1917cdf0e10cSrcweir // throw embed::WrongStateException( 1918cdf0e10cSrcweir // ::rtl::OUString::createFromAscii( "The object waits for saveCompleted() call!\n" ), 1919cdf0e10cSrcweir // uno::Reference< uno::XInterface >( reinterpret_cast< ::cppu::OWeakObject* >(this) ) ); 1920cdf0e10cSrcweir 1921cdf0e10cSrcweir if ( !m_bIsLink ) 1922cdf0e10cSrcweir throw embed::WrongStateException( 1923cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "The object is not a link object!\n" ), 1924cdf0e10cSrcweir uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) ); 1925cdf0e10cSrcweir 1926cdf0e10cSrcweir return m_aLinkURL; 1927cdf0e10cSrcweir } 1928cdf0e10cSrcweir 1929