/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <oleembobj.hxx>

#include "olepersist.hxx"

#include <com/sun/star/embed/EmbedStates.hpp>

#include <com/sun/star/embed/EmbedVerbs.hpp>

#include <com/sun/star/embed/EntryInitModes.hpp>

#include <com/sun/star/embed/WrongStateException.hpp>

#include <com/sun/star/embed/XStorage.hpp>

#include <com/sun/star/embed/XTransactedObject.hpp>

#include <com/sun/star/embed/ElementModes.hpp>

#include <com/sun/star/embed/EmbedUpdateModes.hpp>

#include <com/sun/star/embed/Aspects.hpp>

#include <com/sun/star/embed/XOptimizedStorage.hpp>

#include <com/sun/star/lang/XComponent.hpp>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/container/XNameAccess.hpp>

#include <com/sun/star/container/XNameContainer.hpp>

#include <com/sun/star/io/TempFile.hpp>

#include <com/sun/star/io/XSeekable.hpp>

#include <com/sun/star/io/XTruncate.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/packages/WrongPasswordException.hpp>

#include <com/sun/star/ucb/SimpleFileAccess.hpp>

#include <com/sun/star/io/IOException.hpp>

#include <comphelper/storagehelper.hxx>

#include <comphelper/mimeconfighelper.hxx>

#include <comphelper/classids.hxx>

#include <osl/diagnose.h>

#include <osl/thread.hxx>

#include <rtl/ref.hxx>

#include <sal/log.hxx>

#include <closepreventer.hxx>

#if defined(_WIN32)

#include "olecomponent.hxx"

#endif

using namespace ::com::sun::star;

using namespace ::comphelper;

bool KillFile_Impl( const OUString& aURL, const uno::Reference< uno::XComponentContext >& xContext )

{

    if ( !xContext.is() )

        return false;

    bool bRet = false;

    try

    {

        uno::Reference < ucb::XSimpleFileAccess3 > xAccess(

                ucb::SimpleFileAccess::create( xContext ) );

        xAccess->kill( aURL );

        bRet = true;

    }

    catch( const uno::Exception& )

    {

    }

    return bRet;

}

OUString GetNewTempFileURL_Impl( const uno::Reference< uno::XComponentContext >& xContext )

{

    SAL_WARN_IF( !xContext.is(), "embeddedobj.ole", "No factory is provided!" );

    OUString aResult;

    uno::Reference < io::XTempFile > xTempFile(

            io::TempFile::create(xContext),

            uno::UNO_SET_THROW );

    try {

        xTempFile->setRemoveFile( false );

        aResult = xTempFile->getUri();

    }

    catch ( const uno::Exception& )

    {

    }

    if ( aResult.isEmpty() )

        throw uno::RuntimeException(u"Cannot create tempfile."_ustr);

    return aResult;

}

OUString GetNewFilledTempFile_Impl( const uno::Reference< io::XInputStream >& xInStream,

                                      const uno::Reference< uno::XComponentContext >& xContext )

{

    OSL_ENSURE( xInStream.is() && xContext.is(), "Wrong parameters are provided!" );

    OUString aResult = GetNewTempFileURL_Impl( xContext );

    if ( !aResult.isEmpty() )

    {

        try {

            uno::Reference < ucb::XSimpleFileAccess3 > xTempAccess(

                    ucb::SimpleFileAccess::create( xContext ) );

            uno::Reference< io::XOutputStream > xTempOutStream = xTempAccess->openFileWrite( aResult );

            if ( !xTempOutStream.is() )

                throw io::IOException(); // TODO:

            // copy stream contents to the file

            ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOutStream );

            xTempOutStream->closeOutput();

            xTempOutStream.clear();

        }

        catch( const packages::WrongPasswordException& )

        {

            KillFile_Impl( aResult, xContext );

            throw io::IOException(); //TODO:

        }

        catch( const io::IOException& )

        {

            KillFile_Impl( aResult, xContext );

            throw;

        }

        catch( const uno::RuntimeException& )

        {

            KillFile_Impl( aResult, xContext );

            throw;

        }

        catch( const uno::Exception& )

        {

            KillFile_Impl( aResult, xContext );

            aResult.clear();

        }

    }

    return aResult;

}

#ifdef _WIN32

/// @throws io::IOException

/// @throws uno::RuntimeException

