LCOV - code coverage report
Current view: top level - embeddedobj/source/msole - olepersist.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 616 0.0 %
Date: 2014-04-14 Functions: 0 28 0.0 %
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 <oleembobj.hxx>
      21             : #include <com/sun/star/embed/EmbedStates.hpp>
      22             : #include <com/sun/star/embed/EmbedVerbs.hpp>
      23             : #include <com/sun/star/embed/EntryInitModes.hpp>
      24             : #include <com/sun/star/embed/XStorage.hpp>
      25             : #include <com/sun/star/embed/XTransactedObject.hpp>
      26             : #include <com/sun/star/embed/ElementModes.hpp>
      27             : #include <com/sun/star/embed/EmbedUpdateModes.hpp>
      28             : #include <com/sun/star/embed/Aspects.hpp>
      29             : #include <com/sun/star/embed/XOptimizedStorage.hpp>
      30             : #include <com/sun/star/lang/XComponent.hpp>
      31             : #include <com/sun/star/lang/DisposedException.hpp>
      32             : #include <com/sun/star/container/XNameAccess.hpp>
      33             : #include <com/sun/star/container/XNameContainer.hpp>
      34             : #include <com/sun/star/io/TempFile.hpp>
      35             : #include <com/sun/star/io/XSeekable.hpp>
      36             : #include <com/sun/star/io/XTruncate.hpp>
      37             : #include <com/sun/star/beans/XPropertySet.hpp>
      38             : #include <com/sun/star/ucb/SimpleFileAccess.hpp>
      39             : 
      40             : #include <comphelper/processfactory.hxx>
      41             : #include <comphelper/storagehelper.hxx>
      42             : #include <comphelper/mimeconfighelper.hxx>
      43             : #include <comphelper/classids.hxx>
      44             : #include <osl/thread.hxx>
      45             : 
      46             : #include <closepreventer.hxx>
      47             : 
      48             : #if defined WNT
      49             : #include <olecomponent.hxx>
      50             : #endif
      51             : 
      52             : using namespace ::com::sun::star;
      53             : using namespace ::comphelper;
      54             : 
      55             : 
      56           0 : sal_Bool KillFile_Impl( const OUString& aURL, const uno::Reference< lang::XMultiServiceFactory >& xFactory )
      57             : {
      58           0 :     if ( !xFactory.is() )
      59           0 :         return sal_False;
      60             : 
      61           0 :     sal_Bool bRet = sal_False;
      62             : 
      63             :     try
      64             :     {
      65             :         uno::Reference < ucb::XSimpleFileAccess3 > xAccess(
      66           0 :                 ucb::SimpleFileAccess::create( comphelper::getComponentContext(xFactory) ) );
      67             : 
      68           0 :         xAccess->kill( aURL );
      69           0 :         bRet = sal_True;
      70             :     }
      71           0 :     catch( const uno::Exception& )
      72             :     {
      73             :     }
      74             : 
      75           0 :     return bRet;
      76             : }
      77             : 
      78             : 
      79           0 : OUString GetNewTempFileURL_Impl( const uno::Reference< lang::XMultiServiceFactory >& xFactory )
      80             : {
      81             :     SAL_WARN_IF( !xFactory.is(), "embeddedobj.ole", "No factory is provided!" );
      82             : 
      83           0 :     OUString aResult;
      84             : 
      85             :     uno::Reference < beans::XPropertySet > xTempFile(
      86             :             io::TempFile::create(comphelper::getComponentContext(xFactory)),
      87           0 :             uno::UNO_QUERY_THROW );
      88             : 
      89             :     try {
      90           0 :         xTempFile->setPropertyValue("RemoveFile", uno::makeAny( sal_False ) );
      91           0 :         uno::Any aUrl = xTempFile->getPropertyValue("Uri");
      92           0 :         aUrl >>= aResult;
      93             :     }
      94           0 :     catch ( const uno::Exception& )
      95             :     {
      96             :     }
      97             : 
      98           0 :     if ( aResult.isEmpty() )
      99           0 :         throw uno::RuntimeException(); // TODO: can not create tempfile
     100             : 
     101           0 :     return aResult;
     102             : }
     103             : 
     104             : 
     105           0 : OUString GetNewFilledTempFile_Impl( const uno::Reference< io::XInputStream >& xInStream,
     106             :                                       const uno::Reference< lang::XMultiServiceFactory >& xFactory )
     107             :         throw ( io::IOException,
     108             :                 uno::RuntimeException )
     109             : {
     110             :     OSL_ENSURE( xInStream.is() && xFactory.is(), "Wrong parameters are provided!\n" );
     111             : 
     112           0 :     OUString aResult = GetNewTempFileURL_Impl( xFactory );
     113             : 
     114           0 :     if ( !aResult.isEmpty() )
     115             :     {
     116             :         try {
     117             :             uno::Reference < ucb::XSimpleFileAccess3 > xTempAccess(
     118           0 :                     ucb::SimpleFileAccess::create( comphelper::getComponentContext(xFactory) ) );
     119             : 
     120           0 :             uno::Reference< io::XOutputStream > xTempOutStream = xTempAccess->openFileWrite( aResult );
     121           0 :             if ( xTempOutStream.is() )
     122             :             {
     123             :                 // copy stream contents to the file
     124           0 :                 ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOutStream );
     125           0 :                 xTempOutStream->closeOutput();
     126           0 :                 xTempOutStream = uno::Reference< io::XOutputStream >();
     127             :             }
     128             :             else
     129           0 :                 throw io::IOException(); // TODO:
     130             :         }
     131           0 :         catch( const packages::WrongPasswordException& )
     132             :         {
     133           0 :                KillFile_Impl( aResult, xFactory );
     134           0 :             throw io::IOException(); //TODO:
     135             :         }
     136           0 :         catch( const io::IOException& )
     137             :         {
     138           0 :                KillFile_Impl( aResult, xFactory );
     139           0 :             throw;
     140             :         }
     141           0 :         catch( const uno::RuntimeException& )
     142             :         {
     143           0 :                KillFile_Impl( aResult, xFactory );
     144           0 :             throw;
     145             :         }
     146           0 :         catch( const uno::Exception& )
     147             :         {
     148           0 :                KillFile_Impl( aResult, xFactory );
     149           0 :             aResult = OUString();
     150             :         }
     151             :     }
     152             : 
     153           0 :     return aResult;
     154             : }
     155             : #ifdef WNT
     156             : OUString GetNewFilledTempFile_Impl( const uno::Reference< embed::XOptimizedStorage >& xParentStorage, const OUString& aEntryName, const uno::Reference< lang::XMultiServiceFactory >& xFactory )
     157             :     throw( io::IOException, uno::RuntimeException )
     158             : {
     159             :     OUString aResult;
     160             : 
     161             :     try
     162             :     {
     163             :         uno::Reference < beans::XPropertySet > xTempFile(
     164             :                 io::TempFile::create(comphelper::getComponentContext(xFactory)),
     165             :                 uno::UNO_QUERY );
     166             :         uno::Reference < io::XStream > xTempStream( xTempFile, uno::UNO_QUERY_THROW );
     167             : 
     168             :         xParentStorage->copyStreamElementData( aEntryName, xTempStream );
     169             : 
     170             :         xTempFile->setPropertyValue("RemoveFile", uno::makeAny( sal_False ) );
     171             :         uno::Any aUrl = xTempFile->getPropertyValue("Uri");
     172             :         aUrl >>= aResult;
     173             :     }
     174             :     catch( const uno::RuntimeException& )
     175             :     {
     176             :         throw;
     177             :     }
     178             :     catch( const uno::Exception& )
     179             :     {
     180             :     }
     181             : 
     182             :     if ( aResult.isEmpty() )
     183             :         throw io::IOException();
     184             : 
     185             :     return aResult;
     186             : }
     187             : 
     188             : 
     189             : void SetStreamMediaType_Impl( const uno::Reference< io::XStream >& xStream, const OUString& aMediaType )
     190             : {
     191             :     uno::Reference< beans::XPropertySet > xPropSet( xStream, uno::UNO_QUERY );
     192             :     if ( !xPropSet.is() )
     193             :         throw uno::RuntimeException(); // TODO: all the storage streams must support XPropertySet
     194             : 
     195             :     xPropSet->setPropertyValue("MediaType", uno::makeAny( aMediaType ) );
     196             : }
     197             : #endif
     198             : 
     199           0 : void LetCommonStoragePassBeUsed_Impl( const uno::Reference< io::XStream >& xStream )
     200             : {
     201           0 :     uno::Reference< beans::XPropertySet > xPropSet( xStream, uno::UNO_QUERY );
     202           0 :     if ( !xPropSet.is() )
     203           0 :         throw uno::RuntimeException(); // Only StorageStreams must be provided here, they must implement the interface
     204             : 
     205           0 :     xPropSet->setPropertyValue("UseCommonStoragePasswordEncryption",
     206           0 :                                 uno::makeAny( (sal_Bool)sal_True ) );
     207           0 : }
     208             : #ifdef WNT
     209             : 
     210             : void VerbExecutionController::StartControlExecution()
     211             : {
     212             :     osl::MutexGuard aGuard( m_aVerbExecutionMutex );
     213             : 
     214             :     // the class is used to detect STAMPIT object, that can never be active
     215             :     if ( !m_bVerbExecutionInProgress && !m_bWasEverActive )
     216             :     {
     217             :         m_bVerbExecutionInProgress = sal_True;
     218             :         m_nVerbExecutionThreadIdentifier = osl::Thread::getCurrentIdentifier();
     219             :         m_bChangedOnVerbExecution = sal_False;
     220             :     }
     221             : }
     222             : 
     223             : 
     224             : sal_Bool VerbExecutionController::EndControlExecution_WasModified()
     225             : {
     226             :     osl::MutexGuard aGuard( m_aVerbExecutionMutex );
     227             : 
     228             :     sal_Bool bResult = sal_False;
     229             :     if ( m_bVerbExecutionInProgress && m_nVerbExecutionThreadIdentifier == osl::Thread::getCurrentIdentifier() )
     230             :     {
     231             :         bResult = m_bChangedOnVerbExecution;
     232             :         m_bVerbExecutionInProgress = sal_False;
     233             :     }
     234             : 
     235             :     return bResult;
     236             : }
     237             : 
     238             : 
     239             : void VerbExecutionController::ModificationNotificationIsDone()
     240             : {
     241             :     osl::MutexGuard aGuard( m_aVerbExecutionMutex );
     242             : 
     243             :     if ( m_bVerbExecutionInProgress && osl::Thread::getCurrentIdentifier() == m_nVerbExecutionThreadIdentifier )
     244             :         m_bChangedOnVerbExecution = sal_True;
     245             : }
     246             : #endif
     247             : 
     248           0 : void VerbExecutionController::LockNotification()
     249             : {
     250           0 :     osl::MutexGuard aGuard( m_aVerbExecutionMutex );
     251           0 :     if ( m_nNotificationLock < SAL_MAX_INT32 )
     252           0 :         m_nNotificationLock++;
     253           0 : }
     254             : 
     255             : 
     256           0 : void VerbExecutionController::UnlockNotification()
     257             : {
     258           0 :     osl::MutexGuard aGuard( m_aVerbExecutionMutex );
     259           0 :     if ( m_nNotificationLock > 0 )
     260           0 :         m_nNotificationLock--;
     261           0 : }
     262             : 
     263             : 
     264           0 : uno::Reference< io::XStream > OleEmbeddedObject::GetNewFilledTempStream_Impl( const uno::Reference< io::XInputStream >& xInStream )
     265             :         throw( io::IOException, uno::RuntimeException )
     266             : {
     267             :     SAL_WARN_IF( !xInStream.is(), "embeddedobj.ole", "Wrong parameter is provided!" );
     268             : 
     269             :     uno::Reference < io::XStream > xTempFile(
     270             :             io::TempFile::create(comphelper::getComponentContext(m_xFactory)),
     271           0 :             uno::UNO_QUERY_THROW );
     272             : 
     273           0 :     uno::Reference< io::XOutputStream > xTempOutStream = xTempFile->getOutputStream();
     274           0 :     if ( xTempOutStream.is() )
     275             :     {
     276           0 :         ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOutStream );
     277           0 :         xTempOutStream->flush();
     278             :     }
     279             :     else
     280           0 :         throw io::IOException(); // TODO:
     281             : 
     282           0 :     return xTempFile;
     283             : }
     284             : 
     285             : 
     286           0 : uno::Reference< io::XStream > OleEmbeddedObject::TryToGetAcceptableFormat_Impl( const uno::Reference< io::XStream >& xStream )
     287             :         throw ( uno::Exception )
     288             : {
     289             :     // TODO/LATER: Actually this should be done by a centralized component ( may be a graphical filter )
     290           0 :     if ( !m_xFactory.is() )
     291           0 :         throw uno::RuntimeException();
     292             : 
     293           0 :     uno::Reference< io::XInputStream > xInStream = xStream->getInputStream();
     294           0 :     if ( !xInStream.is() )
     295           0 :         throw uno::RuntimeException();
     296             : 
     297           0 :     uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );
     298           0 :     xSeek->seek( 0 );
     299             : 
     300           0 :     uno::Sequence< sal_Int8 > aData( 8 );
     301           0 :     sal_Int32 nRead = xInStream->readBytes( aData, 8 );
     302           0 :     xSeek->seek( 0 );
     303             : 
     304           0 :     if ( ( nRead >= 2 && aData[0] == 'B' && aData[1] == 'M' )
     305           0 :       || ( nRead >= 4 && aData[0] == 1 && aData[1] == 0 && aData[2] == 9 && aData[3] == 0 ) )
     306             :     {
     307             :         // it should be a bitmap or a Metafile
     308           0 :         return xStream;
     309             :     }
     310             : 
     311             : 
     312           0 :     sal_uInt32 nHeaderOffset = 0;
     313           0 :     if ( ( nRead >= 8 && aData[0] == -1 && aData[1] == -1 && aData[2] == -1 && aData[3] == -1 )
     314           0 :       && ( aData[4] == 2 || aData[4] == 3 || aData[4] == 14 ) && aData[5] == 0 && aData[6] == 0 && aData[7] == 0 )
     315             :     {
     316           0 :         nHeaderOffset = 40;
     317           0 :         xSeek->seek( 8 );
     318             : 
     319             :         // TargetDevice might be used in future, currently the cache has specified NULL
     320           0 :         uno::Sequence< sal_Int8 > aHeadData( 4 );
     321           0 :         nRead = xInStream->readBytes( aHeadData, 4 );
     322           0 :         sal_uInt32 nLen = 0;
     323           0 :         if ( nRead == 4 && aHeadData.getLength() == 4 )
     324           0 :             nLen = ( ( ( (sal_uInt32)aHeadData[3] * 0x100 + (sal_uInt32)aHeadData[2] ) * 0x100 ) + (sal_uInt32)aHeadData[1] ) * 0x100 + (sal_uInt32)aHeadData[0];
     325           0 :         if ( nLen > 4 )
     326             :         {
     327           0 :             xInStream->skipBytes( nLen - 4 );
     328           0 :             nHeaderOffset += nLen - 4;
     329           0 :         }
     330             : 
     331             :     }
     332           0 :     else if ( nRead > 4 )
     333             :     {
     334             :         // check whether the first bytes represent the size
     335           0 :         sal_uInt32 nSize = 0;
     336           0 :         for ( sal_Int32 nInd = 3; nInd >= 0; nInd-- )
     337           0 :             nSize = ( nSize << 8 ) + (sal_uInt8)aData[nInd];
     338             : 
     339           0 :         if ( nSize == xSeek->getLength() - 4 )
     340           0 :             nHeaderOffset = 4;
     341             :     }
     342             : 
     343           0 :     if ( nHeaderOffset )
     344             :     {
     345             :         // this is either a bitmap or a metafile clipboard format, retrieve the pure stream
     346             :         uno::Reference < io::XStream > xResult(
     347             :             io::TempFile::create(comphelper::getComponentContext(m_xFactory)),
     348           0 :             uno::UNO_QUERY_THROW );
     349           0 :         uno::Reference < io::XSeekable > xResultSeek( xResult, uno::UNO_QUERY_THROW );
     350           0 :         uno::Reference < io::XOutputStream > xResultOut = xResult->getOutputStream();
     351           0 :         uno::Reference < io::XInputStream > xResultIn = xResult->getInputStream();
     352           0 :         if ( !xResultOut.is() || !xResultIn.is() )
     353           0 :             throw uno::RuntimeException();
     354             : 
     355           0 :         xSeek->seek( nHeaderOffset ); // header size for these formats
     356           0 :         ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xResultOut );
     357           0 :         xResultOut->closeOutput();
     358           0 :         xResultSeek->seek( 0 );
     359           0 :         xSeek->seek( 0 );
     360             : 
     361           0 :         return xResult;
     362             :     }
     363             : 
     364           0 :     return uno::Reference< io::XStream >();
     365             : }
     366             : 
     367             : 
     368           0 : void OleEmbeddedObject::InsertVisualCache_Impl( const uno::Reference< io::XStream >& xTargetStream,
     369             :                                                 const uno::Reference< io::XStream >& xCachedVisualRepresentation )
     370             :         throw ( uno::Exception )
     371             : {
     372             :     OSL_ENSURE( xTargetStream.is() && xCachedVisualRepresentation.is(), "Invalid argumants!\n" );
     373             : 
     374           0 :     if ( !xTargetStream.is() || !xCachedVisualRepresentation.is() )
     375           0 :         throw uno::RuntimeException();
     376             : 
     377           0 :     uno::Sequence< uno::Any > aArgs( 2 );
     378           0 :     aArgs[0] <<= xTargetStream;
     379           0 :     aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
     380             : 
     381             :     uno::Reference< container::XNameContainer > xNameContainer(
     382           0 :             m_xFactory->createInstanceWithArguments(
     383             :                     OUString( "com.sun.star.embed.OLESimpleStorage" ),
     384           0 :                     aArgs ),
     385           0 :             uno::UNO_QUERY );
     386             : 
     387           0 :     if ( !xNameContainer.is() )
     388           0 :         throw uno::RuntimeException();
     389             : 
     390           0 :     uno::Reference< io::XSeekable > xCachedSeek( xCachedVisualRepresentation, uno::UNO_QUERY_THROW );
     391           0 :     if ( xCachedSeek.is() )
     392           0 :         xCachedSeek->seek( 0 );
     393             : 
     394             :     uno::Reference < io::XStream > xTempFile(
     395             :             io::TempFile::create(comphelper::getComponentContext(m_xFactory)),
     396           0 :             uno::UNO_QUERY_THROW );
     397             : 
     398           0 :     uno::Reference< io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );
     399           0 :     uno::Reference< io::XOutputStream > xTempOutStream = xTempFile->getOutputStream();
     400           0 :     if ( xTempOutStream.is() )
     401             :     {
     402             :         // the OlePres stream must have additional header
     403             :         // TODO/LATER: might need to be extended in future ( actually makes sence only for SO7 format )
     404           0 :         uno::Reference< io::XInputStream > xInCacheStream = xCachedVisualRepresentation->getInputStream();
     405           0 :         if ( !xInCacheStream.is() )
     406           0 :             throw uno::RuntimeException();
     407             : 
     408             :         // write 0xFFFFFFFF at the beginning
     409           0 :         uno::Sequence< sal_Int8 > aData( 4 );
     410           0 :         *( (sal_uInt32*)aData.getArray() ) = 0xFFFFFFFF;
     411             : 
     412           0 :         xTempOutStream->writeBytes( aData );
     413             : 
     414             :         // write clipboard format
     415           0 :         uno::Sequence< sal_Int8 > aSigData( 2 );
     416           0 :         xInCacheStream->readBytes( aSigData, 2 );
     417           0 :         if ( aSigData.getLength() < 2 )
     418           0 :             throw io::IOException();
     419             : 
     420           0 :         if ( aSigData[0] == 'B' && aSigData[1] == 'M' )
     421             :         {
     422             :             // it's a bitmap
     423           0 :             aData[0] = 0x02; aData[1] = 0; aData[2] = 0; aData[3] = 0;
     424             :         }
     425             :         else
     426             :         {
     427             :             // treat it as a metafile
     428           0 :             aData[0] = 0x03; aData[1] = 0; aData[2] = 0; aData[3] = 0;
     429             :         }
     430           0 :         xTempOutStream->writeBytes( aData );
     431             : 
     432             :         // write job related information
     433           0 :         aData[0] = 0x04; aData[1] = 0; aData[2] = 0; aData[3] = 0;
     434           0 :         xTempOutStream->writeBytes( aData );
     435             : 
     436             :         // write aspect
     437           0 :         aData[0] = 0x01; aData[1] = 0; aData[2] = 0; aData[3] = 0;
     438           0 :         xTempOutStream->writeBytes( aData );
     439             : 
     440             :         // write l-index
     441           0 :         *( (sal_uInt32*)aData.getArray() ) = 0xFFFFFFFF;
     442           0 :         xTempOutStream->writeBytes( aData );
     443             : 
     444             :         // write adv. flags
     445           0 :         aData[0] = 0x02; aData[1] = 0; aData[2] = 0; aData[3] = 0;
     446           0 :         xTempOutStream->writeBytes( aData );
     447             : 
     448             :         // write compression
     449           0 :         *( (sal_uInt32*)aData.getArray() ) = 0x0;
     450           0 :         xTempOutStream->writeBytes( aData );
     451             : 
     452             :         // get the size
     453           0 :         awt::Size aSize = getVisualAreaSize( embed::Aspects::MSOLE_CONTENT );
     454           0 :         sal_Int32 nIndex = 0;
     455             : 
     456             :         // write width
     457           0 :         for ( nIndex = 0; nIndex < 4; nIndex++ )
     458             :         {
     459           0 :             aData[nIndex] = (sal_Int8)( aSize.Width % 0x100 );
     460           0 :             aSize.Width /= 0x100;
     461             :         }
     462           0 :         xTempOutStream->writeBytes( aData );
     463             : 
     464             :         // write height
     465           0 :         for ( nIndex = 0; nIndex < 4; nIndex++ )
     466             :         {
     467           0 :             aData[nIndex] = (sal_Int8)( aSize.Height % 0x100 );
     468           0 :             aSize.Height /= 0x100;
     469             :         }
     470           0 :         xTempOutStream->writeBytes( aData );
     471             : 
     472             :         // write garbage, it will be overwritten by the size
     473           0 :         xTempOutStream->writeBytes( aData );
     474             : 
     475             :         // write first bytes that was used to detect the type
     476           0 :         xTempOutStream->writeBytes( aSigData );
     477             : 
     478             :         // write the rest of the stream
     479           0 :         ::comphelper::OStorageHelper::CopyInputToOutput( xInCacheStream, xTempOutStream );
     480             : 
     481             :         // write the size of the stream
     482           0 :         sal_Int64 nLength = xTempSeek->getLength() - 40;
     483           0 :         if ( nLength < 0 || nLength >= 0xFFFFFFFF )
     484             :         {
     485             :             SAL_WARN( "embeddedobj.ole", "Length is not acceptable!" );
     486           0 :             return;
     487             :         }
     488           0 :         for ( sal_Int32 nInd = 0; nInd < 4; nInd++ )
     489             :         {
     490           0 :             aData[nInd] = (sal_Int8)( ( (sal_uInt64) nLength ) % 0x100 );
     491           0 :             nLength /= 0x100;
     492             :         }
     493           0 :         xTempSeek->seek( 36 );
     494           0 :         xTempOutStream->writeBytes( aData );
     495             : 
     496           0 :         xTempOutStream->flush();
     497             : 
     498           0 :         xTempSeek->seek( 0 );
     499           0 :         if ( xCachedSeek.is() )
     500           0 :             xCachedSeek->seek( 0 );
     501             :     }
     502             :     else
     503           0 :         throw io::IOException(); // TODO:
     504             : 
     505             :     // insert the result file as replacement image
     506           0 :     OUString aCacheName = "\002OlePres000";
     507           0 :     if ( xNameContainer->hasByName( aCacheName ) )
     508           0 :         xNameContainer->replaceByName( aCacheName, uno::makeAny( xTempFile ) );
     509             :     else
     510           0 :         xNameContainer->insertByName( aCacheName, uno::makeAny( xTempFile ) );
     511             : 
     512           0 :     uno::Reference< embed::XTransactedObject > xTransacted( xNameContainer, uno::UNO_QUERY );
     513           0 :     if ( !xTransacted.is() )
     514           0 :         throw uno::RuntimeException();
     515             : 
     516           0 :     xTransacted->commit();
     517             : }
     518             : 
     519             : 
     520           0 : void OleEmbeddedObject::RemoveVisualCache_Impl( const uno::Reference< io::XStream >& xTargetStream )
     521             :         throw ( uno::Exception )
     522             : {
     523             :     OSL_ENSURE( xTargetStream.is(), "Invalid argumant!\n" );
     524           0 :     if ( !xTargetStream.is() )
     525           0 :         throw uno::RuntimeException();
     526             : 
     527           0 :     uno::Sequence< uno::Any > aArgs( 2 );
     528           0 :     aArgs[0] <<= xTargetStream;
     529           0 :     aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
     530             :     uno::Reference< container::XNameContainer > xNameContainer(
     531           0 :             m_xFactory->createInstanceWithArguments(
     532             :                     OUString( "com.sun.star.embed.OLESimpleStorage" ),
     533           0 :                     aArgs ),
     534           0 :             uno::UNO_QUERY );
     535             : 
     536           0 :     if ( !xNameContainer.is() )
     537           0 :         throw uno::RuntimeException();
     538             : 
     539           0 :     for ( sal_uInt8 nInd = 0; nInd < 10; nInd++ )
     540             :     {
     541           0 :         OUString aStreamName =  "\002OlePres00" + OUString::number( nInd );
     542           0 :         if ( xNameContainer->hasByName( aStreamName ) )
     543           0 :             xNameContainer->removeByName( aStreamName );
     544           0 :     }
     545             : 
     546           0 :     uno::Reference< embed::XTransactedObject > xTransacted( xNameContainer, uno::UNO_QUERY );
     547           0 :     if ( !xTransacted.is() )
     548           0 :         throw uno::RuntimeException();
     549             : 
     550           0 :     xTransacted->commit();
     551           0 : }
     552             : 
     553             : 
     554           0 : void OleEmbeddedObject::SetVisReplInStream( sal_Bool bExists )
     555             : {
     556           0 :     m_bVisReplInitialized = sal_True;
     557           0 :     m_bVisReplInStream = bExists;
     558           0 : }
     559             : 
     560             : 
     561           0 : sal_Bool OleEmbeddedObject::HasVisReplInStream()
     562             : {
     563           0 :     if ( !m_bVisReplInitialized )
     564             :     {
     565           0 :         if ( m_xCachedVisualRepresentation.is() )
     566           0 :             SetVisReplInStream( sal_True );
     567             :         else
     568             :         {
     569             :             SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::HasVisualReplInStream, analizing" );
     570             : 
     571           0 :             uno::Reference< io::XInputStream > xStream;
     572             : 
     573             :             OSL_ENSURE( !m_pOleComponent || !m_aTempURL.isEmpty(), "The temporary file must exist if there is a component!\n" );
     574           0 :             if ( !m_aTempURL.isEmpty() )
     575             :             {
     576             :                 try
     577             :                 {
     578             :                     // open temporary file for reading
     579             :                     uno::Reference < ucb::XSimpleFileAccess3 > xTempAccess(
     580           0 :                             ucb::SimpleFileAccess::create( comphelper::getComponentContext(m_xFactory) ) );
     581             : 
     582           0 :                     xStream = xTempAccess->openFileRead( m_aTempURL );
     583             :                 }
     584           0 :                 catch( const uno::Exception& )
     585             :                 {}
     586             :             }
     587             : 
     588           0 :             if ( !xStream.is() )
     589           0 :                 xStream = m_xObjectStream->getInputStream();
     590             : 
     591           0 :             if ( xStream.is() )
     592             :             {
     593           0 :                 sal_Bool bExists = sal_False;
     594             : 
     595           0 :                 uno::Sequence< uno::Any > aArgs( 2 );
     596           0 :                 aArgs[0] <<= xStream;
     597           0 :                 aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
     598             :                 uno::Reference< container::XNameContainer > xNameContainer(
     599           0 :                         m_xFactory->createInstanceWithArguments(
     600             :                                 OUString( "com.sun.star.embed.OLESimpleStorage" ),
     601           0 :                                 aArgs ),
     602           0 :                         uno::UNO_QUERY );
     603             : 
     604           0 :                 if ( xNameContainer.is() )
     605             :                 {
     606           0 :                     for ( sal_uInt8 nInd = 0; nInd < 10 && !bExists; nInd++ )
     607             :                     {
     608           0 :                         OUString aStreamName = "\002OlePres00" + OUString::number( nInd );
     609             :                         try
     610             :                         {
     611           0 :                             bExists = xNameContainer->hasByName( aStreamName );
     612             :                         }
     613           0 :                         catch( const uno::Exception& )
     614             :                         {}
     615           0 :                     }
     616             :                 }
     617             : 
     618           0 :                 SetVisReplInStream( bExists );
     619           0 :             }
     620             :         }
     621             :     }
     622             : 
     623           0 :     return m_bVisReplInStream;
     624             : }
     625             : 
     626             : 
     627           0 : uno::Reference< io::XStream > OleEmbeddedObject::TryToRetrieveCachedVisualRepresentation_Impl(
     628             :         const uno::Reference< io::XStream >& xStream,
     629             :         sal_Bool bAllowToRepair50 )
     630             :     throw ()
     631             : {
     632           0 :     uno::Reference< io::XStream > xResult;
     633             : 
     634           0 :     if ( xStream.is() )
     635             :     {
     636             :         SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::TryToRetrieveCachedVisualRepresentation, retrieving" );
     637             : 
     638           0 :         uno::Reference< container::XNameContainer > xNameContainer;
     639           0 :         uno::Sequence< uno::Any > aArgs( 2 );
     640           0 :         aArgs[0] <<= xStream;
     641           0 :         aArgs[1] <<= (sal_Bool)sal_True; // do not create copy
     642             :         try
     643             :         {
     644           0 :             xNameContainer = uno::Reference< container::XNameContainer >(
     645           0 :                 m_xFactory->createInstanceWithArguments(
     646             :                         OUString( "com.sun.star.embed.OLESimpleStorage" ),
     647           0 :                         aArgs ),
     648           0 :                 uno::UNO_QUERY );
     649             :         }
     650           0 :         catch( const uno::Exception& )
     651             :         {}
     652             : 
     653           0 :         if ( xNameContainer.is() )
     654             :         {
     655           0 :             for ( sal_uInt8 nInd = 0; nInd < 10; nInd++ )
     656             :             {
     657           0 :                 OUString aStreamName =  "\002OlePres00" + OUString::number( nInd );
     658           0 :                 uno::Reference< io::XStream > xCachedCopyStream;
     659             :                 try
     660             :                 {
     661           0 :                     if ( ( xNameContainer->getByName( aStreamName ) >>= xCachedCopyStream ) && xCachedCopyStream.is() )
     662             :                     {
     663           0 :                         xResult = TryToGetAcceptableFormat_Impl( xCachedCopyStream );
     664           0 :                         if ( xResult.is() )
     665           0 :                             break;
     666             :                     }
     667             :                 }
     668           0 :                 catch( const uno::Exception& )
     669             :                 {}
     670             : 
     671           0 :                 if ( nInd == 0 )
     672             :                 {
     673             :                     // to be compatible with the old versions Ole10Native is checked after OlePress000
     674           0 :                     aStreamName = "\001Ole10Native";
     675             :                     try
     676             :                     {
     677           0 :                         if ( ( xNameContainer->getByName( aStreamName ) >>= xCachedCopyStream ) && xCachedCopyStream.is() )
     678             :                         {
     679           0 :                             xResult = TryToGetAcceptableFormat_Impl( xCachedCopyStream );
     680           0 :                             if ( xResult.is() )
     681           0 :                                 break;
     682             :                         }
     683             :                     }
     684           0 :                     catch( const uno::Exception& )
     685             :                     {}
     686             :                 }
     687           0 :             }
     688             : 
     689             :             try
     690             :             {
     691           0 :                 if ( bAllowToRepair50 && !xResult.is() )
     692             :                 {
     693           0 :                     OUString aOrigContName( "Ole-Object" );
     694           0 :                     if ( xNameContainer->hasByName( aOrigContName ) )
     695             :                     {
     696           0 :                         uno::Reference< embed::XClassifiedObject > xClassified( xNameContainer, uno::UNO_QUERY_THROW );
     697           0 :                         if ( MimeConfigurationHelper::ClassIDsEqual( xClassified->getClassID(), MimeConfigurationHelper::GetSequenceClassID( SO3_OUT_CLASSID ) ) )
     698             :                         {
     699             :                             // this is an OLE object wrongly stored in 5.0 format
     700             :                             // this object must be repaired since SO7 has done it
     701             : 
     702           0 :                             uno::Reference< io::XOutputStream > xOutputStream = xStream->getOutputStream();
     703           0 :                             uno::Reference< io::XTruncate > xTruncate( xOutputStream, uno::UNO_QUERY_THROW );
     704             : 
     705           0 :                             uno::Reference< io::XInputStream > xOrigInputStream;
     706           0 :                             if ( ( xNameContainer->getByName( aOrigContName ) >>= xOrigInputStream )
     707           0 :                               && xOrigInputStream.is() )
     708             :                             {
     709             :                                 // the provided input stream must be based on temporary medium and must be independent
     710             :                                 // from the stream the storage is based on
     711           0 :                                 uno::Reference< io::XSeekable > xOrigSeekable( xOrigInputStream, uno::UNO_QUERY );
     712           0 :                                 if ( xOrigSeekable.is() )
     713           0 :                                     xOrigSeekable->seek( 0 );
     714             : 
     715           0 :                                 uno::Reference< lang::XComponent > xNameContDisp( xNameContainer, uno::UNO_QUERY_THROW );
     716           0 :                                 xNameContDisp->dispose(); // free the original stream
     717             : 
     718           0 :                                 xTruncate->truncate();
     719           0 :                                 ::comphelper::OStorageHelper::CopyInputToOutput( xOrigInputStream, xOutputStream );
     720           0 :                                 xOutputStream->flush();
     721             : 
     722           0 :                                 if ( xStream == m_xObjectStream )
     723             :                                 {
     724           0 :                                     if ( !m_aTempURL.isEmpty() )
     725             :                                     {
     726             :                                         // this is the own stream, so the temporary URL must be cleaned if it exists
     727           0 :                                         KillFile_Impl( m_aTempURL, m_xFactory );
     728           0 :                                         m_aTempURL = OUString();
     729             :                                     }
     730             : 
     731             : #ifdef WNT
     732             :                                     // retry to create the component after recovering
     733             :                                     GetRidOfComponent();
     734             : 
     735             :                                     try
     736             :                                     {
     737             :                                         CreateOleComponentAndLoad_Impl( NULL );
     738             :                                         m_aClassID = m_pOleComponent->GetCLSID(); // was not set during consruction
     739             :                                     }
     740             :                                     catch( const uno::Exception& )
     741             :                                     {
     742             :                                         GetRidOfComponent();
     743             :                                     }
     744             : #endif
     745             :                                 }
     746             : 
     747           0 :                                 xResult = TryToRetrieveCachedVisualRepresentation_Impl( xStream, sal_False );
     748           0 :                             }
     749           0 :                         }
     750           0 :                     }
     751             :                 }
     752             :             }
     753           0 :             catch( const uno::Exception& )
     754             :             {}
     755           0 :         }
     756             :     }
     757             : 
     758           0 :     return xResult;
     759             : }
     760             : 
     761             : 
     762           0 : void OleEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,
     763             :                                               const uno::Reference< io::XStream >& xNewObjectStream,
     764             :                                               const OUString& aNewName )
     765             : {
     766           0 :     if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) )
     767             :     {
     768             :         SAL_WARN_IF( xNewObjectStream != m_xObjectStream, "embeddedobj.ole", "The streams must be the same!" );
     769           0 :         return;
     770             :     }
     771             : 
     772             :     try {
     773           0 :         uno::Reference< lang::XComponent > xComponent( m_xObjectStream, uno::UNO_QUERY );
     774             :         OSL_ENSURE( !m_xObjectStream.is() || xComponent.is(), "Wrong stream implementation!" );
     775           0 :         if ( xComponent.is() )
     776           0 :             xComponent->dispose();
     777             :     }
     778           0 :     catch ( const uno::Exception& )
     779             :     {
     780             :     }
     781             : 
     782           0 :     m_xObjectStream = xNewObjectStream;
     783           0 :     m_xParentStorage = xNewParentStorage;
     784           0 :     m_aEntryName = aNewName;
     785             : }
     786             : 
     787             : 
     788           0 : void OleEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,
     789             :                                               const OUString& aNewName )
     790             : {
     791           0 :     if ( xNewParentStorage == m_xParentStorage && aNewName.equals( m_aEntryName ) )
     792           0 :         return;
     793             : 
     794           0 :     sal_Int32 nStreamMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;
     795             : 
     796           0 :     uno::Reference< io::XStream > xNewOwnStream = xNewParentStorage->openStreamElement( aNewName, nStreamMode );
     797             :     SAL_WARN_IF( !xNewOwnStream.is(), "embeddedobj.ole", "The method can not return empty reference!" );
     798             : 
     799           0 :     SwitchOwnPersistence( xNewParentStorage, xNewOwnStream, aNewName );
     800             : }
     801             : 
     802             : #ifdef WNT
     803             : 
     804             : sal_Bool OleEmbeddedObject::SaveObject_Impl()
     805             : {
     806             :     sal_Bool bResult = sal_False;
     807             : 
     808             :     if ( m_xClientSite.is() )
     809             :     {
     810             :         try
     811             :         {
     812             :             m_xClientSite->saveObject();
     813             :             bResult = sal_True;
     814             :         }
     815             :         catch( const uno::Exception& )
     816             :         {
     817             :         }
     818             :     }
     819             : 
     820             :     return bResult;
     821             : }
     822             : 
     823             : 
     824             : sal_Bool OleEmbeddedObject::OnShowWindow_Impl( sal_Bool bShow )
     825             : {
     826             :     ::osl::ResettableMutexGuard aGuard( m_aMutex );
     827             : 
     828             :     sal_Bool bResult = sal_False;
     829             : 
     830             :     SAL_WARN_IF( m_nObjectState == -1, "embeddedobj.ole", "The object has no persistence!" );
     831             :     SAL_WARN_IF( m_nObjectState == embed::EmbedStates::LOADED, "embeddedobj.ole", "The object get OnShowWindow in loaded state!" );
     832             :     if ( m_nObjectState == -1 || m_nObjectState == embed::EmbedStates::LOADED )
     833             :         return sal_False;
     834             : 
     835             :     // the object is either activated or deactivated
     836             :     sal_Int32 nOldState = m_nObjectState;
     837             :     if ( bShow && m_nObjectState == embed::EmbedStates::RUNNING )
     838             :     {
     839             :         m_nObjectState = embed::EmbedStates::ACTIVE;
     840             :         m_aVerbExecutionController.ObjectIsActive();
     841             : 
     842             :         aGuard.clear();
     843             :         StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
     844             :     }
     845             :     else if ( !bShow && m_nObjectState == embed::EmbedStates::ACTIVE )
     846             :     {
     847             :         m_nObjectState = embed::EmbedStates::RUNNING;
     848             :         aGuard.clear();
     849             :         StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
     850             :     }
     851             : 
     852             :     if ( m_xClientSite.is() )
     853             :     {
     854             :         try
     855             :         {
     856             :             m_xClientSite->visibilityChanged( bShow );
     857             :             bResult = sal_True;
     858             :         }
     859             :         catch( const uno::Exception& )
     860             :         {
     861             :         }
     862             :     }
     863             : 
     864             :     return bResult;
     865             : }
     866             : 
     867             : 
     868             : void OleEmbeddedObject::OnIconChanged_Impl()
     869             : {
     870             :     // TODO/LATER: currently this notification seems to be impossible
     871             :     // MakeEventListenerNotification_Impl( OUString( "OnIconChanged" ) );
     872             : }
     873             : 
     874             : 
     875             : void OleEmbeddedObject::OnViewChanged_Impl()
     876             : {
     877             :     if ( m_bDisposed )
     878             :         throw lang::DisposedException();
     879             : 
     880             :     // For performance reasons the notification currently is ignored, STAMPIT object is the exception,
     881             :     // it can never be active and never call SaveObject, so it is the only way to detect that it is changed
     882             : 
     883             :     // ==== the STAMPIT related solution =============================
     884             :     // the following variable is used to detect whether the object was modified during verb execution
     885             :     m_aVerbExecutionController.ModificationNotificationIsDone();
     886             : 
     887             :     // The following things are controlled by VerbExecutionController:
     888             :     // - if the verb execution is in progress and the view is changed the object will be stored
     889             :     // after the execution, so there is no need to send the notification.
     890             :     // - the STAMPIT object can never be active.
     891             :     if (m_aVerbExecutionController.CanDoNotification() &&
     892             :             m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE &&
     893             :             (MimeConfigurationHelper::ClassIDsEqual(m_aClassID, MimeConfigurationHelper::GetSequenceClassID(0x852ee1c9, 0x9058, 0x44ba, 0x8c, 0x6c, 0x0c, 0x5f, 0xc6, 0x6b, 0xdb, 0x8d)) ||
     894             :              MimeConfigurationHelper::ClassIDsEqual(m_aClassID, MimeConfigurationHelper::GetSequenceClassID(0xcf1b4491, 0xbea3, 0x4c9f, 0xa7, 0x0f, 0x22, 0x1b, 0x1e, 0xca, 0xef, 0x3e)))
     895             :        )
     896             :     {
     897             :         // The view is changed while the object is in running state, save the new object
     898             :         m_xCachedVisualRepresentation = uno::Reference< io::XStream >();
     899             :         SaveObject_Impl();
     900             :         MakeEventListenerNotification_Impl( OUString( "OnVisAreaChanged" ) );
     901             :     }
     902             : 
     903             : }
     904             : 
     905             : 
     906             : void OleEmbeddedObject::OnClosed_Impl()
     907             : {
     908             :     if ( m_bDisposed )
     909             :         throw lang::DisposedException();
     910             : 
     911             :     if ( m_nObjectState != embed::EmbedStates::LOADED )
     912             :     {
     913             :         sal_Int32 nOldState = m_nObjectState;
     914             :         m_nObjectState = embed::EmbedStates::LOADED;
     915             :         StateChangeNotification_Impl( sal_False, nOldState, m_nObjectState );
     916             :     }
     917             : }
     918             : 
     919             : 
     920             : OUString OleEmbeddedObject::CreateTempURLEmpty_Impl()
     921             : {
     922             :     SAL_WARN_IF( !m_aTempURL.isEmpty(), "embeddedobj.ole", "The object has already the temporary file!" );
     923             :     m_aTempURL = GetNewTempFileURL_Impl( m_xFactory );
     924             : 
     925             :     return m_aTempURL;
     926             : }
     927             : 
     928             : 
     929             : OUString OleEmbeddedObject::GetTempURL_Impl()
     930             : {
     931             :     if ( m_aTempURL.isEmpty() )
     932             :     {
     933             :         SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::GetTempURL_Impl, tempfile creation" );
     934             : 
     935             :         // if there is no temporary file, it will be created from the own entry
     936             :         uno::Reference< embed::XOptimizedStorage > xOptParStorage( m_xParentStorage, uno::UNO_QUERY );
     937             :         if ( xOptParStorage.is() )
     938             :         {
     939             :             m_aTempURL = GetNewFilledTempFile_Impl( xOptParStorage, m_aEntryName, m_xFactory );
     940             :         }
     941             :         else if ( m_xObjectStream.is() )
     942             :         {
     943             :             // load object from the stream
     944             :             uno::Reference< io::XInputStream > xInStream = m_xObjectStream->getInputStream();
     945             :             if ( !xInStream.is() )
     946             :                 throw io::IOException(); // TODO: access denied
     947             : 
     948             :             m_aTempURL = GetNewFilledTempFile_Impl( xInStream, m_xFactory );
     949             :         }
     950             :     }
     951             : 
     952             :     return m_aTempURL;
     953             : }
     954             : 
     955             : 
     956             : void OleEmbeddedObject::CreateOleComponent_Impl( OleComponent* pOleComponent )
     957             : {
     958             :     if ( !m_pOleComponent )
     959             :     {
     960             :         m_pOleComponent = pOleComponent ? pOleComponent : new OleComponent( m_xFactory, this );
     961             :         m_pOleComponent->acquire(); // TODO: needs holder?
     962             : 
     963             :         if ( !m_xClosePreventer.is() )
     964             :             m_xClosePreventer = uno::Reference< util::XCloseListener >(
     965             :                                     static_cast< ::cppu::OWeakObject* >( new OClosePreventer ),
     966             :                                     uno::UNO_QUERY );
     967             : 
     968             :         m_pOleComponent->addCloseListener( m_xClosePreventer );
     969             :     }
     970             : }
     971             : 
     972             : 
     973             : void OleEmbeddedObject::CreateOleComponentAndLoad_Impl( OleComponent* pOleComponent )
     974             : {
     975             :     if ( !m_pOleComponent )
     976             :     {
     977             :         if ( !m_xObjectStream.is() )
     978             :             throw uno::RuntimeException();
     979             : 
     980             :         CreateOleComponent_Impl( pOleComponent );
     981             : 
     982             :         // after the loading the object can appear as a link
     983             :         // will be detected later by olecomponent
     984             : 
     985             :         GetTempURL_Impl();
     986             :         if ( m_aTempURL.isEmpty() )
     987             :             throw uno::RuntimeException(); // TODO
     988             : 
     989             :         m_pOleComponent->LoadEmbeddedObject( m_aTempURL );
     990             :     }
     991             : }
     992             : 
     993             : 
     994             : void OleEmbeddedObject::CreateOleComponentFromClipboard_Impl( OleComponent* pOleComponent )
     995             : {
     996             :     if ( !m_pOleComponent )
     997             :     {
     998             :         if ( !m_xObjectStream.is() )
     999             :             throw uno::RuntimeException();
    1000             : 
    1001             :         CreateOleComponent_Impl( pOleComponent );
    1002             : 
    1003             :         // after the loading the object can appear as a link
    1004             :         // will be detected later by olecomponent
    1005             :         m_pOleComponent->CreateObjectFromClipboard();
    1006             :     }
    1007             : }
    1008             : 
    1009             : 
    1010             : uno::Reference< io::XOutputStream > OleEmbeddedObject::GetStreamForSaving()
    1011             : {
    1012             :     if ( !m_xObjectStream.is() )
    1013             :         throw uno::RuntimeException(); //TODO:
    1014             : 
    1015             :     uno::Reference< io::XOutputStream > xOutStream = m_xObjectStream->getOutputStream();
    1016             :     if ( !xOutStream.is() )
    1017             :         throw io::IOException(); //TODO: access denied
    1018             : 
    1019             :     uno::Reference< io::XTruncate > xTruncate( xOutStream, uno::UNO_QUERY );
    1020             :     if ( !xTruncate.is() )
    1021             :         throw uno::RuntimeException(); //TODO:
    1022             : 
    1023             :     xTruncate->truncate();
    1024             : 
    1025             :     return xOutStream;
    1026             : }
    1027             : 
    1028             : 
    1029             : void OleEmbeddedObject::StoreObjectToStream( uno::Reference< io::XOutputStream > xOutStream )
    1030             :     throw ( uno::Exception )
    1031             : {
    1032             :     // this method should be used only on windows
    1033             :     if ( m_pOleComponent )
    1034             :         m_pOleComponent->StoreOwnTmpIfNecessary();
    1035             : 
    1036             :     // now all the changes should be in temporary location
    1037             :     if ( m_aTempURL.isEmpty() )
    1038             :         throw uno::RuntimeException();
    1039             : 
    1040             :     // open temporary file for reading
    1041             :     uno::Reference < ucb::XSimpleFileAccess3 > xTempAccess(
    1042             :             ucb::SimpleFileAccess::create( comphelper::getComponentContext(m_xFactory) ) );
    1043             : 
    1044             :     uno::Reference< io::XInputStream > xTempInStream = xTempAccess->openFileRead( m_aTempURL );
    1045             :     SAL_WARN_IF( !xTempInStream.is(), "embeddedobj.ole", "The object's temporary file can not be reopened for reading!" );
    1046             : 
    1047             :     // TODO: use bStoreVisReplace
    1048             : 
    1049             :     if ( xTempInStream.is() )
    1050             :     {
    1051             :         // write all the contents to XOutStream
    1052             :         uno::Reference< io::XTruncate > xTrunc( xOutStream, uno::UNO_QUERY );
    1053             :         if ( !xTrunc.is() )
    1054             :             throw uno::RuntimeException(); //TODO:
    1055             : 
    1056             :         xTrunc->truncate();
    1057             : 
    1058             :         ::comphelper::OStorageHelper::CopyInputToOutput( xTempInStream, xOutStream );
    1059             :     }
    1060             :     else
    1061             :         throw io::IOException(); // TODO:
    1062             : 
    1063             :     // TODO: should the view replacement be in the stream ???
    1064             :     //       probably it must be specified on storing
    1065             : }
    1066             : #endif
    1067             : 
    1068           0 : void OleEmbeddedObject::StoreToLocation_Impl(
    1069             :                             const uno::Reference< embed::XStorage >& xStorage,
    1070             :                             const OUString& sEntName,
    1071             :                             const uno::Sequence< beans::PropertyValue >& lObjArgs,
    1072             :                             sal_Bool bSaveAs )
    1073             :         throw ( uno::Exception )
    1074             : {
    1075             :     // TODO: use lObjArgs
    1076             :     // TODO: exchange StoreVisualReplacement by SO file format version?
    1077             : 
    1078           0 :     if ( m_nObjectState == -1 )
    1079             :     {
    1080             :         // the object is still not loaded
    1081             :         throw embed::WrongStateException( OUString( "Can't store object without persistence!\n" ),
    1082           0 :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1083             :     }
    1084             : 
    1085           0 :     if ( m_bWaitSaveCompleted )
    1086             :         throw embed::WrongStateException(
    1087             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1088           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1089             : 
    1090             :     OSL_ENSURE( m_xParentStorage.is() && m_xObjectStream.is(), "The object has no valid persistence!\n" );
    1091             : 
    1092           0 :     sal_Bool bVisReplIsStored = sal_False;
    1093             : 
    1094           0 :     sal_Bool bTryOptimization = sal_False;
    1095           0 :     sal_Bool bStoreVis = m_bStoreVisRepl;
    1096           0 :     uno::Reference< io::XStream > xCachedVisualRepresentation;
    1097           0 :     for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ )
    1098             :     {
    1099           0 :         if ( lObjArgs[nInd].Name == "StoreVisualReplacement" )
    1100           0 :             lObjArgs[nInd].Value >>= bStoreVis;
    1101           0 :         else if ( lObjArgs[nInd].Name == "VisualReplacement" )
    1102           0 :             lObjArgs[nInd].Value >>= xCachedVisualRepresentation;
    1103           0 :         else if ( lObjArgs[nInd].Name == "CanTryOptimization" )
    1104           0 :             lObjArgs[nInd].Value >>= bTryOptimization;
    1105             :     }
    1106             : 
    1107             :     // ignore visual representation provided from outside if it should not be stored
    1108           0 :     if ( !bStoreVis )
    1109           0 :         xCachedVisualRepresentation = uno::Reference< io::XStream >();
    1110             : 
    1111           0 :     if ( bStoreVis && !HasVisReplInStream() && !xCachedVisualRepresentation.is() )
    1112           0 :         throw io::IOException(); // TODO: there is no cached visual representation and nothing is provided from outside
    1113             : 
    1114             :     // if the representation is provided from outside it should be copied to a local stream
    1115           0 :     sal_Bool bNeedLocalCache = xCachedVisualRepresentation.is();
    1116             : 
    1117           0 :     uno::Reference< io::XStream > xTargetStream;
    1118             : 
    1119           0 :     sal_Bool bStoreLoaded = sal_False;
    1120           0 :     if ( m_nObjectState == embed::EmbedStates::LOADED
    1121             : #ifdef WNT
    1122             :         // if the object was NOT modified after storing it can be just copied
    1123             :         // as if it was in loaded state
    1124             :       || ( m_pOleComponent && !m_pOleComponent->IsDirty() )
    1125             : #endif
    1126             :     )
    1127             :     {
    1128           0 :         sal_Bool bOptimizedCopyingDone = sal_False;
    1129             : 
    1130           0 :         if ( bTryOptimization && bStoreVis == HasVisReplInStream() )
    1131             :         {
    1132             :             try
    1133             :             {
    1134           0 :                 uno::Reference< embed::XOptimizedStorage > xSourceOptStor( m_xParentStorage, uno::UNO_QUERY_THROW );
    1135           0 :                 uno::Reference< embed::XOptimizedStorage > xTargetOptStor( xStorage, uno::UNO_QUERY_THROW );
    1136           0 :                 xSourceOptStor->copyElementDirectlyTo( m_aEntryName, xTargetOptStor, sEntName );
    1137           0 :                 bOptimizedCopyingDone = sal_True;
    1138             :             }
    1139           0 :             catch( const uno::Exception& )
    1140             :             {
    1141             :             }
    1142             :         }
    1143             : 
    1144           0 :         if ( !bOptimizedCopyingDone )
    1145             :         {
    1146             :             // if optimized copying fails a normal one should be tried
    1147           0 :             m_xParentStorage->copyElementTo( m_aEntryName, xStorage, sEntName );
    1148             :         }
    1149             : 
    1150             :         // the locally retrieved representation is always preferable
    1151             :         // since the object is in loaded state the representation is unchanged
    1152           0 :         if ( m_xCachedVisualRepresentation.is() )
    1153             :         {
    1154           0 :             xCachedVisualRepresentation = m_xCachedVisualRepresentation;
    1155           0 :             bNeedLocalCache = sal_False;
    1156             :         }
    1157             : 
    1158           0 :         bVisReplIsStored = HasVisReplInStream();
    1159           0 :         bStoreLoaded = sal_True;
    1160             :     }
    1161             : #ifdef WNT
    1162             :     else if ( m_pOleComponent )
    1163             :     {
    1164             :         xTargetStream =
    1165             :                 xStorage->openStreamElement( sEntName, embed::ElementModes::READWRITE );
    1166             :         if ( !xTargetStream.is() )
    1167             :             throw io::IOException(); //TODO: access denied
    1168             : 
    1169             :         SetStreamMediaType_Impl( xTargetStream, OUString( "application/vnd.sun.star.oleobject" ));
    1170             :         uno::Reference< io::XOutputStream > xOutStream = xTargetStream->getOutputStream();
    1171             :         if ( !xOutStream.is() )
    1172             :             throw io::IOException(); //TODO: access denied
    1173             : 
    1174             :         StoreObjectToStream( xOutStream );
    1175             :         bVisReplIsStored = sal_True;
    1176             : 
    1177             :         if ( bSaveAs )
    1178             :         {
    1179             :             // no need to do it on StoreTo since in this case the replacement is in the stream
    1180             :             // and there is no need to cache it even if it is thrown away because the object
    1181             :             // is not changed by StoreTo action
    1182             : 
    1183             :             uno::Reference< io::XStream > xTmpCVRepresentation =
    1184             :                         TryToRetrieveCachedVisualRepresentation_Impl( xTargetStream );
    1185             : 
    1186             :             // the locally retrieved representation is always preferable
    1187             :             if ( xTmpCVRepresentation.is() )
    1188             :             {
    1189             :                 xCachedVisualRepresentation = xTmpCVRepresentation;
    1190             :                 bNeedLocalCache = sal_False;
    1191             :             }
    1192             :         }
    1193             :     }
    1194             : #endif
    1195             :     else
    1196             :     {
    1197           0 :         throw io::IOException(); // TODO
    1198             :     }
    1199             : 
    1200           0 :     if ( !xTargetStream.is() )
    1201             :     {
    1202           0 :         xTargetStream =
    1203           0 :             xStorage->openStreamElement( sEntName, embed::ElementModes::READWRITE );
    1204           0 :         if ( !xTargetStream.is() )
    1205           0 :             throw io::IOException(); //TODO: access denied
    1206             :     }
    1207             : 
    1208           0 :     LetCommonStoragePassBeUsed_Impl( xTargetStream );
    1209             : 
    1210           0 :     if ( bStoreVis != bVisReplIsStored )
    1211             :     {
    1212           0 :         if ( bStoreVis )
    1213             :         {
    1214           0 :             if ( !xCachedVisualRepresentation.is() )
    1215           0 :                 xCachedVisualRepresentation = TryToRetrieveCachedVisualRepresentation_Impl( xTargetStream );
    1216             : 
    1217             :             SAL_WARN_IF( !xCachedVisualRepresentation.is(), "embeddedobj.ole", "No representation is available!" );
    1218             : 
    1219             :             // the following copying will be done in case it is SaveAs anyway
    1220             :             // if it is not SaveAs the seekable access is not required currently
    1221             :             // TODO/LATER: may be required in future
    1222           0 :             if ( bSaveAs )
    1223             :             {
    1224           0 :                 uno::Reference< io::XSeekable > xCachedSeek( xCachedVisualRepresentation, uno::UNO_QUERY );
    1225           0 :                 if ( !xCachedSeek.is() )
    1226             :                 {
    1227             :                     xCachedVisualRepresentation
    1228           0 :                         = GetNewFilledTempStream_Impl( xCachedVisualRepresentation->getInputStream() );
    1229           0 :                     bNeedLocalCache = sal_False;
    1230           0 :                 }
    1231             :             }
    1232             : 
    1233           0 :             InsertVisualCache_Impl( xTargetStream, xCachedVisualRepresentation );
    1234             :         }
    1235             :         else
    1236             :         {
    1237             :             // the removed representation could be cached by this method
    1238           0 :             if ( !xCachedVisualRepresentation.is() )
    1239           0 :                 xCachedVisualRepresentation = TryToRetrieveCachedVisualRepresentation_Impl( xTargetStream );
    1240             : 
    1241           0 :             RemoveVisualCache_Impl( xTargetStream );
    1242             :         }
    1243             :     }
    1244             : 
    1245           0 :     if ( bSaveAs )
    1246             :     {
    1247           0 :         m_bWaitSaveCompleted = sal_True;
    1248           0 :         m_xNewObjectStream = xTargetStream;
    1249           0 :         m_xNewParentStorage = xStorage;
    1250           0 :         m_aNewEntryName = sEntName;
    1251           0 :         m_bNewVisReplInStream = bStoreVis;
    1252           0 :         m_bStoreLoaded = bStoreLoaded;
    1253             : 
    1254           0 :         if ( xCachedVisualRepresentation.is() )
    1255             :         {
    1256           0 :             if ( bNeedLocalCache )
    1257           0 :                 m_xNewCachedVisRepl = GetNewFilledTempStream_Impl( xCachedVisualRepresentation->getInputStream() );
    1258             :             else
    1259           0 :                 m_xNewCachedVisRepl = xCachedVisualRepresentation;
    1260             :         }
    1261             : 
    1262             :         // TODO: register listeners for storages above, in case they are disposed
    1263             :         //       an exception will be thrown on saveCompleted( true )
    1264             :     }
    1265             :     else
    1266             :     {
    1267           0 :         uno::Reference< lang::XComponent > xComp( xTargetStream, uno::UNO_QUERY );
    1268           0 :         if ( xComp.is() )
    1269             :         {
    1270             :             try {
    1271           0 :                 xComp->dispose();
    1272           0 :             } catch( const uno::Exception& )
    1273             :             {
    1274             :             }
    1275           0 :         }
    1276           0 :     }
    1277           0 : }
    1278             : 
    1279             : 
    1280           0 : void SAL_CALL OleEmbeddedObject::setPersistentEntry(
    1281             :                     const uno::Reference< embed::XStorage >& xStorage,
    1282             :                     const OUString& sEntName,
    1283             :                     sal_Int32 nEntryConnectionMode,
    1284             :                     const uno::Sequence< beans::PropertyValue >& lArguments,
    1285             :                     const uno::Sequence< beans::PropertyValue >& lObjArgs )
    1286             :         throw ( lang::IllegalArgumentException,
    1287             :                 embed::WrongStateException,
    1288             :                 io::IOException,
    1289             :                 uno::Exception,
    1290             :                 uno::RuntimeException, std::exception )
    1291             : {
    1292             :     SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::setPersistentEntry" );
    1293             : 
    1294             :     // begin wrapping related part ====================
    1295           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1296           0 :     if ( xWrappedObject.is() )
    1297             :     {
    1298             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1299           0 :         xWrappedObject->setPersistentEntry( xStorage, sEntName, nEntryConnectionMode, lArguments, lObjArgs );
    1300           0 :         return;
    1301             :     }
    1302             :     // end wrapping related part ====================
    1303             : 
    1304             :     // TODO: use lObjArgs
    1305             : 
    1306             :     // the type of the object must be already set
    1307             :     // a kind of typedetection should be done in the factory;
    1308             :     // the only exception is object initialized from a stream,
    1309             :     // the class ID will be detected from the stream
    1310             : 
    1311           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1312           0 :     if ( m_bDisposed )
    1313           0 :         throw lang::DisposedException(); // TODO
    1314             : 
    1315           0 :     if ( !xStorage.is() )
    1316             :         throw lang::IllegalArgumentException( OUString( "No parent storage is provided!\n" ),
    1317             :                                             uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1318           0 :                                             1 );
    1319             : 
    1320           0 :     if ( sEntName.isEmpty() )
    1321             :         throw lang::IllegalArgumentException( OUString( "Empty element name is provided!\n" ),
    1322             :                                             uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1323           0 :                                             2 );
    1324             : 
    1325             :     // May be LOADED should be forbidden here ???
    1326           0 :     if ( ( m_nObjectState != -1 || nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
    1327           0 :       && ( m_nObjectState == -1 || nEntryConnectionMode != embed::EntryInitModes::NO_INIT ) )
    1328             :     {
    1329             :         // if the object is not loaded
    1330             :         // it can not get persistent representation without initialization
    1331             : 
    1332             :         // if the object is loaded
    1333             :         // it can switch persistent representation only without initialization
    1334             : 
    1335             :         throw embed::WrongStateException(
    1336             :                     OUString( "Can't change persistent representation of activated object!\n" ),
    1337           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1338             :     }
    1339             : 
    1340           0 :     if ( m_bWaitSaveCompleted )
    1341             :     {
    1342           0 :         if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
    1343           0 :             saveCompleted( ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) ) );
    1344             :         else
    1345             :             throw embed::WrongStateException(
    1346             :                         OUString( "The object waits for saveCompleted() call!\n" ),
    1347           0 :                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1348             :     }
    1349             : 
    1350           0 :     uno::Reference< container::XNameAccess > xNameAccess( xStorage, uno::UNO_QUERY );
    1351           0 :     if ( !xNameAccess.is() )
    1352           0 :         throw uno::RuntimeException(); //TODO
    1353             : 
    1354             :     // detect entry existence
    1355           0 :     sal_Bool bElExists = xNameAccess->hasByName( sEntName );
    1356             : 
    1357           0 :     m_bReadOnly = sal_False;
    1358           0 :     for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ )
    1359           0 :         if ( lArguments[nInd].Name == "ReadOnly" )
    1360           0 :             lArguments[nInd].Value >>= m_bReadOnly;
    1361             : 
    1362             : #ifdef WNT
    1363             :     sal_Int32 nStorageMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;
    1364             : #endif
    1365             : 
    1366           0 :     SwitchOwnPersistence( xStorage, sEntName );
    1367             : 
    1368           0 :     for ( sal_Int32 nInd = 0; nInd < lObjArgs.getLength(); nInd++ )
    1369           0 :         if ( lObjArgs[nInd].Name == "StoreVisualReplacement" )
    1370           0 :             lObjArgs[nInd].Value >>= m_bStoreVisRepl;
    1371             : 
    1372             : #ifdef WNT
    1373             :     if ( nEntryConnectionMode == embed::EntryInitModes::DEFAULT_INIT )
    1374             :     {
    1375             :         if ( m_bFromClipboard )
    1376             :         {
    1377             :             // the object should be initialized from clipboard
    1378             :             // inpossibility to initialize the object means error here
    1379             :             CreateOleComponentFromClipboard_Impl( NULL );
    1380             :             m_aClassID = m_pOleComponent->GetCLSID(); // was not set during consruction
    1381             :             m_pOleComponent->RunObject();
    1382             :             m_nObjectState = embed::EmbedStates::RUNNING;
    1383             :         }
    1384             :         else if ( bElExists )
    1385             :         {
    1386             :             // load object from the stream
    1387             :             // after the loading the object can appear as a link
    1388             :             // will be detected by olecomponent
    1389             :             try
    1390             :             {
    1391             :                 CreateOleComponentAndLoad_Impl( NULL );
    1392             :                 m_aClassID = m_pOleComponent->GetCLSID(); // was not set during consruction
    1393             :             }
    1394             :             catch( const uno::Exception& )
    1395             :             {
    1396             :                 // TODO/LATER: detect classID of the object if possible
    1397             :                 // means that the object inprocess server could not be successfully instantiated
    1398             :                 GetRidOfComponent();
    1399             :             }
    1400             : 
    1401             :             m_nObjectState = embed::EmbedStates::LOADED;
    1402             :         }
    1403             :         else
    1404             :         {
    1405             :             // create a new object
    1406             :             CreateOleComponent_Impl();
    1407             :             m_pOleComponent->CreateNewEmbeddedObject( m_aClassID );
    1408             :             m_pOleComponent->RunObject();
    1409             :             m_nObjectState = embed::EmbedStates::RUNNING;
    1410             :         }
    1411             :     }
    1412             :     else
    1413             :     {
    1414             :         if ( ( nStorageMode & embed::ElementModes::READWRITE ) != embed::ElementModes::READWRITE )
    1415             :             throw io::IOException();
    1416             : 
    1417             :         if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
    1418             :         {
    1419             :             // the document just already changed its stream to store to;
    1420             :             // the links to OLE documents switch their persistence in the same way
    1421             :             // as normal embedded objects
    1422             :         }
    1423             :         else if ( nEntryConnectionMode == embed::EntryInitModes::TRUNCATE_INIT )
    1424             :         {
    1425             :             // create a new object, that will be stored in specified stream
    1426             :             CreateOleComponent_Impl();
    1427             : 
    1428             :             m_pOleComponent->CreateNewEmbeddedObject( m_aClassID );
    1429             :             m_pOleComponent->RunObject();
    1430             :             m_nObjectState = embed::EmbedStates::RUNNING;
    1431             :         }
    1432             :         else if ( nEntryConnectionMode == embed::EntryInitModes::MEDIA_DESCRIPTOR_INIT )
    1433             :         {
    1434             :             // use URL ( may be content or stream later ) from MediaDescriptor to initialize object
    1435             :             OUString aURL;
    1436             :             for ( sal_Int32 nInd = 0; nInd < lArguments.getLength(); nInd++ )
    1437             :                 if ( lArguments[nInd].Name == "URL" )
    1438             :                     lArguments[nInd].Value >>= aURL;
    1439             : 
    1440             :             if ( aURL.isEmpty() )
    1441             :                 throw lang::IllegalArgumentException(
    1442             :                                     OUString( "Empty URL is provided in the media descriptor!\n" ),
    1443             :                                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1444             :                                     4 );
    1445             : 
    1446             :             CreateOleComponent_Impl();
    1447             : 
    1448             :             // TODO: the m_bIsLink value must be set already
    1449             :             if ( !m_bIsLink )
    1450             :                 m_pOleComponent->CreateObjectFromFile( aURL );
    1451             :             else
    1452             :                 m_pOleComponent->CreateLinkFromFile( aURL );
    1453             : 
    1454             :             m_pOleComponent->RunObject();
    1455             :             m_aClassID = m_pOleComponent->GetCLSID(); // was not set during consruction
    1456             : 
    1457             :             m_nObjectState = embed::EmbedStates::RUNNING;
    1458             :         }
    1459             :         //else if ( nEntryConnectionMode == embed::EntryInitModes::TRANSFERABLE_INIT )
    1460             :         //{
    1461             :             //TODO:
    1462             :         //}
    1463             :         else
    1464             :             throw lang::IllegalArgumentException( OUString( "Wrong connection mode is provided!\n" ),
    1465             :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1466             :                                         3 );
    1467             :     }
    1468             : #else
    1469             :     // On unix the ole object can not do anything except storing itself somewere
    1470           0 :     if ( nEntryConnectionMode == embed::EntryInitModes::DEFAULT_INIT && bElExists )
    1471             :     {
    1472             :         // TODO/LATER: detect classID of the object
    1473             :         // can be a real problem for the links
    1474             : 
    1475           0 :         m_nObjectState = embed::EmbedStates::LOADED;
    1476             :     }
    1477           0 :     else if ( nEntryConnectionMode == embed::EntryInitModes::NO_INIT )
    1478             :     {
    1479             :         // do nothing, the object has already switched it's persistence
    1480             :     }
    1481             :     else
    1482             :         throw lang::IllegalArgumentException( OUString( "Wrong connection mode is provided!\n" ),
    1483             :                                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1484           0 :                                     3 );
    1485             : 
    1486             : #endif
    1487             : }
    1488             : 
    1489             : 
    1490           0 : void SAL_CALL OleEmbeddedObject::storeToEntry( const uno::Reference< embed::XStorage >& xStorage,
    1491             :                             const OUString& sEntName,
    1492             :                             const uno::Sequence< beans::PropertyValue >& lArguments,
    1493             :                             const uno::Sequence< beans::PropertyValue >& lObjArgs )
    1494             :         throw ( lang::IllegalArgumentException,
    1495             :                 embed::WrongStateException,
    1496             :                 io::IOException,
    1497             :                 uno::Exception,
    1498             :                 uno::RuntimeException, std::exception )
    1499             : {
    1500             :     SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::storeToEntry" );
    1501             : 
    1502             :     // begin wrapping related part ====================
    1503           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1504           0 :     if ( xWrappedObject.is() )
    1505             :     {
    1506             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1507           0 :         xWrappedObject->storeToEntry( xStorage, sEntName, lArguments, lObjArgs );
    1508           0 :         return;
    1509             :     }
    1510             :     // end wrapping related part ====================
    1511             : 
    1512           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1513           0 :     if ( m_bDisposed )
    1514           0 :         throw lang::DisposedException(); // TODO
    1515             : 
    1516           0 :     VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
    1517             : 
    1518           0 :     StoreToLocation_Impl( xStorage, sEntName, lObjArgs, sal_False );
    1519             : 
    1520             :     // TODO: should the listener notification be done?
    1521             : }
    1522             : 
    1523             : 
    1524           0 : void SAL_CALL OleEmbeddedObject::storeAsEntry( const uno::Reference< embed::XStorage >& xStorage,
    1525             :                             const OUString& sEntName,
    1526             :                             const uno::Sequence< beans::PropertyValue >& lArguments,
    1527             :                             const uno::Sequence< beans::PropertyValue >& lObjArgs )
    1528             :         throw ( lang::IllegalArgumentException,
    1529             :                 embed::WrongStateException,
    1530             :                 io::IOException,
    1531             :                 uno::Exception,
    1532             :                 uno::RuntimeException, std::exception )
    1533             : {
    1534             :     SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::storeAsEntry" );
    1535             : 
    1536             :     // begin wrapping related part ====================
    1537           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1538           0 :     if ( xWrappedObject.is() )
    1539             :     {
    1540             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1541           0 :         xWrappedObject->storeAsEntry( xStorage, sEntName, lArguments, lObjArgs );
    1542           0 :         return;
    1543             :     }
    1544             :     // end wrapping related part ====================
    1545             : 
    1546           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1547           0 :     if ( m_bDisposed )
    1548           0 :         throw lang::DisposedException(); // TODO
    1549             : 
    1550           0 :     VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
    1551             : 
    1552           0 :     StoreToLocation_Impl( xStorage, sEntName, lObjArgs, sal_True );
    1553             : 
    1554             :     // TODO: should the listener notification be done here or in saveCompleted?
    1555             : }
    1556             : 
    1557             : 
    1558           0 : void SAL_CALL OleEmbeddedObject::saveCompleted( sal_Bool bUseNew )
    1559             :         throw ( embed::WrongStateException,
    1560             :                 uno::Exception,
    1561             :                 uno::RuntimeException, std::exception )
    1562             : {
    1563             :     SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::saveCompleted" );
    1564             : 
    1565             :     // begin wrapping related part ====================
    1566           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1567           0 :     if ( xWrappedObject.is() )
    1568             :     {
    1569             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1570           0 :         xWrappedObject->saveCompleted( bUseNew );
    1571           0 :         return;
    1572             :     }
    1573             :     // end wrapping related part ====================
    1574             : 
    1575           0 :     ::osl::ResettableMutexGuard aGuard( m_aMutex );
    1576           0 :     if ( m_bDisposed )
    1577           0 :         throw lang::DisposedException(); // TODO
    1578             : 
    1579           0 :     if ( m_nObjectState == -1 )
    1580             :     {
    1581             :         // the object is still not loaded
    1582             :         throw embed::WrongStateException( OUString( "Can't store object without persistence!\n" ),
    1583           0 :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1584             :     }
    1585             : 
    1586             :     // it is allowed to call saveCompleted( false ) for nonstored objects
    1587           0 :     if ( !m_bWaitSaveCompleted && !bUseNew )
    1588           0 :         return;
    1589             : 
    1590             :     SAL_WARN_IF( !m_bWaitSaveCompleted, "embeddedobj.ole", "Unexpected saveCompleted() call!\n" );
    1591           0 :     if ( !m_bWaitSaveCompleted )
    1592           0 :         throw io::IOException(); // TODO: illegal call
    1593             : 
    1594             :     OSL_ENSURE( m_xNewObjectStream.is() && m_xNewParentStorage.is() , "Internal object information is broken!\n" );
    1595           0 :     if ( !m_xNewObjectStream.is() || !m_xNewParentStorage.is() )
    1596           0 :         throw uno::RuntimeException(); // TODO: broken internal information
    1597             : 
    1598           0 :     if ( bUseNew )
    1599             :     {
    1600           0 :         SwitchOwnPersistence( m_xNewParentStorage, m_xNewObjectStream, m_aNewEntryName );
    1601           0 :         m_bStoreVisRepl = m_bNewVisReplInStream;
    1602           0 :         SetVisReplInStream( m_bNewVisReplInStream );
    1603           0 :         m_xCachedVisualRepresentation = m_xNewCachedVisRepl;
    1604             :     }
    1605             :     else
    1606             :     {
    1607             :         // close remembered stream
    1608             :         try {
    1609           0 :             uno::Reference< lang::XComponent > xComponent( m_xNewObjectStream, uno::UNO_QUERY );
    1610             :             SAL_WARN_IF( !xComponent.is(), "embeddedobj.ole", "Wrong storage implementation!" );
    1611           0 :             if ( xComponent.is() )
    1612           0 :                 xComponent->dispose();
    1613             :         }
    1614           0 :         catch ( const uno::Exception& )
    1615             :         {
    1616             :         }
    1617             :     }
    1618             : 
    1619           0 :     sal_Bool bStoreLoaded = m_bStoreLoaded;
    1620             : 
    1621           0 :     m_xNewObjectStream = uno::Reference< io::XStream >();
    1622           0 :     m_xNewParentStorage = uno::Reference< embed::XStorage >();
    1623           0 :     m_aNewEntryName = OUString();
    1624           0 :     m_bWaitSaveCompleted = sal_False;
    1625           0 :     m_bNewVisReplInStream = sal_False;
    1626           0 :     m_xNewCachedVisRepl = uno::Reference< io::XStream >();
    1627           0 :     m_bStoreLoaded = sal_False;
    1628             : 
    1629           0 :     if ( bUseNew && m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE && !bStoreLoaded
    1630           0 :       && m_nObjectState != embed::EmbedStates::LOADED )
    1631             :     {
    1632             :         // the object replacement image should be updated, so the cached size as well
    1633           0 :         m_bHasCachedSize = sal_False;
    1634             :         try
    1635             :         {
    1636             :             // the call will cache the size in case of success
    1637             :             // probably it might need to be done earlier, while the object is in active state
    1638           0 :             getVisualAreaSize( embed::Aspects::MSOLE_CONTENT );
    1639             :         }
    1640           0 :         catch( const uno::Exception& )
    1641             :         {}
    1642             :     }
    1643             : 
    1644           0 :     aGuard.clear();
    1645           0 :     if ( bUseNew )
    1646             :     {
    1647           0 :         MakeEventListenerNotification_Impl( OUString( "OnSaveAsDone" ));
    1648             : 
    1649             :         // the object can be changed only on windows
    1650             :         // the notification should be done only if the object is not in loaded state
    1651           0 :         if ( m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE && !bStoreLoaded )
    1652             :         {
    1653           0 :             MakeEventListenerNotification_Impl( OUString( "OnVisAreaChanged" ));
    1654             :         }
    1655           0 :     }
    1656             : }
    1657             : 
    1658             : 
    1659           0 : sal_Bool SAL_CALL OleEmbeddedObject::hasEntry()
    1660             :         throw ( embed::WrongStateException,
    1661             :                 uno::RuntimeException, std::exception )
    1662             : {
    1663             :     // begin wrapping related part ====================
    1664           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1665           0 :     if ( xWrappedObject.is() )
    1666             :     {
    1667             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1668           0 :         return xWrappedObject->hasEntry();
    1669             :     }
    1670             :     // end wrapping related part ====================
    1671             : 
    1672           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1673           0 :     if ( m_bDisposed )
    1674           0 :         throw lang::DisposedException(); // TODO
    1675             : 
    1676           0 :     if ( m_bWaitSaveCompleted )
    1677             :         throw embed::WrongStateException(
    1678             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1679           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1680             : 
    1681           0 :     if ( m_xObjectStream.is() )
    1682           0 :         return sal_True;
    1683             : 
    1684           0 :     return sal_False;
    1685             : }
    1686             : 
    1687             : 
    1688           0 : OUString SAL_CALL OleEmbeddedObject::getEntryName()
    1689             :         throw ( embed::WrongStateException,
    1690             :                 uno::RuntimeException, std::exception )
    1691             : {
    1692             :     // begin wrapping related part ====================
    1693           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1694           0 :     if ( xWrappedObject.is() )
    1695             :     {
    1696             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1697           0 :         return xWrappedObject->getEntryName();
    1698             :     }
    1699             :     // end wrapping related part ====================
    1700             : 
    1701           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1702           0 :     if ( m_bDisposed )
    1703           0 :         throw lang::DisposedException(); // TODO
    1704             : 
    1705           0 :     if ( m_nObjectState == -1 )
    1706             :     {
    1707             :         // the object is still not loaded
    1708             :         throw embed::WrongStateException( OUString( "The object persistence is not initialized!\n" ),
    1709           0 :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1710             :     }
    1711             : 
    1712           0 :     if ( m_bWaitSaveCompleted )
    1713             :         throw embed::WrongStateException(
    1714             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1715           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1716             : 
    1717           0 :     return m_aEntryName;
    1718             : }
    1719             : 
    1720             : 
    1721             : 
    1722           0 : void SAL_CALL OleEmbeddedObject::storeOwn()
    1723             :         throw ( embed::WrongStateException,
    1724             :                 io::IOException,
    1725             :                 uno::Exception,
    1726             :                 uno::RuntimeException, std::exception )
    1727             : {
    1728             :     SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::storeOwn" );
    1729             : 
    1730             :     // begin wrapping related part ====================
    1731           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1732           0 :     if ( xWrappedObject.is() )
    1733             :     {
    1734             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1735           0 :         xWrappedObject->storeOwn();
    1736           0 :         return;
    1737             :     }
    1738             :     // end wrapping related part ====================
    1739             : 
    1740             :     // during switching from Activated to Running and from Running to Loaded states the object will
    1741             :     // ask container to store the object, the container has to make decision
    1742             :     // to do so or not
    1743             : 
    1744           0 :     ::osl::ResettableMutexGuard aGuard( m_aMutex );
    1745           0 :     if ( m_bDisposed )
    1746           0 :         throw lang::DisposedException(); // TODO
    1747             : 
    1748           0 :     VerbExecutionControllerGuard aVerbGuard( m_aVerbExecutionController );
    1749             : 
    1750           0 :     if ( m_nObjectState == -1 )
    1751             :     {
    1752             :         // the object is still not loaded
    1753             :         throw embed::WrongStateException( OUString( "Can't store object without persistence!\n" ),
    1754           0 :                                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1755             :     }
    1756             : 
    1757           0 :     if ( m_bWaitSaveCompleted )
    1758             :         throw embed::WrongStateException(
    1759             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1760           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1761             : 
    1762           0 :     if ( m_bReadOnly )
    1763           0 :         throw io::IOException(); // TODO: access denied
    1764             : 
    1765           0 :     LetCommonStoragePassBeUsed_Impl( m_xObjectStream );
    1766             : 
    1767           0 :     sal_Bool bStoreLoaded = sal_True;
    1768             : 
    1769             : #ifdef WNT
    1770             :     if ( m_nObjectState != embed::EmbedStates::LOADED && m_pOleComponent && m_pOleComponent->IsDirty() )
    1771             :     {
    1772             :         bStoreLoaded = sal_False;
    1773             : 
    1774             :         OSL_ENSURE( m_xParentStorage.is() && m_xObjectStream.is(), "The object has no valid persistence!\n" );
    1775             : 
    1776             :         if ( !m_xObjectStream.is() )
    1777             :             throw io::IOException(); //TODO: access denied
    1778             : 
    1779             :         SetStreamMediaType_Impl( m_xObjectStream, OUString( "application/vnd.sun.star.oleobject" ));
    1780             :         uno::Reference< io::XOutputStream > xOutStream = m_xObjectStream->getOutputStream();
    1781             :         if ( !xOutStream.is() )
    1782             :             throw io::IOException(); //TODO: access denied
    1783             : 
    1784             :         // TODO: does this work for links too?
    1785             :         StoreObjectToStream( GetStreamForSaving() );
    1786             : 
    1787             :         // the replacement is changed probably, and it must be in the object stream
    1788             :         if ( !m_pOleComponent->IsWorkaroundActive() )
    1789             :             m_xCachedVisualRepresentation = uno::Reference< io::XStream >();
    1790             :         SetVisReplInStream( sal_True );
    1791             :     }
    1792             : #endif
    1793             : 
    1794           0 :     if ( m_bStoreVisRepl != HasVisReplInStream() )
    1795             :     {
    1796           0 :         if ( m_bStoreVisRepl )
    1797             :         {
    1798             :             // the m_xCachedVisualRepresentation must be set or it should be already stored
    1799           0 :             if ( m_xCachedVisualRepresentation.is() )
    1800           0 :                 InsertVisualCache_Impl( m_xObjectStream, m_xCachedVisualRepresentation );
    1801             :             else
    1802             :             {
    1803           0 :                 m_xCachedVisualRepresentation = TryToRetrieveCachedVisualRepresentation_Impl( m_xObjectStream );
    1804             :                 SAL_WARN_IF( !m_xCachedVisualRepresentation.is(), "embeddedobj.ole", "No representation is available!" );
    1805             :             }
    1806             :         }
    1807             :         else
    1808             :         {
    1809           0 :             if ( !m_xCachedVisualRepresentation.is() )
    1810           0 :                 m_xCachedVisualRepresentation = TryToRetrieveCachedVisualRepresentation_Impl( m_xObjectStream );
    1811           0 :             RemoveVisualCache_Impl( m_xObjectStream );
    1812             :         }
    1813             : 
    1814           0 :         SetVisReplInStream( m_bStoreVisRepl );
    1815             :     }
    1816             : 
    1817           0 :     if ( m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE && !bStoreLoaded )
    1818             :     {
    1819             :         // the object replacement image should be updated, so the cached size as well
    1820           0 :         m_bHasCachedSize = sal_False;
    1821             :         try
    1822             :         {
    1823             :             // the call will cache the size in case of success
    1824             :             // probably it might need to be done earlier, while the object is in active state
    1825           0 :             getVisualAreaSize( embed::Aspects::MSOLE_CONTENT );
    1826             :         }
    1827           0 :         catch( const uno::Exception& )
    1828             :         {}
    1829             :     }
    1830             : 
    1831           0 :     aGuard.clear();
    1832             : 
    1833           0 :     MakeEventListenerNotification_Impl( OUString( "OnSaveDone" ));
    1834             : 
    1835             :     // the object can be changed only on Windows
    1836             :     // the notification should be done only if the object is not in loaded state
    1837           0 :     if ( m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE && !bStoreLoaded )
    1838           0 :         MakeEventListenerNotification_Impl( OUString( "OnVisAreaChanged" ));
    1839             : }
    1840             : 
    1841             : 
    1842           0 : sal_Bool SAL_CALL OleEmbeddedObject::isReadonly()
    1843             :         throw ( embed::WrongStateException,
    1844             :                 uno::RuntimeException, std::exception )
    1845             : {
    1846             :     // begin wrapping related part ====================
    1847           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1848           0 :     if ( xWrappedObject.is() )
    1849             :     {
    1850             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1851           0 :         return xWrappedObject->isReadonly();
    1852             :     }
    1853             :     // end wrapping related part ====================
    1854             : 
    1855           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1856           0 :     if ( m_bDisposed )
    1857           0 :         throw lang::DisposedException(); // TODO
    1858             : 
    1859           0 :     if ( m_nObjectState == -1 )
    1860             :     {
    1861             :         // the object is still not loaded
    1862             :         throw embed::WrongStateException( OUString( "The object persistence is not initialized!\n" ),
    1863           0 :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1864             :     }
    1865             : 
    1866           0 :     if ( m_bWaitSaveCompleted )
    1867             :         throw embed::WrongStateException(
    1868             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1869           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1870             : 
    1871           0 :     return m_bReadOnly;
    1872             : }
    1873             : 
    1874             : 
    1875           0 : void SAL_CALL OleEmbeddedObject::reload(
    1876             :                 const uno::Sequence< beans::PropertyValue >& lArguments,
    1877             :                 const uno::Sequence< beans::PropertyValue >& lObjArgs )
    1878             :         throw ( lang::IllegalArgumentException,
    1879             :                 embed::WrongStateException,
    1880             :                 io::IOException,
    1881             :                 uno::Exception,
    1882             :                 uno::RuntimeException, std::exception )
    1883             : {
    1884             :     // begin wrapping related part ====================
    1885           0 :     uno::Reference< embed::XEmbedPersist > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1886           0 :     if ( xWrappedObject.is() )
    1887             :     {
    1888             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1889           0 :         xWrappedObject->reload( lArguments, lObjArgs );
    1890           0 :         return;
    1891             :     }
    1892             :     // end wrapping related part ====================
    1893             : 
    1894             :     // TODO: use lObjArgs
    1895             : 
    1896           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1897           0 :     if ( m_bDisposed )
    1898           0 :         throw lang::DisposedException(); // TODO
    1899             : 
    1900           0 :     if ( m_nObjectState == -1 )
    1901             :     {
    1902             :         // the object is still not loaded
    1903             :         throw embed::WrongStateException( OUString( "The object persistence is not initialized!\n" ),
    1904           0 :                                         uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1905             :     }
    1906             : 
    1907           0 :     if ( m_bWaitSaveCompleted )
    1908             :         throw embed::WrongStateException(
    1909             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1910           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1911             : 
    1912             :     // TODO:
    1913             :     // throw away current document
    1914             :     // load new document from current storage
    1915             :     // use meaningfull part of lArguments
    1916             : }
    1917             : 
    1918             : 
    1919           0 : void SAL_CALL OleEmbeddedObject::breakLink( const uno::Reference< embed::XStorage >& xStorage,
    1920             :                                                 const OUString& sEntName )
    1921             :         throw ( lang::IllegalArgumentException,
    1922             :                 embed::WrongStateException,
    1923             :                 io::IOException,
    1924             :                 uno::Exception,
    1925             :                 uno::RuntimeException, std::exception )
    1926             : {
    1927             :     // begin wrapping related part ====================
    1928           0 :     uno::Reference< embed::XLinkageSupport > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    1929           0 :     if ( xWrappedObject.is() )
    1930             :     {
    1931             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    1932           0 :         xWrappedObject->breakLink( xStorage, sEntName );
    1933           0 :         return;
    1934             :     }
    1935             :     // end wrapping related part ====================
    1936             : 
    1937           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    1938           0 :     if ( m_bDisposed )
    1939           0 :         throw lang::DisposedException(); // TODO
    1940             : 
    1941           0 :     if ( !xStorage.is() )
    1942             :         throw lang::IllegalArgumentException( OUString( "No parent storage is provided!\n" ),
    1943             :                                             uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1944           0 :                                             1 );
    1945             : 
    1946           0 :     if ( sEntName.isEmpty() )
    1947             :         throw lang::IllegalArgumentException( OUString( "Empty element name is provided!\n" ),
    1948             :                                             uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ),
    1949           0 :                                             2 );
    1950             : 
    1951             :     // TODO: The object must be at least in Running state;
    1952           0 :     if ( !m_bIsLink || m_nObjectState == -1 || !m_pOleComponent )
    1953             :     {
    1954             :         // it must be a linked initialized object
    1955             :         throw embed::WrongStateException(
    1956             :                     OUString( "The object is not a valid linked object!\n" ),
    1957           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1958             :     }
    1959             : 
    1960           0 :     if ( m_bReadOnly )
    1961           0 :         throw io::IOException(); // TODO: Access denied
    1962             : 
    1963           0 :     if ( m_bWaitSaveCompleted )
    1964             :         throw embed::WrongStateException(
    1965             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    1966           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    1967             : 
    1968             : 
    1969             : #ifdef WNT
    1970             :     if ( m_pOleComponent )
    1971             :     {
    1972             :         // TODO: create an object based on the link
    1973             : 
    1974             :         // disconnect the old temporary URL
    1975             :         OUString aOldTempURL = m_aTempURL;
    1976             :         m_aTempURL = OUString();
    1977             : 
    1978             :         OleComponent* pNewOleComponent = new OleComponent( m_xFactory, this );
    1979             :         try {
    1980             :             pNewOleComponent->InitEmbeddedCopyOfLink( m_pOleComponent );
    1981             :         }
    1982             :         catch ( const uno::Exception& )
    1983             :         {
    1984             :             delete pNewOleComponent;
    1985             :             if ( !m_aTempURL.isEmpty() )
    1986             :                    KillFile_Impl( m_aTempURL, m_xFactory );
    1987             :             m_aTempURL = aOldTempURL;
    1988             :             throw;
    1989             :         }
    1990             : 
    1991             :         try {
    1992             :             GetRidOfComponent();
    1993             :         }
    1994             :         catch( const uno::Exception& )
    1995             :         {
    1996             :             delete pNewOleComponent;
    1997             :             if ( !m_aTempURL.isEmpty() )
    1998             :                    KillFile_Impl( m_aTempURL, m_xFactory );
    1999             :             m_aTempURL = aOldTempURL;
    2000             :             throw;
    2001             :         }
    2002             : 
    2003             :            KillFile_Impl( aOldTempURL, m_xFactory );
    2004             : 
    2005             :         CreateOleComponent_Impl( pNewOleComponent );
    2006             : 
    2007             :         if ( m_xParentStorage != xStorage || !m_aEntryName.equals( sEntName ) )
    2008             :             SwitchOwnPersistence( xStorage, sEntName );
    2009             : 
    2010             :         if ( m_nObjectState != embed::EmbedStates::LOADED )
    2011             :         {
    2012             :             // TODO: should we activate the new object if the link was activated?
    2013             : 
    2014             :             sal_Int32 nTargetState = m_nObjectState;
    2015             :             m_nObjectState = embed::EmbedStates::LOADED;
    2016             : 
    2017             :             if ( m_nObjectState == embed::EmbedStates::RUNNING )
    2018             :                 m_pOleComponent->RunObject(); // the object already was in running state, the server must be installed
    2019             :             else // m_nObjectState == embed::EmbedStates::ACTIVE
    2020             :             {
    2021             :                 m_pOleComponent->RunObject(); // the object already was in running state, the server must be installed
    2022             :                 m_pOleComponent->ExecuteVerb( embed::EmbedVerbs::MS_OLEVERB_OPEN );
    2023             :             }
    2024             : 
    2025             :             m_nObjectState = nTargetState;
    2026             :         }
    2027             : 
    2028             :         m_bIsLink = sal_False;
    2029             :         m_aLinkURL = OUString();
    2030             :     }
    2031             :     else
    2032             : #endif
    2033             :     {
    2034           0 :         throw io::IOException(); //TODO:
    2035           0 :     }
    2036             : }
    2037             : 
    2038             : 
    2039           0 : sal_Bool SAL_CALL  OleEmbeddedObject::isLink()
    2040             :         throw ( embed::WrongStateException,
    2041             :                 uno::RuntimeException, std::exception )
    2042             : {
    2043             :     // begin wrapping related part ====================
    2044           0 :     uno::Reference< embed::XLinkageSupport > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    2045           0 :     if ( xWrappedObject.is() )
    2046             :     {
    2047             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    2048           0 :         return xWrappedObject->isLink();
    2049             :     }
    2050             :     // end wrapping related part ====================
    2051             : 
    2052           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    2053           0 :     if ( m_bDisposed )
    2054           0 :         throw lang::DisposedException(); // TODO
    2055             : 
    2056           0 :     return m_bIsLink;
    2057             : }
    2058             : 
    2059             : 
    2060           0 : OUString SAL_CALL OleEmbeddedObject::getLinkURL()
    2061             :         throw ( embed::WrongStateException,
    2062             :                 uno::Exception,
    2063             :                 uno::RuntimeException, std::exception )
    2064             : {
    2065             :     // begin wrapping related part ====================
    2066           0 :     uno::Reference< embed::XLinkageSupport > xWrappedObject( m_xWrappedObject, uno::UNO_QUERY );
    2067           0 :     if ( xWrappedObject.is() )
    2068             :     {
    2069             :         // the object was converted to OOo embedded object, the current implementation is now only a wrapper
    2070           0 :         return xWrappedObject->getLinkURL();
    2071             :     }
    2072             :     // end wrapping related part ====================
    2073             : 
    2074           0 :     ::osl::MutexGuard aGuard( m_aMutex );
    2075           0 :     if ( m_bDisposed )
    2076           0 :         throw lang::DisposedException(); // TODO
    2077             : 
    2078           0 :     if ( m_bWaitSaveCompleted )
    2079             :         throw embed::WrongStateException(
    2080             :                     OUString( "The object waits for saveCompleted() call!\n" ),
    2081           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    2082             : 
    2083           0 :     if ( !m_bIsLink )
    2084             :         throw embed::WrongStateException(
    2085             :                     OUString( "The object is not a link object!\n" ),
    2086           0 :                     uno::Reference< uno::XInterface >( static_cast< ::cppu::OWeakObject* >(this) ) );
    2087             : 
    2088             :     // TODO: probably the link URL can be retrieved from OLE
    2089             : 
    2090           0 :     return m_aLinkURL;
    2091             : }
    2092             : 
    2093             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10