LCOV - code coverage report
Current view: top level - libreoffice/embeddedobj/source/commonembedding - persistence.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 225 777 29.0 %
Date: 2012-12-27 Functions: 18 34 52.9 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10