static OUString GetNewFilledTempFile_Impl( const uno::Reference< embed::XOptimizedStorage >& xParentStorage, const OUString& aEntryName, const uno::Reference< uno::XComponentContext >& xContext )

{

    OUString aResult;

    try

    {

        uno::Reference < io::XTempFile > xTempFile(

                io::TempFile::create(xContext),

                uno::UNO_SET_THROW );

        xParentStorage->copyStreamElementData( aEntryName, xTempFile );

        xTempFile->setRemoveFile( false );

        aResult = xTempFile->getUri();

    }

    catch( const uno::RuntimeException& )

    {

        throw;

    }

    catch( const uno::Exception& )

    {

    }

    if ( aResult.isEmpty() )

        throw io::IOException();

    return aResult;

}

static void SetStreamMediaType_Impl( const uno::Reference< io::XStream >& xStream, const OUString& aMediaType )

{

    uno::Reference< beans::XPropertySet > xPropSet( xStream, uno::UNO_QUERY_THROW );

    xPropSet->setPropertyValue("MediaType", uno::Any( aMediaType ) );

}

#endif

static void LetCommonStoragePassBeUsed_Impl( const uno::Reference< io::XStream >& xStream )

{

    uno::Reference< beans::XPropertySet > xPropSet( xStream, uno::UNO_QUERY_THROW );

    xPropSet->setPropertyValue(u"UseCommonStoragePasswordEncryption"_ustr,

                                uno::Any( true ) );

}

#ifdef _WIN32

void VerbExecutionController::StartControlExecution()

{

    osl::MutexGuard aGuard( m_aVerbExecutionMutex );

    // the class is used to detect STAMPIT object, that can never be active

    if ( !m_bVerbExecutionInProgress && !m_bWasEverActive )

    {

        m_bVerbExecutionInProgress = true;

        m_nVerbExecutionThreadIdentifier = osl::Thread::getCurrentIdentifier();

        m_bChangedOnVerbExecution = false;

    }

}

bool VerbExecutionController::EndControlExecution_WasModified()

{

    osl::MutexGuard aGuard( m_aVerbExecutionMutex );

    bool bResult = false;

    if ( m_bVerbExecutionInProgress && m_nVerbExecutionThreadIdentifier == osl::Thread::getCurrentIdentifier() )

    {

        bResult = m_bChangedOnVerbExecution;

        m_bVerbExecutionInProgress = false;

    }

    return bResult;

}

void VerbExecutionController::ModificationNotificationIsDone()

{

    osl::MutexGuard aGuard( m_aVerbExecutionMutex );

    if ( m_bVerbExecutionInProgress && osl::Thread::getCurrentIdentifier() == m_nVerbExecutionThreadIdentifier )

        m_bChangedOnVerbExecution = true;

}

#endif

void VerbExecutionController::LockNotification()

{

    osl::MutexGuard aGuard( m_aVerbExecutionMutex );

    if ( m_nNotificationLock < SAL_MAX_INT32 )

        m_nNotificationLock++;

}

void VerbExecutionController::UnlockNotification()

{

    osl::MutexGuard aGuard( m_aVerbExecutionMutex );

    if ( m_nNotificationLock > 0 )

        m_nNotificationLock--;

}

uno::Reference< io::XStream > OleEmbeddedObject::GetNewFilledTempStream_Impl( const uno::Reference< io::XInputStream >& xInStream )

{

    SAL_WARN_IF( !xInStream.is(), "embeddedobj.ole", "Wrong parameter is provided!" );

    uno::Reference < io::XStream > xTempFile(

            io::TempFile::create(m_xContext),

            uno::UNO_QUERY_THROW );

    uno::Reference< io::XOutputStream > xTempOutStream = xTempFile->getOutputStream();

    if ( !xTempOutStream.is() )

        throw io::IOException(); // TODO:

    ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xTempOutStream );

    xTempOutStream->flush();

    return xTempFile;

}

uno::Reference< io::XStream > OleEmbeddedObject::TryToGetAcceptableFormat_Impl( const uno::Reference< io::XStream >& xStream )

