wangxin/loongoffice
1
0
Fork 0
forked from amazingfate/loongoffice
Code Pull Requests Activity
Files
3d36ff1a1d94bcdb6facf12eec00a532b6640880
loongoffice/embeddedobj/source/msole/olecomponent.cxx
Miklos Vajna d5cd62164d embeddedobj: handle getting the visible area on a thread 
The Windows OLE2 implementation of the embedded object interface assumes
that the same thread is used for loading and saving the embedded
objects.

This means that in case the main thread is used for loading (e.g. from
remote UNO, but with OnMainThead=true), but a
thread is used for storing (without an explicit OnMainThead=true), then
the underlying win32 API call failed and we returned a fixed size in
EmbeddedObjectRef::GetSize().

Fix the problem by explicitly checking for RPC_E_WRONG_THREAD and adding
error handling for that case.

Change-Id: Icf1e7722d33a809fa671d1505b2a0155af040c71
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/115236
Reviewed-by: Miklos Vajna <vmiklos@collabora.com>
Tested-by: Jenkins
2021-05-07 14:21:40 +02:00

1785 lines
60 KiB
C++
Raw Blame History

/* -*- 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 <sal/config.h>
#include <com/sun/star/datatransfer/UnsupportedFlavorException.hpp>
#include <com/sun/star/lang/IllegalArgumentException.hpp>
#include <com/sun/star/lang/DisposedException.hpp>
#include <com/sun/star/embed/WrongStateException.hpp>
#include <com/sun/star/embed/UnreachableStateException.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/io/TempFile.hpp>
#include <com/sun/star/io/XTruncate.hpp>
#include <com/sun/star/io/IOException.hpp>
#include <com/sun/star/awt/XRequestCallback.hpp>
#include "platform.h"
#include <cppuhelper/interfacecontainer.h>
#include <comphelper/mimeconfighelper.hxx>
#include <comphelper/processfactory.hxx>
#include <osl/file.hxx>
#include <rtl/ref.hxx>
#include <o3tl/char16_t2wchar_t.hxx>
#include <vcl/threadex.hxx>
#include "graphconvert.hxx"
#include "olecomponent.hxx"
#include "olepersist.hxx"
#include "olewrapclient.hxx"
#include "advisesink.hxx"
#include <oleembobj.hxx>
#include "mtnotification.hxx"
#include <memory>
#include <string>
using namespace ::com::sun::star;
using namespace ::comphelper;
#define MAX_ENUM_ELE 20
#define FORMATS_NUM 3
// ============ class ComSmart =====================
namespace {
template< class T > class ComSmart
{
T* m_pInterface;
void OwnRelease()
{
if ( m_pInterface )
{
T* pInterface = m_pInterface;
m_pInterface = nullptr;
pInterface->Release();
}
}
public:
ComSmart()
: m_pInterface( nullptr )
{}
ComSmart( const ComSmart<T>& rObj )
: m_pInterface( rObj.m_pInterface )
{
if ( m_pInterface != NULL )
m_pInterface->AddRef();
}
ComSmart( T* pInterface )
: m_pInterface( pInterface )
{
if ( m_pInterface != NULL )
m_pInterface->AddRef();
}
~ComSmart()
{
OwnRelease();
}
ComSmart& operator=( const ComSmart<T>& rObj )
{
if(this == &rObj)
return *this;
OwnRelease();
m_pInterface = rObj.m_pInterface;
if ( m_pInterface != NULL )
m_pInterface->AddRef();
return *this;
}
ComSmart<T>& operator=( T* pInterface )
{
OwnRelease();
m_pInterface = pInterface;
if ( m_pInterface != NULL )
m_pInterface->AddRef();
return *this;
}
operator T*() const
{
return m_pInterface;
}
T& operator*() const
{
return *m_pInterface;
}
T** operator&()
{
OwnRelease();
m_pInterface = nullptr;
return &m_pInterface;
}
T* operator->() const
{
return m_pInterface;
}
bool operator==( const ComSmart<T>& rObj ) const
{
return ( m_pInterface == rObj.m_pInterface );
}
bool operator!=( const ComSmart<T>& rObj ) const
{
return ( m_pInterface != rObj.m_pInterface );
}
bool operator==( const T* pInterface ) const
{
return ( m_pInterface == pInterface );
}
bool operator!=( const T* pInterface ) const
{
return ( m_pInterface != pInterface );
}
};
}
// ============ class ComSmart =====================
typedef std::vector< FORMATETC* > FormatEtcList;
FORMATETC const pFormatTemplates[FORMATS_NUM] = {
{ CF_ENHMETAFILE, nullptr, 0, -1, TYMED_ENHMF },
{ CF_METAFILEPICT, nullptr, 0, -1, TYMED_MFPICT },
{ CF_BITMAP, nullptr, 0, -1, TYMED_GDI } };
struct OleComponentNative_Impl {
ComSmart< IUnknown > m_pObj;
ComSmart< IOleObject > m_pOleObject;
ComSmart< IViewObject2 > m_pViewObject2;
ComSmart< IStorage > m_pIStorage;
FormatEtcList m_aFormatsList;
uno::Sequence< datatransfer::DataFlavor > m_aSupportedGraphFormats;
OleComponentNative_Impl()
{
// TODO: Extend format list
m_aSupportedGraphFormats.realloc( 5 );
m_aSupportedGraphFormats[0] = datatransfer::DataFlavor(
"application/x-openoffice-emf;windows_formatname=\"Image EMF\"",
"Windows Enhanced Metafile",
cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
m_aSupportedGraphFormats[1] = datatransfer::DataFlavor(
"application/x-openoffice-wmf;windows_formatname=\"Image WMF\"",
"Windows Metafile",
cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
m_aSupportedGraphFormats[2] = datatransfer::DataFlavor(
"application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"",
"Bitmap",
cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
m_aSupportedGraphFormats[3] = datatransfer::DataFlavor(
"image/png",
"PNG",
cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
m_aSupportedGraphFormats[0] = datatransfer::DataFlavor(
"application/x-openoffice-gdimetafile;windows_formatname=\"GDIMetaFile\"",
"GDIMetafile",
cppu::UnoType<uno::Sequence< sal_Int8 >>::get() );
}
bool ConvertDataForFlavor( const STGMEDIUM& aMedium,
const datatransfer::DataFlavor& aFlavor,
uno::Any& aResult );
bool GraphicalFlavor( const datatransfer::DataFlavor& aFlavor );
uno::Sequence< datatransfer::DataFlavor > GetFlavorsForAspects( sal_uInt32 nSupportedAspects );
};
static DWORD GetAspectFromFlavor( const datatransfer::DataFlavor& aFlavor )
{
if ( aFlavor.MimeType.indexOf( ";Aspect=THUMBNAIL" ) != -1 )
return DVASPECT_THUMBNAIL;
else if ( aFlavor.MimeType.indexOf( ";Aspect=ICON" ) != -1 )
return DVASPECT_ICON;
else if ( aFlavor.MimeType.indexOf( ";Aspect=DOCPRINT" ) != -1 )
return DVASPECT_DOCPRINT;
else
return DVASPECT_CONTENT;
}
static OUString GetFlavorSuffixFromAspect( DWORD nAsp )
{
OUString aResult;
if ( nAsp == DVASPECT_THUMBNAIL )
aResult = ";Aspect=THUMBNAIL";
else if ( nAsp == DVASPECT_ICON )
aResult = ";Aspect=ICON";
else if ( nAsp == DVASPECT_DOCPRINT )
aResult = ";Aspect=DOCPRINT";
// no suffix for DVASPECT_CONTENT
return aResult;
}
static HRESULT OpenIStorageFromURL_Impl( const OUString& aURL, IStorage** ppIStorage )
{
OSL_ENSURE( ppIStorage, "The pointer must not be empty!" );
OUString aFilePath;
if ( !ppIStorage || ::osl::FileBase::getSystemPathFromFileURL( aURL, aFilePath ) != ::osl::FileBase::E_None )
throw uno::RuntimeException(); // TODO: something dangerous happened
return StgOpenStorage( o3tl::toW(aFilePath.getStr()),
nullptr,
STGM_READWRITE | STGM_TRANSACTED, // | STGM_DELETEONRELEASE,
nullptr,
0,
ppIStorage );
}
bool OleComponentNative_Impl::ConvertDataForFlavor( const STGMEDIUM& aMedium,
const datatransfer::DataFlavor& aFlavor,
uno::Any& aResult )
{
bool bAnyIsReady = false;
// try to convert data from Medium format to specified Flavor format
if ( aFlavor.DataType == cppu::UnoType<uno::Sequence< sal_Int8 >>::get() )
{
// first the GDI-metafile must be generated
std::unique_ptr<sal_Int8[]> pBuf;
sal_uInt32 nBufSize = 0;
OUString aFormat;
if ( aMedium.tymed == TYMED_MFPICT ) // Win Metafile
{
aFormat = "image/x-wmf";
METAFILEPICT* pMF = static_cast<METAFILEPICT*>(GlobalLock( aMedium.hMetaFilePict ));
if ( pMF )
{
nBufSize = GetMetaFileBitsEx( pMF->hMF, 0, nullptr ) + 22;
pBuf.reset(new sal_Int8[nBufSize]);
// TODO/LATER: the unit size must be calculated correctly
*reinterpret_cast<long*>( pBuf.get() ) = 0x9ac6cdd7L;
*reinterpret_cast<short*>( pBuf.get()+6 ) = SHORT(0);
*reinterpret_cast<short*>( pBuf.get()+8 ) = SHORT(0);
*reinterpret_cast<short*>( pBuf.get()+10 ) = static_cast<SHORT>(pMF->xExt);
*reinterpret_cast<short*>( pBuf.get()+12 ) = static_cast<SHORT>(pMF->yExt);
*reinterpret_cast<short*>( pBuf.get()+14 ) = USHORT(2540);
if ( nBufSize && nBufSize == GetMetaFileBitsEx( pMF->hMF, nBufSize - 22, pBuf.get() + 22 ) )
{
if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-wmf;windows_formatname=\"Image WMF\"", 57 ) )
{
aResult <<= uno::Sequence< sal_Int8 >( pBuf.get(), nBufSize );
bAnyIsReady = true;
}
}
GlobalUnlock( aMedium.hMetaFilePict );
}
}
else if ( aMedium.tymed == TYMED_ENHMF ) // Enh Metafile
{
aFormat = "image/x-emf";
nBufSize = GetEnhMetaFileBits( aMedium.hEnhMetaFile, 0, nullptr );
pBuf.reset(new sal_Int8[nBufSize]);
if ( nBufSize && nBufSize == GetEnhMetaFileBits( aMedium.hEnhMetaFile, nBufSize, reinterpret_cast<LPBYTE>(pBuf.get()) ) )
{
if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-emf;windows_formatname=\"Image EMF\"", 57 ) )
{
aResult <<= uno::Sequence< sal_Int8 >( pBuf.get(), nBufSize );
bAnyIsReady = true;
}
}
}
else if ( aMedium.tymed == TYMED_GDI ) // Bitmap
{
aFormat = "image/x-MS-bmp";
// Find out size of buffer: deprecated GetBitmapBits does not have a mode to return
// required buffer size
BITMAP aBmp;
GetObjectW(aMedium.hBitmap, sizeof(aBmp), &aBmp);
nBufSize = aBmp.bmWidthBytes * aBmp.bmHeight;
pBuf.reset(new sal_Int8[nBufSize]);
if ( nBufSize && nBufSize == sal::static_int_cast< ULONG >( GetBitmapBits( aMedium.hBitmap, nBufSize, pBuf.get() ) ) )
{
if ( aFlavor.MimeType.matchAsciiL( "application/x-openoffice-bitmap;windows_formatname=\"Bitmap\"", 54 ) )
{
aResult <<= uno::Sequence< sal_Int8 >( pBuf.get(), nBufSize );
bAnyIsReady = true;
}
}
}
if ( pBuf && !bAnyIsReady )
{
for ( auto const & supportedFormat : std::as_const(m_aSupportedGraphFormats) )
if ( aFlavor.MimeType.match( supportedFormat.MimeType )
&& aFlavor.DataType == supportedFormat.DataType
&& aFlavor.DataType == cppu::UnoType<uno::Sequence< sal_Int8 >>::get() )
{
bAnyIsReady = ConvertBufferToFormat( pBuf.get(), nBufSize, aFormat, aResult );
break;
}
}
}
return bAnyIsReady;
}
bool OleComponentNative_Impl::GraphicalFlavor( const datatransfer::DataFlavor& aFlavor )
{
// Actually all the required graphical formats must be supported
for ( auto const & supportedFormat : std::as_const(m_aSupportedGraphFormats) )
if ( aFlavor.MimeType.match( supportedFormat.MimeType )
&& aFlavor.DataType == supportedFormat.DataType )
return true;
return false;
}
static bool GetClassIDFromSequence_Impl( uno::Sequence< sal_Int8 > const & aSeq, CLSID& aResult )
{
if ( aSeq.getLength() == 16 )
{
aResult.Data1 = ( ( ( ( ( static_cast<sal_uInt8>(aSeq[0]) << 8 ) + static_cast<sal_uInt8>(aSeq[1]) ) << 8 ) + static_cast<sal_uInt8>(aSeq[2]) ) << 8 ) + static_cast<sal_uInt8>(aSeq[3]);
aResult.Data2 = ( static_cast<sal_uInt8>(aSeq[4]) << 8 ) + static_cast<sal_uInt8>(aSeq[5]);
aResult.Data3 = ( static_cast<sal_uInt8>(aSeq[6]) << 8 ) + static_cast<sal_uInt8>(aSeq[7]);
for( int nInd = 0; nInd < 8; nInd++ )
aResult.Data4[nInd] = static_cast<sal_uInt8>(aSeq[nInd+8]);
return true;
}
return false;
}
static OUString WinAccToVcl_Impl( const sal_Unicode* pStr )
{
OUString aResult;
if( pStr )
{
while ( *pStr )
{
if ( *pStr == '&' )
{
aResult += "~";
while( *( ++pStr ) == '&' );
}
else
{
aResult += OUString( pStr, 1 );
pStr++;
}
}
}
return aResult;
}
OleComponent::OleComponent( const uno::Reference< uno::XComponentContext >& xContext, OleEmbeddedObject* pUnoOleObject )
: m_pInterfaceContainer( nullptr )
, m_bDisposed( false )
, m_bModified( false )
, m_pNativeImpl( new OleComponentNative_Impl() )
, m_pUnoOleObject( pUnoOleObject )
, m_pOleWrapClientSite( nullptr )
, m_pImplAdviseSink( nullptr )
, m_nOLEMiscFlags( 0 )
, m_nAdvConn( 0 )
, m_xContext( xContext )
, m_bOleInitialized( false )
, m_bWorkaroundActive( false )
{
OSL_ENSURE( m_pUnoOleObject, "No owner object is provided!" );
HRESULT hr = OleInitialize( nullptr );
OSL_ENSURE( hr == S_OK || hr == S_FALSE, "The ole can not be successfully initialized" );
if ( hr == S_OK || hr == S_FALSE )
m_bOleInitialized = true;
m_pOleWrapClientSite = new OleWrapperClientSite( this );
m_pOleWrapClientSite->AddRef();
m_pImplAdviseSink = new OleWrapperAdviseSink( this );
m_pImplAdviseSink->AddRef();
}
OleComponent::~OleComponent()
{
OSL_ENSURE( !m_pOleWrapClientSite && !m_pImplAdviseSink && !m_pInterfaceContainer && !m_bOleInitialized,
"The object was not closed successfully! DISASTER is possible!" );
if ( m_pOleWrapClientSite || m_pImplAdviseSink || m_pInterfaceContainer || m_bOleInitialized )
{
osl_atomic_increment(&m_refCount);
try {
Dispose();
} catch( const uno::Exception& ) {}
}
for (auto const& format : m_pNativeImpl->m_aFormatsList)
{
delete format;
}
m_pNativeImpl->m_aFormatsList.clear();
delete m_pNativeImpl;
}
void OleComponent::Dispose()
{
if ( m_bDisposed )
return;
// Call CloseObject() without m_aMutex locked, since it will call
// IOleObject::Close(), which can call event listeners, which can run on a
// different thread.
CloseObject();
osl::MutexGuard aGuard(m_aMutex);
if ( m_pOleWrapClientSite )
{
m_pOleWrapClientSite->disconnectOleComponent();
m_pOleWrapClientSite->Release();
m_pOleWrapClientSite = nullptr;
}
if ( m_pImplAdviseSink )
{
m_pImplAdviseSink->disconnectOleComponent();
m_pImplAdviseSink->Release();
m_pImplAdviseSink = nullptr;
}
if ( m_pInterfaceContainer )
{
lang::EventObject aEvent( static_cast< ::cppu::OWeakObject* >( this ) );
m_pInterfaceContainer->disposeAndClear( aEvent );
delete m_pInterfaceContainer;
m_pInterfaceContainer = nullptr;
}
if ( m_bOleInitialized )
{
// since the disposing can happen not only from main thread but also from a clipboard
// the deinitialization might lead to a disaster, SO7 does not deinitialize OLE at all
// so currently the same approach is selected as workaround
// OleUninitialize();
m_bOleInitialized = false;
}
m_bDisposed = true;
}
void OleComponent::disconnectEmbeddedObject()
{
// must not be called from destructor of UNO OLE object!!!
osl::MutexGuard aGuard( m_aMutex );
m_pUnoOleObject = nullptr;
}
void OleComponent::CreateNewIStorage_Impl()
{
// TODO: in future a global memory could be used instead of file.
// write the stream to the temporary file
OUString aTempURL;
OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" );
if ( m_pUnoOleObject )
aTempURL = m_pUnoOleObject->CreateTempURLEmpty_Impl();
else
aTempURL = GetNewTempFileURL_Impl( m_xContext );
if ( !aTempURL.getLength() )
throw uno::RuntimeException(); // TODO
// open an IStorage based on the temporary file
OUString aTempFilePath;
if ( ::osl::FileBase::getSystemPathFromFileURL( aTempURL, aTempFilePath ) != ::osl::FileBase::E_None )
throw uno::RuntimeException(); // TODO: something dangerous happened
HRESULT hr = StgCreateDocfile( o3tl::toW(aTempFilePath.getStr()), STGM_CREATE | STGM_READWRITE | STGM_TRANSACTED | STGM_DELETEONRELEASE, 0, &m_pNativeImpl->m_pIStorage );
if ( FAILED( hr ) || !m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO: transport error code?
}
uno::Sequence< datatransfer::DataFlavor > OleComponentNative_Impl::GetFlavorsForAspects( sal_uInt32 nSupportedAspects )
{
uno::Sequence< datatransfer::DataFlavor > aResult;
for ( sal_uInt32 nAsp = 1; nAsp <= 8; nAsp *= 2 )
if ( ( nSupportedAspects & nAsp ) == nAsp )
{
OUString aAspectSuffix = GetFlavorSuffixFromAspect( nAsp );
sal_Int32 nLength = aResult.getLength();
aResult.realloc( nLength + m_aSupportedGraphFormats.getLength() );
for ( sal_Int32 nInd = 0; nInd < m_aSupportedGraphFormats.getLength(); nInd++ )
{
aResult[nLength + nInd].MimeType = m_aSupportedGraphFormats[nInd].MimeType + aAspectSuffix;
aResult[nLength + nInd].HumanPresentableName = m_aSupportedGraphFormats[nInd].HumanPresentableName;
aResult[nLength + nInd].DataType = m_aSupportedGraphFormats[nInd].DataType;
}
}
return aResult;
}
void OleComponent::RetrieveObjectDataFlavors_Impl()
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
if ( !m_aDataFlavors.getLength() )
{
ComSmart< IDataObject > pDataObject;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pDataObject) );
if ( SUCCEEDED( hr ) && pDataObject )
{
ComSmart< IEnumFORMATETC > pFormatEnum;
hr = pDataObject->EnumFormatEtc( DATADIR_GET, &pFormatEnum );
if ( SUCCEEDED( hr ) && pFormatEnum )
{
FORMATETC pElem[ MAX_ENUM_ELE ];
ULONG nNum = 0;
// if it is possible to retrieve at least one supported graphical format for an aspect
// this format can be converted to other supported formats
sal_uInt32 nSupportedAspects = 0;
do
{
HRESULT hr2 = pFormatEnum->Next( MAX_ENUM_ELE, pElem, &nNum );
if( hr2 == S_OK || hr2 == S_FALSE )
{
for( sal_uInt32 nInd = 0; nInd < FORMATS_NUM; nInd++ )
{
if ( pElem[nInd].cfFormat == pFormatTemplates[nInd].cfFormat
&& pElem[nInd].tymed == pFormatTemplates[nInd].tymed )
nSupportedAspects |= pElem[nInd].dwAspect;
}
}
else
break;
}
while( nNum == MAX_ENUM_ELE );
m_aDataFlavors = m_pNativeImpl->GetFlavorsForAspects( nSupportedAspects );
}
}
if ( !m_aDataFlavors.getLength() )
{
// TODO:
// for any reason the object could not provide this information
// try to get access to the cached representation
}
}
}
bool OleComponent::InitializeObject_Impl()
// There will be no static objects!
{
if ( !m_pNativeImpl->m_pObj )
return false;
// the linked object will be detected here
ComSmart< IOleLink > pOleLink;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IOleLink, reinterpret_cast<void**>(&pOleLink) );
OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" );
if ( m_pUnoOleObject )
m_pUnoOleObject->SetObjectIsLink_Impl( pOleLink != nullptr );
hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IViewObject2, reinterpret_cast<void**>(&m_pNativeImpl->m_pViewObject2) );
if ( FAILED( hr ) || !m_pNativeImpl->m_pViewObject2 )
return false;
// remove all the caches
IOleCache* pIOleCache = nullptr;
if ( SUCCEEDED( m_pNativeImpl->m_pObj->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ) ) && pIOleCache )
{
IEnumSTATDATA* pEnumSD = nullptr;
HRESULT hr2 = pIOleCache->EnumCache( &pEnumSD );
if ( SUCCEEDED( hr2 ) && pEnumSD )
{
pEnumSD->Reset();
STATDATA aSD;
DWORD nNum;
while( SUCCEEDED( pEnumSD->Next( 1, &aSD, &nNum ) ) && nNum == 1 )
hr2 = pIOleCache->Uncache( aSD.dwConnection );
}
// No IDataObject implementation, caching must be used instead
DWORD nConn;
FORMATETC aFormat = { 0, nullptr, DVASPECT_CONTENT, -1, TYMED_MFPICT };
hr2 = pIOleCache->Cache( &aFormat, ADVFCACHE_ONSAVE, &nConn );
pIOleCache->Release();
pIOleCache = nullptr;
}
hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&m_pNativeImpl->m_pOleObject) );
if ( FAILED( hr ) || !m_pNativeImpl->m_pOleObject )
return false; // Static objects are not supported, they should be inserted as graphics
m_pNativeImpl->m_pOleObject->GetMiscStatus( DVASPECT_CONTENT, reinterpret_cast<DWORD*>(&m_nOLEMiscFlags) );
// TODO: use other misc flags also
// the object should have drawable aspect even in case it supports only iconic representation
// if ( m_nOLEMiscFlags & OLEMISC_ONLYICONIC )
m_pNativeImpl->m_pOleObject->SetClientSite( m_pOleWrapClientSite );
// the only need in this registration is workaround for close notification
m_pNativeImpl->m_pOleObject->Advise( m_pImplAdviseSink, reinterpret_cast<DWORD*>(&m_nAdvConn) );
m_pNativeImpl->m_pViewObject2->SetAdvise( DVASPECT_CONTENT, 0, m_pImplAdviseSink );
OleSetContainedObject( m_pNativeImpl->m_pOleObject, TRUE );
return true;
}
namespace
{
HRESULT OleLoadSeh(LPSTORAGE pIStorage, LPVOID* ppObj)
{
HRESULT hr = E_FAIL;
__try {
hr = OleLoad(pIStorage, IID_IUnknown, nullptr, ppObj);
} __except( EXCEPTION_EXECUTE_HANDLER ) {
return E_FAIL;
}
return hr;
}
}
void OleComponent::LoadEmbeddedObject( const OUString& aTempURL )
{
if ( !aTempURL.getLength() )
throw lang::IllegalArgumentException(); // TODO
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO the object is already initialized or wrong initialization is done
// open an IStorage based on the temporary file
HRESULT hr = OpenIStorageFromURL_Impl( aTempURL, &m_pNativeImpl->m_pIStorage );
if ( FAILED( hr ) || !m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO: transport error code?
hr = OleLoadSeh(m_pNativeImpl->m_pIStorage, reinterpret_cast<void**>(&m_pNativeImpl->m_pObj));
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
{
throw uno::RuntimeException();
}
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
}
void OleComponent::CreateObjectFromClipboard()
{
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO:the object is already initialized
CreateNewIStorage_Impl();
if ( !m_pNativeImpl->m_pIStorage )
throw uno::RuntimeException(); // TODO
IDataObject * pDO = nullptr;
HRESULT hr = OleGetClipboard( &pDO );
if( SUCCEEDED( hr ) && pDO )
{
hr = OleQueryCreateFromData( pDO );
if( S_OK == GetScode( hr ) )
{
hr = OleCreateFromData( pDO,
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr, // &aFormat,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
}
else
{
// Static objects are not supported
pDO->Release();
}
}
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
throw uno::RuntimeException();
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
}
void OleComponent::CreateNewEmbeddedObject( const uno::Sequence< sal_Int8 >& aSeqCLSID )
{
CLSID aClsID;
if ( !GetClassIDFromSequence_Impl( aSeqCLSID, aClsID ) )
throw lang::IllegalArgumentException(); // TODO
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO:the object is already initialized
CreateNewIStorage_Impl();
if ( !m_pNativeImpl->m_pIStorage )
throw uno::RuntimeException(); // TODO
// FORMATETC aFormat = { CF_METAFILEPICT, NULL, nAspect, -1, TYMED_MFPICT }; // for OLE..._DRAW should be NULL
HRESULT hr = OleCreate( aClsID,
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr, // &aFormat,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
throw uno::RuntimeException(); // TODO
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
// TODO: getExtent???
}
void OleComponent::CreateObjectFromData( const uno::Reference< datatransfer::XTransferable >& )
// Static objects are not supported, they should be inserted as graphics
{
// TODO: May be this call is useless since there are no static objects
// and nonstatic objects will be created based on OLEstorage ( stream ).
// ???
// OleQueryCreateFromData...
}
void OleComponent::CreateObjectFromFile( const OUString& aFileURL )
{
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO:the object is already initialized
CreateNewIStorage_Impl();
if ( !m_pNativeImpl->m_pIStorage )
throw uno::RuntimeException(); // TODO:
OUString aFilePath;
if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None )
throw uno::RuntimeException(); // TODO: something dangerous happened
HRESULT hr = OleCreateFromFile( CLSID_NULL,
o3tl::toW(aFilePath.getStr()),
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
throw uno::RuntimeException(); // TODO
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
}
void OleComponent::CreateLinkFromFile( const OUString& aFileURL )
{
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO:the object is already initialized
CreateNewIStorage_Impl();
if ( !m_pNativeImpl->m_pIStorage )
throw uno::RuntimeException(); // TODO:
OUString aFilePath;
if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None )
throw uno::RuntimeException(); // TODO: something dangerous happened
HRESULT hr = OleCreateLinkToFile( o3tl::toW(aFilePath.getStr()),
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
throw uno::RuntimeException(); // TODO
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
}
void OleComponent::InitEmbeddedCopyOfLink( rtl::Reference<OleComponent> const & pOleLinkComponent )
{
if ( !pOleLinkComponent || !pOleLinkComponent->m_pNativeImpl->m_pObj )
throw lang::IllegalArgumentException(); // TODO
if ( m_pNativeImpl->m_pIStorage )
throw io::IOException(); // TODO:the object is already initialized
ComSmart< IDataObject > pDataObject;
HRESULT hr = pOleLinkComponent->m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pDataObject) );
if ( SUCCEEDED( hr ) && pDataObject && SUCCEEDED( OleQueryCreateFromData( pDataObject ) ) )
{
// the object must be already disconnected from the temporary URL
CreateNewIStorage_Impl();
if ( !m_pNativeImpl->m_pIStorage )
throw uno::RuntimeException(); // TODO:
hr = OleCreateFromData( pDataObject,
IID_IUnknown,
OLERENDER_DRAW,
nullptr,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
}
if ( !m_pNativeImpl->m_pObj )
{
ComSmart< IOleLink > pOleLink;
hr = pOleLinkComponent->m_pNativeImpl->m_pObj->QueryInterface( IID_IOleLink, reinterpret_cast<void**>(&pOleLink) );
if ( FAILED( hr ) || !pOleLink )
throw io::IOException(); // TODO: the object doesn't support IOleLink
ComSmart< IMoniker > pMoniker;
hr = pOleLink->GetSourceMoniker( &pMoniker );
if ( FAILED( hr ) || !pMoniker )
throw io::IOException(); // TODO: can not retrieve moniker
// In case of file moniker life is easy : )
DWORD aMonType = 0;
hr = pMoniker->IsSystemMoniker( &aMonType );
if ( SUCCEEDED( hr ) && aMonType == MKSYS_FILEMONIKER )
{
ComSmart< IMalloc > pMalloc;
hr = CoGetMalloc( 1, &pMalloc ); // if fails there will be a memory leak
OSL_ENSURE(SUCCEEDED(hr) && pMalloc, "CoGetMalloc() failed!");
LPOLESTR pOleStr = nullptr;
hr = pOleLink->GetSourceDisplayName( &pOleStr );
if ( SUCCEEDED( hr ) && pOleStr )
{
std::wstring aFilePath( pOleStr );
if ( pMalloc )
pMalloc->Free( pOleStr );
hr = OleCreateFromFile( CLSID_NULL,
aFilePath.c_str(),
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr,
nullptr,
m_pNativeImpl->m_pIStorage,
reinterpret_cast<void**>(&m_pNativeImpl->m_pObj) );
}
}
// in case of other moniker types the only way is to get storage
if ( !m_pNativeImpl->m_pObj )
{
ComSmart< IBindCtx > pBindCtx;
hr = CreateBindCtx( 0, &pBindCtx );
if ( SUCCEEDED( hr ) && pBindCtx )
{
ComSmart< IStorage > pObjectStorage;
hr = pMoniker->BindToStorage( pBindCtx, nullptr, IID_IStorage, reinterpret_cast<void**>(&pObjectStorage) );
if ( SUCCEEDED( hr ) && pObjectStorage )
{
hr = pObjectStorage->CopyTo( 0, nullptr, nullptr, m_pNativeImpl->m_pIStorage );
if ( SUCCEEDED( hr ) )
hr = OleLoadSeh(m_pNativeImpl->m_pIStorage, reinterpret_cast<void**>(&m_pNativeImpl->m_pObj));
}
}
}
}
// If object could not be created the only way is to use graphical representation
if ( FAILED( hr ) || !m_pNativeImpl->m_pObj )
throw uno::RuntimeException(); // TODO
if ( !InitializeObject_Impl() )
throw uno::RuntimeException(); // TODO
}
void OleComponent::RunObject()
{
OSL_ENSURE( m_pNativeImpl->m_pOleObject, "The pointer can not be set to NULL here!" );
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
if ( !OleIsRunning( m_pNativeImpl->m_pOleObject ) )
{
HRESULT hr = OleRun( m_pNativeImpl->m_pObj );
if ( FAILED( hr ) )
{
if ( hr == REGDB_E_CLASSNOTREG )
throw embed::UnreachableStateException(); // the object server is not installed
else
throw io::IOException();
}
}
}
awt::Size OleComponent::CalculateWithFactor( const awt::Size& aSize,
const awt::Size& aMultiplier,
const awt::Size& aDivisor )
{
awt::Size aResult;
sal_Int64 nWidth = static_cast<sal_Int64>(aSize.Width) * static_cast<sal_Int64>(aMultiplier.Width) / static_cast<sal_Int64>(aDivisor.Width);
sal_Int64 nHeight = static_cast<sal_Int64>(aSize.Height) * static_cast<sal_Int64>(aMultiplier.Height) / static_cast<sal_Int64>(aDivisor.Height);
OSL_ENSURE( nWidth < SAL_MAX_INT32 && nWidth > SAL_MIN_INT32
&& nHeight < SAL_MAX_INT32 && nHeight > SAL_MIN_INT32,
"Unacceptable result size!" );
aResult.Width = static_cast<sal_Int32>(nWidth);
aResult.Height = static_cast<sal_Int32>(nHeight);
return aResult;
}
void OleComponent::CloseObject()
{
if ( m_pNativeImpl->m_pOleObject && OleIsRunning( m_pNativeImpl->m_pOleObject ) )
m_pNativeImpl->m_pOleObject->Close( OLECLOSE_NOSAVE ); // must be saved before
}
uno::Sequence< embed::VerbDescriptor > OleComponent::GetVerbList()
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
if( !m_aVerbList.getLength() )
{
ComSmart< IEnumOLEVERB > pEnum;
if( SUCCEEDED( m_pNativeImpl->m_pOleObject->EnumVerbs( &pEnum ) ) )
{
OLEVERB szEle[ MAX_ENUM_ELE ];
ULONG nNum = 0;
sal_Int32 nSeqSize = 0;
do
{
HRESULT hr = pEnum->Next( MAX_ENUM_ELE, szEle, &nNum );
if( hr == S_OK || hr == S_FALSE )
{
m_aVerbList.realloc( nSeqSize += nNum );
for( sal_uInt32 nInd = 0; nInd < nNum; nInd++ )
{
m_aVerbList[nSeqSize-nNum+nInd].VerbID = szEle[ nInd ].lVerb;
m_aVerbList[nSeqSize-nNum+nInd].VerbName = WinAccToVcl_Impl( o3tl::toU(szEle[ nInd ].lpszVerbName) );
m_aVerbList[nSeqSize-nNum+nInd].VerbFlags = szEle[ nInd ].fuFlags;
m_aVerbList[nSeqSize-nNum+nInd].VerbAttributes = szEle[ nInd ].grfAttribs;
}
}
else
break;
}
while( nNum == MAX_ENUM_ELE );
}
}
return m_aVerbList;
}
void OleComponent::ExecuteVerb( sal_Int32 nVerbID )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO
HRESULT hr = OleRun( m_pNativeImpl->m_pOleObject );
if ( FAILED( hr ) )
throw io::IOException(); // TODO: a specific exception that transport error code can be thrown here
// TODO: probably extents should be set here and stored in aRect
// TODO: probably the parent window also should be set
hr = m_pNativeImpl->m_pOleObject->DoVerb( nVerbID, nullptr, m_pOleWrapClientSite, 0, nullptr, nullptr );
if ( FAILED( hr ) )
throw io::IOException(); // TODO
}
void OleComponent::SetHostName( const OUString& aEmbDocName )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
m_pNativeImpl->m_pOleObject->SetHostNames( L"app name", o3tl::toW( aEmbDocName.getStr() ) );
}
void OleComponent::SetExtent( const awt::Size& aVisAreaSize, sal_Int64 nAspect )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nMSAspect = static_cast<DWORD>(nAspect); // first 32 bits are for MS aspects
SIZEL aSize = { aVisAreaSize.Width, aVisAreaSize.Height };
HRESULT hr = m_pNativeImpl->m_pOleObject->SetExtent( nMSAspect, &aSize );
if ( FAILED( hr ) )
{
// TODO/LATER: is it correct? In future user code probably should be ready for the exception.
// if the object is running but not activated, RPC_E_SERVER_DIED error code is returned by OLE package
// in this case just do nothing
// Also Visio returns E_FAIL on resize if it is in running state
// if ( hr != RPC_E_SERVER_DIED )
throw io::IOException(); // TODO
}
}
awt::Size OleComponent::GetExtent( sal_Int64 nAspect )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nMSAspect = static_cast<DWORD>(nAspect); // first 32 bits are for MS aspects
awt::Size aSize;
bool bGotSize = false;
if ( nMSAspect == DVASPECT_CONTENT )
{
// Try to get the size from the replacement image first
ComSmart< IDataObject > pDataObject;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pDataObject) );
if ( SUCCEEDED( hr ) || pDataObject )
{
STGMEDIUM aMedium;
FORMATETC aFormat = pFormatTemplates[1]; // use windows metafile format
aFormat.dwAspect = nMSAspect;
hr = pDataObject->GetData( &aFormat, &aMedium );
if (hr == RPC_E_WRONG_THREAD)
{
// Assume that the OLE object was loaded on the main thread.
vcl::solarthread::syncExecute([this, &hr, &pDataObject, &aFormat, &aMedium]() {
// Make sure that the current state is embed::EmbedStates::RUNNING.
RunObject();
// Now try again on the correct thread.
hr = pDataObject->GetData(&aFormat, &aMedium);
});
}
if ( SUCCEEDED( hr ) && aMedium.tymed == TYMED_MFPICT ) // Win Metafile
{
METAFILEPICT* pMF = static_cast<METAFILEPICT*>(GlobalLock( aMedium.hMetaFilePict ));
if ( pMF )
{
// the object uses 0.01 mm as unit, so the metafile size should be converted to object unit
sal_Int64 nMult = 1;
sal_Int64 nDiv = 1;
switch( pMF->mm )
{
case MM_HIENGLISH:
nMult = 254;
nDiv = 100;
break;
case MM_LOENGLISH:
nMult = 254;
nDiv = 10;
break;
case MM_LOMETRIC:
nMult = 10;
break;
case MM_TWIPS:
nMult = 254;
nDiv = 144;
break;
case MM_ISOTROPIC:
case MM_ANISOTROPIC:
case MM_HIMETRIC:
// do nothing
break;
}
sal_Int64 nX = static_cast<sal_Int64>(abs( pMF->xExt )) * nMult / nDiv;
sal_Int64 nY = static_cast<sal_Int64>(abs( pMF->yExt )) * nMult / nDiv;
if ( nX < SAL_MAX_INT32 && nY < SAL_MAX_INT32 )
{
aSize.Width = static_cast<sal_Int32>(nX);
aSize.Height = static_cast<sal_Int32>(nY);
bGotSize = true;
}
else
OSL_FAIL( "Unexpected size is provided!" );
}
}
else if (!SUCCEEDED(hr))
{
SAL_WARN("embeddedobj.ole", " OleComponent::GetExtent: GetData() failed");
}
// i113605, to release storage medium
if ( SUCCEEDED( hr ) )
::ReleaseStgMedium(&aMedium);
}
}
if ( !bGotSize )
throw lang::IllegalArgumentException();
return aSize;
}
awt::Size OleComponent::GetCachedExtent( sal_Int64 nAspect )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nMSAspect = static_cast<DWORD>(nAspect); // first 32 bits are for MS aspects
SIZEL aSize;
HRESULT hr = m_pNativeImpl->m_pViewObject2->GetExtent( nMSAspect, -1, nullptr, &aSize );
if ( FAILED( hr ) )
{
// TODO/LATER: is it correct?
// if there is no appropriate cache for the aspect, OLE_E_BLANK error code is returned
// if ( hr == OLE_E_BLANK )
// throw lang::IllegalArgumentException();
//else
// throw io::IOException(); // TODO
SAL_WARN("embeddedobj.ole", " OleComponent::GetCachedExtent: GetExtent() failed");
throw lang::IllegalArgumentException();
}
return awt::Size( aSize.cx, aSize.cy );
}
awt::Size OleComponent::GetRecommendedExtent( sal_Int64 nAspect )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nMSAspect = static_cast<DWORD>(nAspect); // first 32 bits are for MS aspects
SIZEL aSize;
HRESULT hr = m_pNativeImpl->m_pOleObject->GetExtent( nMSAspect, &aSize );
if ( FAILED( hr ) )
{
SAL_WARN("embeddedobj.ole", " OleComponent::GetRecommendedExtent: GetExtent() failed");
throw lang::IllegalArgumentException();
}
return awt::Size( aSize.cx, aSize.cy );
}
sal_Int64 OleComponent::GetMiscStatus( sal_Int64 nAspect )
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nResult;
m_pNativeImpl->m_pOleObject->GetMiscStatus( static_cast<DWORD>(nAspect), &nResult );
return static_cast<sal_Int64>(nResult); // first 32 bits are for MS flags
}
uno::Sequence< sal_Int8 > OleComponent::GetCLSID()
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
GUID aCLSID;
HRESULT hr = m_pNativeImpl->m_pOleObject->GetUserClassID( &aCLSID );
if ( FAILED( hr ) )
throw io::IOException(); // TODO:
return MimeConfigurationHelper::GetSequenceClassID( aCLSID.Data1, aCLSID.Data2, aCLSID.Data3,
aCLSID.Data4[0], aCLSID.Data4[1],
aCLSID.Data4[2], aCLSID.Data4[3],
aCLSID.Data4[4], aCLSID.Data4[5],
aCLSID.Data4[6], aCLSID.Data4[7] );
}
bool OleComponent::IsDirty()
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
if ( IsWorkaroundActive() )
return true;
ComSmart< IPersistStorage > pPersistStorage;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersistStorage) );
if ( FAILED( hr ) || !pPersistStorage )
throw io::IOException(); // TODO
hr = pPersistStorage->IsDirty();
return ( hr != S_FALSE );
}
void OleComponent::StoreOwnTmpIfNecessary()
{
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
ComSmart< IPersistStorage > pPersistStorage;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersistStorage) );
if ( FAILED( hr ) || !pPersistStorage )
throw io::IOException(); // TODO
if ( m_bWorkaroundActive || pPersistStorage->IsDirty() != S_FALSE )
{
hr = OleSave( pPersistStorage, m_pNativeImpl->m_pIStorage, TRUE );
if ( FAILED( hr ) )
{
// Till now was required only for AcrobatReader7.0.8
GUID aCLSID;
hr = m_pNativeImpl->m_pOleObject->GetUserClassID( &aCLSID );
if ( FAILED( hr ) )
{
SAL_WARN("embeddedobj.ole", "OleComponent::StoreOwnTmpIfNecessary: GetUserClassID() failed");
throw io::IOException(); // TODO
}
hr = WriteClassStg( m_pNativeImpl->m_pIStorage, aCLSID );
if ( FAILED( hr ) )
throw io::IOException(); // TODO
// the result of the following call is not checked because some objects, for example AcrobatReader7.0.8
// return error even in case the saving was done correctly
hr = pPersistStorage->Save( m_pNativeImpl->m_pIStorage, TRUE );
// another workaround for AcrobatReader7.0.8 object, this object might think that it is not changed
// when it has been created from file, although it must be saved
m_bWorkaroundActive = true;
}
hr = m_pNativeImpl->m_pIStorage->Commit( STGC_DEFAULT );
if ( FAILED( hr ) )
throw io::IOException(); // TODO
hr = pPersistStorage->SaveCompleted( nullptr );
if ( FAILED( hr ) && hr != E_UNEXPECTED )
throw io::IOException(); // TODO
}
}
bool OleComponent::SaveObject_Impl()
{
bool bResult = false;
OleEmbeddedObject* pLockObject = nullptr;
{
osl::MutexGuard aGuard( m_aMutex );
if ( m_pUnoOleObject )
{
pLockObject = m_pUnoOleObject;
pLockObject->acquire();
}
}
if ( pLockObject )
{
bResult = pLockObject->SaveObject_Impl();
pLockObject->release();
}
return bResult;
}
bool OleComponent::OnShowWindow_Impl( bool bShow )
{
bool bResult = false;
OleEmbeddedObject* pLockObject = nullptr;
{
osl::MutexGuard aGuard( m_aMutex );
if ( m_pUnoOleObject )
{
pLockObject = m_pUnoOleObject;
pLockObject->acquire();
}
}
if ( pLockObject )
{
bResult = pLockObject->OnShowWindow_Impl( bShow );
pLockObject->release();
}
return bResult;
}
void OleComponent::OnViewChange_Impl( sal_uInt32 dwAspect )
{
// TODO: check if it is enough or may be saving notifications are required for Visio2000
::rtl::Reference< OleEmbeddedObject > xLockObject;
{
osl::MutexGuard aGuard( m_aMutex );
if ( m_pUnoOleObject )
xLockObject = m_pUnoOleObject;
}
if ( xLockObject.is() )
{
uno::Reference < awt::XRequestCallback > xRequestCallback(
m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.awt.AsyncCallback", m_xContext),
uno::UNO_QUERY );
xRequestCallback->addCallback( new MainThreadNotificationRequest( xLockObject, OLECOMP_ONVIEWCHANGE, dwAspect ), uno::Any() );
}
}
void OleComponent::OnClose_Impl()
{
::rtl::Reference< OleEmbeddedObject > xLockObject;
{
osl::MutexGuard aGuard( m_aMutex );
if ( m_pUnoOleObject )
xLockObject = m_pUnoOleObject;
}
if ( xLockObject.is() )
{
uno::Reference < awt::XRequestCallback > xRequestCallback(
m_xContext->getServiceManager()->createInstanceWithContext("com.sun.star.awt.AsyncCallback", m_xContext),
uno::UNO_QUERY );
xRequestCallback->addCallback( new MainThreadNotificationRequest( xLockObject, OLECOMP_ONCLOSE ), uno::Any() );
}
}
// XCloseable
void SAL_CALL OleComponent::close( sal_Bool bDeliverOwnership )
{
uno::Reference< uno::XInterface > xSelfHold;
{
osl::MutexGuard aGuard(m_aMutex);
if (m_bDisposed)
throw lang::DisposedException(); // TODO
xSelfHold.set(static_cast<::cppu::OWeakObject*>(this));
lang::EventObject aSource(static_cast<::cppu::OWeakObject*>(this));
if (m_pInterfaceContainer)
{
::cppu::OInterfaceContainerHelper* pContainer
= m_pInterfaceContainer->getContainer(cppu::UnoType<util::XCloseListener>::get());
if (pContainer != nullptr)
{
::cppu::OInterfaceIteratorHelper pIterator(*pContainer);
while (pIterator.hasMoreElements())
{
try
{
static_cast<util::XCloseListener*>(pIterator.next())
->queryClosing(aSource, bDeliverOwnership);
}
catch (const uno::RuntimeException&)
{
pIterator.remove();
}
}
}
pContainer
= m_pInterfaceContainer->getContainer(cppu::UnoType<util::XCloseListener>::get());
if (pContainer != nullptr)
{
::cppu::OInterfaceIteratorHelper pCloseIterator(*pContainer);
while (pCloseIterator.hasMoreElements())
{
try
{
static_cast<util::XCloseListener*>(pCloseIterator.next())
->notifyClosing(aSource);
}
catch (const uno::RuntimeException&)
{
pCloseIterator.remove();
}
}
}
}
}
Dispose();
}
void SAL_CALL OleComponent::addCloseListener( const uno::Reference< util::XCloseListener >& xListener )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pInterfaceContainer )
m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
m_pInterfaceContainer->addInterface( cppu::UnoType<util::XCloseListener>::get(), xListener );
}
void SAL_CALL OleComponent::removeCloseListener( const uno::Reference< util::XCloseListener >& xListener )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( m_pInterfaceContainer )
m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XCloseListener>::get(),
xListener );
}
// XTransferable
uno::Any SAL_CALL OleComponent::getTransferData( const datatransfer::DataFlavor& aFlavor )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
uno::Any aResult;
bool bSupportedFlavor = false;
if ( m_pNativeImpl->GraphicalFlavor( aFlavor ) )
{
DWORD nRequestedAspect = GetAspectFromFlavor( aFlavor );
// if own icon is set and icon aspect is requested the own icon can be returned directly
ComSmart< IDataObject > pDataObject;
HRESULT hr = m_pNativeImpl->m_pObj->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pDataObject) );
if ( FAILED( hr ) || !pDataObject )
throw io::IOException(); // TODO: transport error code
// The following optimization does not make much sense currently just because
// only one aspect is supported, and only three formats for the aspect are supported
// and moreover it is not guaranteed that the once returned format will be supported further
// example - i52106
// TODO/LATER: bring the optimization back when other aspects are supported
// FORMATETC* pFormatEtc = m_pNativeImpl->GetSupportedFormatForAspect( nRequestedAspect );
// if ( pFormatEtc )
// {
// STGMEDIUM aMedium;
// hr = pDataObject->GetData( pFormatEtc, &aMedium );
// if ( SUCCEEDED( hr ) )
// bSupportedFlavor = m_pNativeImpl->ConvertDataForFlavor( aMedium, aFlavor, aResult );
// }
// else
{
// the supported format of the application is still not found, find one
for ( sal_Int32 nInd = 0; nInd < FORMATS_NUM; nInd++ )
{
STGMEDIUM aMedium;
FORMATETC aFormat = pFormatTemplates[nInd];
aFormat.dwAspect = nRequestedAspect;
hr = pDataObject->GetData( &aFormat, &aMedium );
if ( SUCCEEDED( hr ) )
{
bSupportedFlavor = m_pNativeImpl->ConvertDataForFlavor( aMedium, aFlavor, aResult );
::ReleaseStgMedium(&aMedium); // i113605, to release storage medium
if ( bSupportedFlavor )
{
// TODO/LATER: bring the optimization back when other aspects are supported
// m_pNativeImpl->AddSupportedFormat( aFormat );
break;
}
}
}
}
// If the replacement could not be retrieved, the cached representation should be used
// currently it is not necessary to retrieve it here, so it is implemented in the object itself
}
// TODO: Investigate if there is already the format name
// and whether this format is really required
else if ( aFlavor.DataType == cppu::UnoType<io::XInputStream>::get()
&& aFlavor.MimeType == "application/x-openoffice-contentstream" )
{
// allow to retrieve stream-representation of the object persistence
bSupportedFlavor = true;
uno::Reference < io::XStream > xTempFileStream(
io::TempFile::create(m_xContext),
uno::UNO_QUERY_THROW );
uno::Reference< io::XOutputStream > xTempOutStream = xTempFileStream->getOutputStream();
uno::Reference< io::XInputStream > xTempInStream = xTempFileStream->getInputStream();
if ( !(xTempOutStream.is() && xTempInStream.is()) )
throw io::IOException(); // TODO:
OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" );
if ( !m_pUnoOleObject )
throw uno::RuntimeException();
m_pUnoOleObject->StoreObjectToStream( xTempOutStream );
xTempOutStream->closeOutput();
xTempOutStream.clear();
aResult <<= xTempInStream;
}
if ( !bSupportedFlavor )
throw datatransfer::UnsupportedFlavorException();
return aResult;
}
uno::Sequence< datatransfer::DataFlavor > SAL_CALL OleComponent::getTransferDataFlavors()
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
RetrieveObjectDataFlavors_Impl();
return m_aDataFlavors;
}
sal_Bool SAL_CALL OleComponent::isDataFlavorSupported( const datatransfer::DataFlavor& aFlavor )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pNativeImpl->m_pOleObject )
throw embed::WrongStateException(); // TODO: the object is in wrong state
if ( !m_aDataFlavors.getLength() )
{
RetrieveObjectDataFlavors_Impl();
}
for ( auto const & supportedFormat : std::as_const(m_aDataFlavors) )
if ( supportedFormat.MimeType.equals( aFlavor.MimeType ) && supportedFormat.DataType == aFlavor.DataType )
return true;
return false;
}
void SAL_CALL OleComponent::dispose()
{
try
{
close( true );
}
catch ( const uno::Exception& )
{
}
}
void SAL_CALL OleComponent::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pInterfaceContainer )
m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
m_pInterfaceContainer->addInterface( cppu::UnoType<lang::XEventListener>::get(), xListener );
}
void SAL_CALL OleComponent::removeEventListener( const uno::Reference< lang::XEventListener >& xListener )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( m_pInterfaceContainer )
m_pInterfaceContainer->removeInterface( cppu::UnoType<lang::XEventListener>::get(),
xListener );
}
sal_Int64 SAL_CALL OleComponent::getSomething( const css::uno::Sequence< sal_Int8 >& aIdentifier )
{
try
{
uno::Sequence < sal_Int8 > aCLSID = GetCLSID();
if ( MimeConfigurationHelper::ClassIDsEqual( aIdentifier, aCLSID ) )
return reinterpret_cast<sal_Int64>(static_cast<IUnknown*>(m_pNativeImpl->m_pObj));
// compatibility hack for old versions: CLSID was used in wrong order (SvGlobalName order)
sal_Int32 nLength = aIdentifier.getLength();
if ( nLength == 16 )
{
for ( sal_Int32 n=8; n<16; n++ )
if ( aIdentifier[n] != aCLSID[n] )
return 0;
if ( aIdentifier[7] == aCLSID[6] &&
aIdentifier[6] == aCLSID[7] &&
aIdentifier[5] == aCLSID[4] &&
aIdentifier[4] == aCLSID[5] &&
aIdentifier[3] == aCLSID[0] &&
aIdentifier[2] == aCLSID[1] &&
aIdentifier[1] == aCLSID[2] &&
aIdentifier[0] == aCLSID[3] )
return reinterpret_cast<sal_Int64>(static_cast<IUnknown*>(m_pNativeImpl->m_pObj));
}
}
catch ( const uno::Exception& )
{
}
return 0;
}
sal_Bool SAL_CALL OleComponent::isModified()
{
return m_bModified;
}
void SAL_CALL OleComponent::setModified( sal_Bool bModified )
{
m_bModified = bModified;
if ( bModified && m_pInterfaceContainer )
{
::cppu::OInterfaceContainerHelper* pContainer =
m_pInterfaceContainer->getContainer( cppu::UnoType<util::XModifyListener>::get());
if ( pContainer != nullptr )
{
::cppu::OInterfaceIteratorHelper pIterator( *pContainer );
while ( pIterator.hasMoreElements() )
{
try
{
lang::EventObject aEvent( static_cast<util::XModifiable*>(this) );
static_cast<util::XModifyListener*>(pIterator.next())->modified( aEvent );
}
catch( const uno::RuntimeException& )
{
pIterator.remove();
}
}
}
}
}
void SAL_CALL OleComponent::addModifyListener( const css::uno::Reference < css::util::XModifyListener >& xListener )
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( !m_pInterfaceContainer )
m_pInterfaceContainer = new ::cppu::OMultiTypeInterfaceContainerHelper( m_aMutex );
m_pInterfaceContainer->addInterface( cppu::UnoType<util::XModifyListener>::get(), xListener );
}
void SAL_CALL OleComponent::removeModifyListener( const css::uno::Reference < css::util::XModifyListener >& xListener)
{
::osl::MutexGuard aGuard( m_aMutex );
if ( m_bDisposed )
throw lang::DisposedException(); // TODO
if ( m_pInterfaceContainer )
m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XModifyListener>::get(),
xListener );
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
View Git Blame Copy Permalink