{

    // TODO/LATER: Actually this should be done by a centralized component ( may be a graphical filter )

    if ( !m_xContext.is() )

        throw uno::RuntimeException();

    uno::Reference< io::XInputStream > xInStream = xStream->getInputStream();

    if ( !xInStream.is() )

        throw uno::RuntimeException();

    uno::Reference< io::XSeekable > xSeek( xStream, uno::UNO_QUERY_THROW );

    xSeek->seek( 0 );

    uno::Sequence< sal_Int8 > aData( 8 );

    sal_Int32 nRead = xInStream->readBytes( aData, 8 );

    xSeek->seek( 0 );

    if ( ( nRead >= 2 && aData[0] == 'B' && aData[1] == 'M' )

      || ( nRead >= 4 && aData[0] == 1 && aData[1] == 0 && aData[2] == 9 && aData[3] == 0 ) )

    {

        // it should be a bitmap or a Metafile

        return xStream;

    }

    sal_uInt32 nHeaderOffset = 0;

    if ( ( nRead >= 8 && aData[0] == -1 && aData[1] == -1 && aData[2] == -1 && aData[3] == -1 )

      && ( aData[4] == 2 || aData[4] == 3 || aData[4] == 14 ) && aData[5] == 0 && aData[6] == 0 && aData[7] == 0 )

    {

        nHeaderOffset = 40;

        xSeek->seek( 8 );

        // TargetDevice might be used in future, currently the cache has specified NULL

        uno::Sequence< sal_Int8 > aHeadData( 4 );

        nRead = xInStream->readBytes( aHeadData, 4 );

        sal_uInt32 nLen = 0;

        if ( nRead == 4 && aHeadData.getLength() == 4 )

            nLen = ( ( ( static_cast<sal_uInt32>(aHeadData[3]) * 0x100 + static_cast<sal_uInt32>(aHeadData[2]) ) * 0x100 ) + static_cast<sal_uInt32>(aHeadData[1]) ) * 0x100 + static_cast<sal_uInt32>(aHeadData[0]);

        if ( nLen > 4 )

        {

            xInStream->skipBytes( nLen - 4 );

            nHeaderOffset += nLen - 4;

        }

    }

    else if ( nRead > 4 )

    {

        // check whether the first bytes represent the size

        sal_uInt32 nSize = 0;

        for ( sal_Int32 nInd = 3; nInd >= 0; nInd-- )

            nSize = ( nSize << 8 ) + static_cast<sal_uInt8>(aData[nInd]);

        if ( nSize == xSeek->getLength() - 4 )

            nHeaderOffset = 4;

    }

    if ( nHeaderOffset )

    {

        // this is either a bitmap or a metafile clipboard format, retrieve the pure stream

        uno::Reference < io::XStream > xResult(

            io::TempFile::create(m_xContext),

            uno::UNO_QUERY_THROW );

        uno::Reference < io::XSeekable > xResultSeek( xResult, uno::UNO_QUERY_THROW );

        uno::Reference < io::XOutputStream > xResultOut = xResult->getOutputStream();

        uno::Reference < io::XInputStream > xResultIn = xResult->getInputStream();

        if ( !xResultOut.is() || !xResultIn.is() )

            throw uno::RuntimeException();

        xSeek->seek( nHeaderOffset ); // header size for these formats

        ::comphelper::OStorageHelper::CopyInputToOutput( xInStream, xResultOut );

        xResultOut->closeOutput();

        xResultSeek->seek( 0 );

        xSeek->seek( 0 );

        return xResult;

    }

    return uno::Reference< io::XStream >();

}

void OleEmbeddedObject::InsertVisualCache_Impl( const uno::Reference< io::XStream >& xTargetStream,

                                                const uno::Reference< io::XStream >& xCachedVisualRepresentation,

                                                osl::ResettableMutexGuard& rGuard )

{

    OSL_ENSURE( xTargetStream.is() && xCachedVisualRepresentation.is(), "Invalid arguments!" );

    if ( !xTargetStream.is() || !xCachedVisualRepresentation.is() )

        throw uno::RuntimeException();

    uno::Sequence< uno::Any > aArgs{ uno::Any(xTargetStream),

                                     uno::Any(true) }; // do not create copy

    uno::Reference< container::XNameContainer > xNameContainer(

            m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(

                    u"com.sun.star.embed.OLESimpleStorage"_ustr,

                    aArgs, m_xContext ),

            uno::UNO_QUERY_THROW );

    uno::Reference< io::XSeekable > xCachedSeek( xCachedVisualRepresentation, uno::UNO_QUERY_THROW );

    xCachedSeek->seek( 0 );

    uno::Reference < io::XStream > xTempFile(

            io::TempFile::create(m_xContext),

            uno::UNO_QUERY_THROW );

    uno::Reference< io::XSeekable > xTempSeek( xTempFile, uno::UNO_QUERY_THROW );

    uno::Reference< io::XOutputStream > xTempOutStream = xTempFile->getOutputStream();

    if ( !xTempOutStream.is() )

        throw io::IOException(); // TODO:

    // the OlePres stream must have additional header

    // TODO/LATER: might need to be extended in future (actually makes sense only for SO7 format)

    uno::Reference< io::XInputStream > xInCacheStream = xCachedVisualRepresentation->getInputStream();

    if ( !xInCacheStream.is() )

        throw uno::RuntimeException();

    // write 0xFFFFFFFF at the beginning

    uno::Sequence< sal_Int8 > aData( 4 );

    auto pData = aData.getArray();

    * reinterpret_cast<sal_uInt32*>(pData) = 0xFFFFFFFF;

    xTempOutStream->writeBytes( aData );

    // write clipboard format

    uno::Sequence< sal_Int8 > aSigData( 2 );

    xInCacheStream->readBytes( aSigData, 2 );

    if ( aSigData.getLength() < 2 )

        throw io::IOException();

    if ( aSigData[0] == 'B' && aSigData[1] == 'M' )

    {

        // it's a bitmap

        pData[0] = 0x02; pData[1] = 0; pData[2] = 0; pData[3] = 0;

    }

    else

    {

        // treat it as a metafile

        pData[0] = 0x03; pData[1] = 0; pData[2] = 0; pData[3] = 0;

    }

    xTempOutStream->writeBytes( aData );

    // write job related information

    pData[0] = 0x04; pData[1] = 0; pData[2] = 0; pData[3] = 0;

    xTempOutStream->writeBytes( aData );

    // write aspect

    pData[0] = 0x01; pData[1] = 0; pData[2] = 0; pData[3] = 0;

    xTempOutStream->writeBytes( aData );

    // write l-index

    * reinterpret_cast<sal_uInt32*>(pData) = 0xFFFFFFFF;

    xTempOutStream->writeBytes( aData );

    // write adv. flags

    pData[0] = 0x02; pData[1] = 0; pData[2] = 0; pData[3] = 0;

    xTempOutStream->writeBytes( aData );

    // write compression

    * reinterpret_cast<sal_uInt32*>(pData) = 0x0;

    xTempOutStream->writeBytes( aData );

    // get the size

    awt::Size aSize = getVisualAreaSize_impl(embed::Aspects::MSOLE_CONTENT, rGuard);

    sal_Int32 nIndex = 0;

    // write width

    for ( nIndex = 0; nIndex < 4; nIndex++ )

    {

        pData[nIndex] = static_cast<sal_Int8>( aSize.Width % 0x100 );

        aSize.Width /= 0x100;

    }

    xTempOutStream->writeBytes( aData );

    // write height

    for ( nIndex = 0; nIndex < 4; nIndex++ )

    {

        pData[nIndex] = static_cast<sal_Int8>( aSize.Height % 0x100 );

        aSize.Height /= 0x100;

    }

    xTempOutStream->writeBytes( aData );

    // write garbage, it will be overwritten by the size

    xTempOutStream->writeBytes( aData );

    // write first bytes that was used to detect the type

    xTempOutStream->writeBytes( aSigData );

    // write the rest of the stream

    ::comphelper::OStorageHelper::CopyInputToOutput( xInCacheStream, xTempOutStream );

    // write the size of the stream

    sal_Int64 nLength = xTempSeek->getLength() - 40;

    if ( nLength < 0 || nLength >= 0xFFFFFFFF )

    {

        SAL_WARN( "embeddedobj.ole", "Length is not acceptable!" );

        return;

    }

    for ( sal_Int32 nInd = 0; nInd < 4; nInd++ )

    {

        pData[nInd] = static_cast<sal_Int8>( static_cast<sal_uInt64>(nLength) % 0x100 );

        nLength /= 0x100;

    }

    xTempSeek->seek( 36 );

    xTempOutStream->writeBytes( aData );

    xTempOutStream->flush();

    xTempSeek->seek( 0 );

    if ( xCachedSeek.is() )

        xCachedSeek->seek( 0 );

    // insert the result file as replacement image

    OUString aCacheName = u"\002OlePres000"_ustr;

    if ( xNameContainer->hasByName( aCacheName ) )

        xNameContainer->replaceByName( aCacheName, uno::Any( xTempFile ) );

    else

        xNameContainer->insertByName( aCacheName, uno::Any( xTempFile ) );

    uno::Reference< embed::XTransactedObject > xTransacted( xNameContainer, uno::UNO_QUERY_THROW );

    xTransacted->commit();

}

void OleEmbeddedObject::RemoveVisualCache_Impl( const uno::Reference< io::XStream >& xTargetStream )

{

    OSL_ENSURE( xTargetStream.is(), "Invalid argument!" );

    if ( !xTargetStream.is() )

        throw uno::RuntimeException();

    uno::Sequence< uno::Any > aArgs{ uno::Any(xTargetStream),

                                     uno::Any(true) }; // do not create copy

    uno::Reference< container::XNameContainer > xNameContainer(

            m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(

                    u"com.sun.star.embed.OLESimpleStorage"_ustr,

                    aArgs, m_xContext ),

            uno::UNO_QUERY_THROW );

    for ( sal_uInt8 nInd = 0; nInd < 10; nInd++ )

    {

        OUString aStreamName =  "\002OlePres00" + OUString::number( nInd );

        if ( xNameContainer->hasByName( aStreamName ) )

            xNameContainer->removeByName( aStreamName );

    }

    uno::Reference< embed::XTransactedObject > xTransacted( xNameContainer, uno::UNO_QUERY_THROW );

    xTransacted->commit();

}

void OleEmbeddedObject::SetVisReplInStream( bool bExists )

{

    m_bVisReplInitialized = true;

    m_bVisReplInStream = bExists;

}

bool OleEmbeddedObject::HasVisReplInStream()

{

    if ( !m_bVisReplInitialized )

    {

        if ( m_xCachedVisualRepresentation.is() )

            SetVisReplInStream( true );

        else

        {

            SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::HasVisualReplInStream, analyzing" );

            uno::Reference< io::XInputStream > xStream;

            OSL_ENSURE( !m_pOleComponent || !m_aTempURL.isEmpty(), "The temporary file must exist if there is a component!" );

            if ( !m_aTempURL.isEmpty() )

            {

                try

                {

                    // open temporary file for reading

                    uno::Reference < ucb::XSimpleFileAccess3 > xTempAccess(

                            ucb::SimpleFileAccess::create( m_xContext ) );

                    xStream = xTempAccess->openFileRead( m_aTempURL );

                }

                catch( const uno::Exception& )

                {}

            }

            if ( !xStream.is() )

                xStream = m_xObjectStream->getInputStream();

            if ( xStream.is() )

            {

                bool bExists = false;

                uno::Sequence< uno::Any > aArgs{ uno::Any(xStream),

                                                 uno::Any(true) }; // do not create copy

                uno::Reference< container::XNameContainer > xNameContainer(

                        m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(

                                u"com.sun.star.embed.OLESimpleStorage"_ustr,

                                aArgs, m_xContext ),

                        uno::UNO_QUERY );

                if ( xNameContainer.is() )

                {

                    for ( sal_uInt8 nInd = 0; nInd < 10 && !bExists; nInd++ )

                    {

                        OUString aStreamName = "\002OlePres00" + OUString::number( nInd );

                        try

                        {

                            bExists = xNameContainer->hasByName( aStreamName );

                        }

                        catch( const uno::Exception& )

                        {}

                    }

                }

                SetVisReplInStream( bExists );

            }

        }

    }

    return m_bVisReplInStream;

}

uno::Reference< io::XStream > OleEmbeddedObject::TryToRetrieveCachedVisualRepresentation_Impl(

        const uno::Reference< io::XStream >& xStream,

        osl::ResettableMutexGuard& rGuard,

        bool bAllowToRepair50 )

    noexcept

{

    uno::Reference< io::XStream > xResult;

    if ( xStream.is() )

    {

        SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::TryToRetrieveCachedVisualRepresentation, retrieving" );

        uno::Reference< container::XNameContainer > xNameContainer;

        uno::Sequence< uno::Any > aArgs{ uno::Any(xStream),

                                         uno::Any(true) }; // do not create copy

        try

        {

            xNameContainer.set(

                m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(

                        u"com.sun.star.embed.OLESimpleStorage"_ustr,

                        aArgs, m_xContext ),

                uno::UNO_QUERY );

        }

        catch( const uno::Exception& )

        {}

        if ( xNameContainer.is() )

        {

            for ( sal_uInt8 nInd = 0; nInd < 10; nInd++ )

            {

                OUString aStreamName =  "\002OlePres00" + OUString::number( nInd );

                uno::Reference< io::XStream > xCachedCopyStream;

                try

                {

                    if ( ( xNameContainer->getByName( aStreamName ) >>= xCachedCopyStream ) && xCachedCopyStream.is() )

                    {

                        xResult = TryToGetAcceptableFormat_Impl( xCachedCopyStream );

                        if ( xResult.is() )

                            break;

                    }

                }

                catch( const uno::Exception& )

                {}

                if ( nInd == 0 )

                {

                    // to be compatible with the old versions Ole10Native is checked after OlePress000

                    aStreamName = "\001Ole10Native";

                    try

                    {

                        if ( ( xNameContainer->getByName( aStreamName ) >>= xCachedCopyStream ) && xCachedCopyStream.is() )

                        {

                            xResult = TryToGetAcceptableFormat_Impl( xCachedCopyStream );

                            if ( xResult.is() )

                                break;

                        }

                    }

                    catch( const uno::Exception& )

                    {}

                }

            }

            try

            {

                if ( bAllowToRepair50 && !xResult.is() )

                {

                    OUString aOrigContName( u"Ole-Object"_ustr );

                    if ( xNameContainer->hasByName( aOrigContName ) )

                    {

                        uno::Reference< embed::XClassifiedObject > xClassified( xNameContainer, uno::UNO_QUERY_THROW );

                        if ( MimeConfigurationHelper::ClassIDsEqual( xClassified->getClassID(), MimeConfigurationHelper::GetSequenceClassID( SO3_OUT_CLASSID ) ) )

                        {

                            // this is an OLE object wrongly stored in 5.0 format

                            // this object must be repaired since SO7 has done it

                            uno::Reference< io::XOutputStream > xOutputStream = xStream->getOutputStream();

                            uno::Reference< io::XTruncate > xTruncate( xOutputStream, uno::UNO_QUERY_THROW );

                            uno::Reference< io::XInputStream > xOrigInputStream;

                            if ( ( xNameContainer->getByName( aOrigContName ) >>= xOrigInputStream )

                              && xOrigInputStream.is() )

                            {

                                // the provided input stream must be based on temporary medium and must be independent

                                // from the stream the storage is based on

                                uno::Reference< io::XSeekable > xOrigSeekable( xOrigInputStream, uno::UNO_QUERY );

                                if ( xOrigSeekable.is() )

                                    xOrigSeekable->seek( 0 );

                                uno::Reference< lang::XComponent > xNameContDisp( xNameContainer, uno::UNO_QUERY_THROW );

                                xNameContDisp->dispose(); // free the original stream

                                xTruncate->truncate();

                                ::comphelper::OStorageHelper::CopyInputToOutput( xOrigInputStream, xOutputStream );

                                xOutputStream->flush();

                                if ( xStream == m_xObjectStream )

                                {

                                    if ( !m_aTempURL.isEmpty() )

                                    {

                                        // this is the own stream, so the temporary URL must be cleaned if it exists

                                        KillFile_Impl( m_aTempURL, m_xContext );

                                        m_aTempURL.clear();

                                    }

#ifdef _WIN32

                                    // retry to create the component after recovering

                                    GetRidOfComponent(&rGuard);

                                    try

                                    {

                                        CreateOleComponentAndLoad_Impl();

                                        m_aClassID = m_pOleComponent->GetCLSID(); // was not set during construction

                                    }

                                    catch( const uno::Exception& )

                                    {

                                        GetRidOfComponent(&rGuard);

                                    }

#endif

                                }

                                xResult = TryToRetrieveCachedVisualRepresentation_Impl( xStream, rGuard );

                            }

                        }

                    }

                }

            }

            catch( const uno::Exception& )

            {}

        }

    }

    return xResult;

}

void OleEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,

                                              const uno::Reference< io::XStream >& xNewObjectStream,

                                              const OUString& aNewName )

{

    if ( xNewParentStorage == m_xParentStorage && aNewName == m_aEntryName )

    {

        SAL_WARN_IF( xNewObjectStream != m_xObjectStream, "embeddedobj.ole", "The streams must be the same!" );

        return;

    }

    uno::Reference<io::XSeekable> xNewSeekable(xNewObjectStream, uno::UNO_QUERY);

    if (xNewSeekable.is() && xNewSeekable->getLength() == 0)

    {

        uno::Reference<io::XSeekable> xOldSeekable(m_xObjectStream, uno::UNO_QUERY);

        if (xOldSeekable.is() && xOldSeekable->getLength() > 0)

        {

            SAL_WARN("embeddedobj.ole", "OleEmbeddedObject::SwitchOwnPersistence(stream version): "

                                        "empty new stream, reusing old one");

            uno::Reference<io::XInputStream> xInput = m_xObjectStream->getInputStream();

            uno::Reference<io::XOutputStream> xOutput = xNewObjectStream->getOutputStream();

            xOldSeekable->seek(0);

            comphelper::OStorageHelper::CopyInputToOutput(xInput, xOutput);

            xNewSeekable->seek(0);

        }

    }

    try {

        uno::Reference< lang::XComponent > xComponent( m_xObjectStream, uno::UNO_QUERY );

        OSL_ENSURE( !m_xObjectStream.is() || xComponent.is(), "Wrong stream implementation!" );

        if ( xComponent.is() )

            xComponent->dispose();

    }

    catch ( const uno::Exception& )

    {

    }

    m_xObjectStream = xNewObjectStream;

    m_xParentStorage = xNewParentStorage;

    m_aEntryName = aNewName;

}

void OleEmbeddedObject::SwitchOwnPersistence( const uno::Reference< embed::XStorage >& xNewParentStorage,

                                              const OUString& aNewName )

{

    if ( xNewParentStorage == m_xParentStorage && aNewName == m_aEntryName )

        return;

    sal_Int32 nStreamMode = m_bReadOnly ? embed::ElementModes::READ : embed::ElementModes::READWRITE;

    uno::Reference< io::XStream > xNewOwnStream = xNewParentStorage->openStreamElement( aNewName, nStreamMode );

    uno::Reference<io::XSeekable> xNewSeekable (xNewOwnStream, uno::UNO_QUERY);

    if (xNewSeekable.is() && xNewSeekable->getLength() == 0)

    {

        uno::Reference<io::XSeekable> xOldSeekable(m_xObjectStream, uno::UNO_QUERY);

        if (xOldSeekable.is() && xOldSeekable->getLength() > 0)

        {

            SAL_WARN("embeddedobj.ole", "OleEmbeddedObject::SwitchOwnPersistence: empty new stream, reusing old one");

            uno::Reference<io::XInputStream> xInput = m_xObjectStream->getInputStream();

            uno::Reference<io::XOutputStream> xOutput = xNewOwnStream->getOutputStream();

            comphelper::OStorageHelper::CopyInputToOutput(xInput, xOutput);

            xNewSeekable->seek(0);

        }

    }

    SAL_WARN_IF( !xNewOwnStream.is(), "embeddedobj.ole", "The method can not return empty reference!" );

    SwitchOwnPersistence( xNewParentStorage, xNewOwnStream, aNewName );

}

#ifdef _WIN32

bool OleEmbeddedObject::SaveObject_Impl()

{

    bool bResult = false;

    if ( m_xClientSite.is() )

    {

        try

        {

            m_xClientSite->saveObject();

            bResult = true;

        }

        catch( const uno::Exception& )

        {

        }

    }

    return bResult;

}

bool OleEmbeddedObject::OnShowWindow_Impl( bool bShow )

{

    osl::ResettableMutexGuard aGuard(m_aMutex);

    bool bResult = false;

    SAL_WARN_IF( m_nObjectState == -1, "embeddedobj.ole", "The object has no persistence!" );

    SAL_WARN_IF( m_nObjectState == embed::EmbedStates::LOADED, "embeddedobj.ole", "The object get OnShowWindow in loaded state!" );

    if ( m_nObjectState == -1 || m_nObjectState == embed::EmbedStates::LOADED )

        return false;

    // the object is either activated or deactivated

    sal_Int32 nOldState = m_nObjectState;

    if ( bShow && m_nObjectState == embed::EmbedStates::RUNNING )

    {

        m_nObjectState = embed::EmbedStates::ACTIVE;

        m_aVerbExecutionController.ObjectIsActive();

        StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );

    }

    else if ( !bShow && m_nObjectState == embed::EmbedStates::ACTIVE )

    {

        m_nObjectState = embed::EmbedStates::RUNNING;

        StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );

    }

    if ( m_xClientSite.is() )

    {

        try

        {

            ExecUnlocked([p = m_xClientSite, bShow] { p->visibilityChanged(bShow); }, aGuard);

            bResult = true;

        }

        catch( const uno::Exception& )

        {

        }

    }

    return bResult;

}

void OleEmbeddedObject::OnIconChanged_Impl()

{

    // TODO/LATER: currently this notification seems to be impossible

    // MakeEventListenerNotification_Impl( OUString( "OnIconChanged" ) );

}

void OleEmbeddedObject::OnViewChanged_Impl()

{

    osl::ResettableMutexGuard aGuard(m_aMutex);

    if ( m_bDisposed )

        throw lang::DisposedException();

    // For performance reasons the notification currently is ignored, STAMPIT object is the exception,

    // it can never be active and never call SaveObject, so it is the only way to detect that it is changed

    // ==== the STAMPIT related solution =============================

    // the following variable is used to detect whether the object was modified during verb execution

    m_aVerbExecutionController.ModificationNotificationIsDone();

    // The following things are controlled by VerbExecutionController:

    // - if the verb execution is in progress and the view is changed the object will be stored

    // after the execution, so there is no need to send the notification.

    // - the STAMPIT object can never be active.

    if (m_aVerbExecutionController.CanDoNotification() &&

            m_pOleComponent && m_nUpdateMode == embed::EmbedUpdateModes::ALWAYS_UPDATE &&

            (MimeConfigurationHelper::ClassIDsEqual(m_aClassID, MimeConfigurationHelper::GetSequenceClassID(0x852ee1c9, 0x9058, 0x44ba, 0x8c, 0x6c, 0x0c, 0x5f, 0xc6, 0x6b, 0xdb, 0x8d)) ||

             MimeConfigurationHelper::ClassIDsEqual(m_aClassID, MimeConfigurationHelper::GetSequenceClassID(0xcf1b4491, 0xbea3, 0x4c9f, 0xa7, 0x0f, 0x22, 0x1b, 0x1e, 0xca, 0xef, 0x3e)))

       )

    {

        // The view is changed while the object is in running state, save the new object

        m_xCachedVisualRepresentation.clear();

        SaveObject_Impl();

        MakeEventListenerNotification_Impl( "OnVisAreaChanged", aGuard );

    }

}

void OleEmbeddedObject::OnClosed_Impl()

{

    osl::ResettableMutexGuard aGuard(m_aMutex);

    if ( m_bDisposed )

        throw lang::DisposedException();

    if ( m_nObjectState != embed::EmbedStates::LOADED )

    {

        sal_Int32 nOldState = m_nObjectState;

        m_nObjectState = embed::EmbedStates::LOADED;

        StateChangeNotification_Impl( false, nOldState, m_nObjectState, aGuard );

    }

}

OUString OleEmbeddedObject::CreateTempURLEmpty_Impl()

{

    SAL_WARN_IF( !m_aTempURL.isEmpty(), "embeddedobj.ole", "The object has already the temporary file!" );

    m_aTempURL = GetNewTempFileURL_Impl( m_xContext );

    return m_aTempURL;

}

OUString OleEmbeddedObject::GetTempURL_Impl()

{

    if ( m_aTempURL.isEmpty() )

    {

        SAL_INFO( "embeddedobj.ole", "embeddedobj (mv76033) OleEmbeddedObject::GetTempURL_Impl, tempfile creation" );

        // if there is no temporary file, it will be created from the own entry

        uno::Reference< embed::XOptimizedStorage > xOptParStorage( m_xParentStorage, uno::UNO_QUERY );

        if ( xOptParStorage.is() )

        {

            m_aTempURL = GetNewFilledTempFile_Impl( xOptParStorage, m_aEntryName, m_xContext );

        }

        else if ( m_xObjectStream.is() )

        {

            // load object from the stream

            uno::Reference< io::XInputStream > xInStream = m_xObjectStream->getInputStream();

            if ( !xInStream.is() )

                throw io::IOException(); // TODO: access denied