/* -*- 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 .
*/
// We have at least one single-threaded apartment (STA) in the process (the VCL Main thread, which // is the GUI thread), and a multithreaded apartment (MTA) for most of other threads. OLE objects // may be created in either: in interactive mode, this typically happens in the STA; when serving // external requests, this may be either in STA (when explicit "OnMainThread" argument is passed to // loadComponentFromURL, and the instantiation of the object happens during the load), or in MTA // (the thread actually serving the incoming calls). // // The objects typically can only be used in the apartment where they were instantiated. This means // that e.g. a call to IOleObject::Close will fail, if it is performed in a different thread, when // it was started in the main thread. And vice versa, opening a document in a handler thread, then // trying to interact with the OLE object in GUI would fail. // // To handle this, several workarounds were implemented in the past; the mentioned "OnMainThread" // argument is one of these, allowing open document requests be processed not in the handler threads // that received the request, but in the main thread which will then be used for interaction. Also // OleComponent::GetExtent was changed to check if the first call to IDataObject::GetData failed // with RPC_E_WRONG_THREAD, and then retry in the main thread. // // But ultimately every call to the OLE object needs such checks. E.g., failing to close the object // keeps the server running, effectively leaking resources, until it crashes/freezes after multiple // iterations. // // Currently, OleComponentNative_Impl is implemented using IGlobalInterfaceTable, which allows to // register an object in process-global instance of the table from the thread that instantiated the // object, and obtain a "cookie" (a number); and then use that cookie from any thread to access that // object. The global table will do its magic to provide either the original object (when it is // requested from the same apartment as used for its registration), or a "proxy", which will marshal // all calls to the proper thread, transparently for the caller. This implementation should obsolete // the previous workarounds (in theory). // // m_pGlobalTable is the reference to the global table. // The storage object gets registered in the global table immediately when it's created. // But the OLE object itself can't be registered immediately, before it is run: an attempt to call // RegisterInterfaceInGlobal with such a newly created OLE object fails with CO_E_OBJNOTCONNECTED. // Thus, the initial reference to the OLE object (which at this stage seems to be apartment-neutral) // is stored to m_pObj. Only when it is run, it is registered in the global table. // // Indeed, the implicit change of the thread is a blocking operation, which opens a wonderful new // opportunities for shiny deadlocks. Thus, precautions are needed to avoid them. // // When the OLE object is accessed by m_pObj (should be only in initialization code!), no measures // are taken to change locking. But when it is accessed by getObj() - which may return the proxy - // the calls are guarded by a SolarMutexReleaser, to allow the other thread do its job. // // There are at least two other mutexes in play here. One is in OleEmbeddedObject, that holds the // OleComponent. The calls to OleComponent's methods are also wrapped there into unlock/lock pairs // (see OleEmbeddedObject::changeState). The other is in OleComponent itself. For now, I see no // deadlocks caused by that mutex, so no unlock/lock is introduced for that. It may turn out to be // required eventually. class OleComponentNative_Impl
{ public:
sal::systools::COMReference< IUnknown > m_pObj;
uno::Sequence< datatransfer::DataFlavor > m_aSupportedGraphFormats;
// The getters may return a proxy, that redirects the calls to another thread. // Thus, calls to methods of returned objects must be inside solar mutex releaser. auto getStorage() const { return getInterface<IStorage>(m_nStorage); } auto getObj() const { return m_nOleObject ? getInterface<IUnknown>(m_nOleObject) : m_pObj; } template <typename T> auto get() const { return getObj().QueryInterface<T>(sal::systools::COM_QUERY); }
~OleComponentNative_Impl()
{ if (m_nOleObject)
m_pGlobalTable->RevokeInterfaceFromGlobal(m_nOleObject); if (m_nStorage)
m_pGlobalTable->RevokeInterfaceFromGlobal(m_nStorage);
}
// 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
// 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;
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!" );
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();
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;
}
sal::systools::COMReference<IStorage> OleComponentNative_Impl::CreateNewStorage(const OUString& url)
{ if (IsStorageRegistered()) throw io::IOException(); // TODO:the object is already initialized // TODO: in future a global memory could be used instead of file.
// write the stream to the temporary file if (url.isEmpty()) throw uno::RuntimeException(
u"Cannot create storage: Provided URL is empty."_ustr); // TODO
// open an IStorage based on the temporary file
OUString aTempFilePath; if (osl::FileBase::getSystemPathFromFileURL(url, aTempFilePath) != osl::FileBase::E_None) throw uno::RuntimeException(
u"Failed to retrieve system path from file URL. Possible invalid or unsafe URL."_ustr
); // TODO: something dangerous happened
void OleComponent::RetrieveObjectDataFlavors_Impl()
{ if (!m_pNativeImpl->m_pObj) throw embed::WrongStateException(); // TODO: the object is in wrong state
// 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 );
if ( !m_aDataFlavors.getLength() )
{ // TODO: // for any reason the object could not provide this information // try to get access to the cached representation
}
}
}
void OleComponent::InitializeObject_Impl() // There will be no static objects!
{ if ( !m_pNativeImpl->m_pObj ) throw embed::WrongStateException();
// the linked object will be detected here
OSL_ENSURE( m_pUnoOleObject, "Unexpected object absence!" ); if ( m_pUnoOleObject )
m_pUnoOleObject->SetObjectIsLink_Impl( m_pNativeImpl->m_pObj.QueryInterface<IOleLink>(sal::systools::COM_QUERY).is() );
auto pViewObject2(m_pNativeImpl->m_pObj.QueryInterface<IViewObject2>(sal::systools::COM_QUERY)); if (!pViewObject2) throw uno::RuntimeException(
u"Failed to query IViewObject2 interface from native implementation object."_ustr
); // TODO
// remove all the caches if ( sal::systools::COMReference< IOleCache > pIOleCache{ m_pNativeImpl->m_pObj, sal::systools::COM_QUERY } )
{
IEnumSTATDATA* pEnumSD = nullptr;
HRESULT hr2 = pIOleCache->EnumCache( &pEnumSD );
// 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 );
}
auto pOleObject(m_pNativeImpl->m_pObj.QueryInterface<IOleObject>(sal::systools::COM_QUERY)); if (!pOleObject) throw uno::RuntimeException(
u"Failed to query IOleObject interface from native implementation object."_ustr
); // Static objects are not supported, they should be inserted as graphics
DWORD nOLEMiscFlags(0);
pOleObject->GetMiscStatus(DVASPECT_CONTENT, reinterpret_cast<DWORD*>(&nOLEMiscFlags)); // TODO: use other misc flags also // the object should have drawable aspect even in case it supports only iconic representation // if ( nOLEMiscFlags & OLEMISC_ONLYICONIC )
pOleObject->SetClientSite(m_pOleWrapClientSite);
// the only need in this registration is workaround for close notification
DWORD nAdvConn(0);
pOleObject->Advise(m_pImplAdviseSink, reinterpret_cast<DWORD*>(&nAdvConn));
pViewObject2->SetAdvise(DVASPECT_CONTENT, 0, m_pImplAdviseSink);
OleSetContainedObject(pOleObject, TRUE);
}
namespace
{
HRESULT OleLoadSeh(LPSTORAGE pIStorage, IUnknown** ppObj)
{
HRESULT hr = E_FAIL; // tdf#119039: there is a nasty bug in OleLoad, that may call an unpaired // IUnknown::Release on pIStorage on STG_E_FILENOTFOUND: see // https://developercommunity.visualstudio.com/t/10144795 // Workaround it here to avoid crash in smart COM pointer destructor that // would try to release already released object. Since we don't know if // the bug appears each time STG_E_FILENOTFOUND is returned, this might // potentially leak the storage object. if (pIStorage)
pIStorage->AddRef();
void OleComponent::LoadEmbeddedObject( const OUString& aTempURL )
{ if ( !aTempURL.getLength() ) throw lang::IllegalArgumentException(); // TODO
if (m_pNativeImpl->IsStorageRegistered()) throw io::IOException(); // TODO the object is already initialized or wrong initialization is done
// open an IStorage based on the temporary file
OUString aFilePath; if (osl::FileBase::getSystemPathFromFileURL(aTempURL, aFilePath) != ::osl::FileBase::E_None) throw uno::RuntimeException( u"Failed to retrieve system path from file URL: Invalid or unsupported URL."_ustr); // TODO: something dangerous happened
hr = OleLoadSeh(pStorage, &m_pNativeImpl->m_pObj); if (FAILED(hr)) throw uno::RuntimeException( "Failed to load OLE object from storage: " + comphelper::WindowsErrorStringFromHRESULT(hr)
);
InitializeObject_Impl();
}
void OleComponent::CreateObjectFromClipboard()
{ auto pStorage(m_pNativeImpl->CreateNewStorage(getTempURL())); if (!pStorage) throw uno::RuntimeException(
u"Failed to create new storage for clipboard object."_ustr
); // TODO
if ( !GetClassIDFromSequence_Impl( aSeqCLSID, aClsID ) ) throw lang::IllegalArgumentException(); // TODO
auto pStorage(m_pNativeImpl->CreateNewStorage(getTempURL())); if (!pStorage) throw uno::RuntimeException(
u"Failed to retrieve CLSID from the provided sequence."_ustr
); // 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,
pStorage,
IID_PPV_ARGS_Helper(&m_pNativeImpl->m_pObj) ); if (FAILED(hr)) throw uno::RuntimeException(
u"Failed to create new storage for embedded object."_ustr
); // TODO
InitializeObject_Impl();
// 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 )
{ auto pStorage(m_pNativeImpl->CreateNewStorage(getTempURL())); if (!pStorage) throw uno::RuntimeException(
u"Failed to create new storage for OLE object from file."_ustr
); // TODO:
OUString aFilePath; if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None ) throw uno::RuntimeException( "Failed to convert file URL to system path: " + aFileURL
); // TODO: something dangerous happened
HRESULT hr = OleCreateFromFile( CLSID_NULL,
o3tl::toW(aFilePath.getStr()),
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr,
nullptr,
pStorage,
IID_PPV_ARGS_Helper(&m_pNativeImpl->m_pObj) ); if (FAILED(hr)) throw uno::RuntimeException( "Failed to create OLE object from file: " + comphelper::WindowsErrorStringFromHRESULT(hr)
); // TODO
InitializeObject_Impl();
}
void OleComponent::CreateLinkFromFile( const OUString& aFileURL )
{ auto pStorage(m_pNativeImpl->CreateNewStorage(getTempURL())); if (!pStorage) throw uno::RuntimeException(
u"Failed to create new storage for linked OLE object."_ustr
); // TODO:
OUString aFilePath; if ( ::osl::FileBase::getSystemPathFromFileURL( aFileURL, aFilePath ) != ::osl::FileBase::E_None ) throw uno::RuntimeException(
u"Failed to convert file URL to system path: "_ustr + aFileURL
); // TODO: something dangerous happened
HRESULT hr = OleCreateLinkToFile( o3tl::toW(aFilePath.getStr()),
IID_IUnknown,
OLERENDER_DRAW, // OLERENDER_FORMAT
nullptr,
nullptr,
pStorage,
IID_PPV_ARGS_Helper(&m_pNativeImpl->m_pObj) ); if (FAILED(hr)) throw uno::RuntimeException( "Failed to create linked OLE object from file: " + comphelper::WindowsErrorStringFromHRESULT(hr)
); // TODO
InitializeObject_Impl();
}
void OleComponent::InitEmbeddedCopyOfLink( rtl::Reference<OleComponent> const & pOleLinkComponent )
{ if (!pOleLinkComponent) throw lang::IllegalArgumentException(); // TODO
auto pOleLinkComponentObj(pOleLinkComponent->m_pNativeImpl->getObj()); if (!pOleLinkComponentObj) throw lang::IllegalArgumentException();
// the object must be already disconnected from the temporary URL auto pStorage(m_pNativeImpl->CreateNewStorage(getTempURL()));
SolarMutexReleaser releaser;
auto pDataObject(pOleLinkComponentObj.QueryInterface<IDataObject>(sal::systools::COM_QUERY)); if ( pDataObject && SUCCEEDED( OleQueryCreateFromData( pDataObject ) ) )
{ if (!pStorage) throw uno::RuntimeException(
u"Failed to create storage for OLE object from IDataObject."_ustr
); // TODO:
if ( !m_pNativeImpl->m_pObj )
{ auto pOleLink(pOleLinkComponentObj.QueryInterface<IOleLink>(sal::systools::COM_QUERY)); if ( !pOleLink ) throw io::IOException(); // TODO: the object doesn't support IOleLink
sal::systools::COMReference< IMoniker > pMoniker;
HRESULT 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 )
{
sal::systools::COMReference< IMalloc > pMalloc;
hr = CoGetMalloc( 1, &pMalloc ); // if fails there will be a memory leak
OSL_ENSURE(SUCCEEDED(hr) && pMalloc, "CoGetMalloc() failed!");
// in case of other moniker types the only way is to get storage if ( !m_pNativeImpl->m_pObj )
{
sal::systools::COMReference< IBindCtx > pBindCtx;
hr = CreateBindCtx( 0, &pBindCtx ); if ( SUCCEEDED( hr ) && pBindCtx )
{
sal::systools::COMReference< IStorage > pObjectStorage;
hr = pMoniker->BindToStorage(pBindCtx, nullptr, IID_PPV_ARGS(&pObjectStorage)); if ( SUCCEEDED( hr ) && pObjectStorage )
{
hr = pObjectStorage->CopyTo(0, nullptr, nullptr, pStorage); if ( SUCCEEDED( hr ) )
hr = OleLoadSeh(pStorage, &m_pNativeImpl->m_pObj);
}
}
}
}
InitializeObject_Impl();
}
void OleComponent::RunObject()
{ auto pOleObject(m_pNativeImpl->get<IOleObject>());
OSL_ENSURE(pOleObject, "The pointer can not be set to NULL here!"); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
if (!OleIsRunning(pOleObject))
{
HRESULT hr = OleRun( m_pNativeImpl->m_pObj );
if ( FAILED( hr ) )
{
OUString error = comphelper::WindowsErrorStringFromHRESULT(hr); if ( hr == REGDB_E_CLASSNOTREG )
{ if (auto pOleObj
= m_pNativeImpl->m_pObj.QueryInterface<IOleObject>(sal::systools::COM_QUERY))
{
LPOLESTR lpUserType = nullptr; if (SUCCEEDED(pOleObj->GetUserType(USERCLASSTYPE_FULL, &lpUserType)))
{
error += OUString::Concat("\n") + o3tl::toU(lpUserType);
sal::systools::COMReference<IMalloc> pMalloc;
hr = CoGetMalloc(1, &pMalloc); // if fails there will be a memory leak
SAL_WARN_IF(FAILED(hr) || !pMalloc, "embeddedobj.ole", "CoGetMalloc() failed"); if (pMalloc)
pMalloc->Free(lpUserType);
}
} throw embed::UnreachableStateException(
error, getXWeak(), -1,
css::embed::EmbedStates::RUNNING); // the object server is not installed
} else throw io::IOException(error, getXWeak());
} // Only now, when the object is activated, it can be registered in the global table; // before this point, RegisterInterfaceInGlobal would return CO_E_OBJNOTCONNECTED
m_pNativeImpl->registerObj();
}
}
void OleComponent::CloseObject()
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (pOleObject && OleIsRunning(pOleObject))
{
SolarMutexReleaser releaser;
HRESULT hr = pOleObject->Close(OLECLOSE_NOSAVE); // must be saved before
SAL_WARN_IF(FAILED(hr), "embeddedobj.ole", "IOleObject::Close failed");
}
}
uno::Sequence< embed::VerbDescriptor > OleComponent::GetVerbList()
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO
SolarMutexReleaser releaser;
// TODO: probably extents should be set here and stored in aRect // TODO: probably the parent window also should be set
HRESULT hr = pOleObject->DoVerb(nVerbID, nullptr, m_pOleWrapClientSite, 0, nullptr, nullptr);
if ( FAILED( hr ) ) throw io::IOException(); // TODO
}
void OleComponent::SetHostName( const OUString& aEmbDocName )
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
void OleComponent::SetExtent( const awt::Size& aVisAreaSize, sal_Int64 nAspect )
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nMSAspect = static_cast<DWORD>(nAspect); // first 32 bits are for MS aspects
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_pObj) 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 if (auto pDataObject = m_pNativeImpl->get<IDataObject>())
{
STGMEDIUM aMedium;
FORMATETC aFormat = pFormatTemplates[1]; // use windows metafile format
aFormat.dwAspect = nMSAspect;
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
o3tl::Length eFrom = o3tl::Length::mm100; switch( pMF->mm )
{ case MM_HIENGLISH:
eFrom = o3tl::Length::in1000; break;
case MM_LOENGLISH:
eFrom = o3tl::Length::in100; break;
case MM_LOMETRIC:
eFrom = o3tl::Length::mm10; break;
case MM_TWIPS:
eFrom = o3tl::Length::twip; break;
case MM_ISOTROPIC: case MM_ANISOTROPIC: case MM_HIMETRIC: // do nothing break;
}
sal_Int64 nX = o3tl::convert(abs( pMF->xExt ), eFrom, o3tl::Length::mm100);
sal_Int64 nY = o3tl::convert(abs( pMF->yExt ), eFrom, o3tl::Length::mm100); 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!" );
}
} elseif (!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 )
{ auto pViewObject2(m_pNativeImpl->get<IViewObject2>()); if (!pViewObject2) 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;
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
awt::Size OleComponent::GetRecommendedExtent( sal_Int64 nAspect )
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!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;
{
SolarMutexReleaser releaser;
hr = 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 )
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
DWORD nResult = 0;
{
SolarMutexReleaser releaser;
pOleObject->GetMiscStatus(static_cast<DWORD>(nAspect), &nResult);
} returnstatic_cast<sal_Int64>(nResult); // first 32 bits are for MS flags
}
uno::Sequence< sal_Int8 > OleComponent::GetCLSID()
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
void OleComponent::StoreOwnTmpIfNecessary()
{ auto pOleObject(m_pNativeImpl->get<IOleObject>()); if (!pOleObject) throw embed::WrongStateException(); // TODO: the object is in wrong state
auto pPersistStorage(m_pNativeImpl->get<IPersistStorage>()); if ( !pPersistStorage ) throw io::IOException(); // TODO
SolarMutexReleaser releaser;
if ( m_bWorkaroundActive || pPersistStorage->IsDirty() != S_FALSE )
{ auto pStorage(m_pNativeImpl->getStorage());
HRESULT hr = OleSave(pPersistStorage, pStorage, TRUE); if ( FAILED( hr ) )
{ // Till now was required only for AcrobatReader7.0.8
GUID aCLSID;
hr = pOleObject->GetUserClassID(&aCLSID); if ( FAILED( hr ) )
{
SAL_WARN("embeddedobj.ole", "OleComponent::StoreOwnTmpIfNecessary: GetUserClassID() failed"); throw io::IOException(); // TODO
}
hr = WriteClassStg(pStorage, 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(pStorage, 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 = pStorage->Commit(STGC_DEFAULT); if ( FAILED( hr ) ) throw io::IOException(); // TODO
hr = pPersistStorage->SaveCompleted( nullptr ); if ( FAILED( hr ) && hr != E_UNEXPECTED ) throw io::IOException(); // TODO
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;
if ( m_pInterfaceContainer )
m_pInterfaceContainer->removeInterface( cppu::UnoType<util::XCloseListener>::get(),
xListener );
}
// XTransferable
uno::Any SAL_CALL OleComponent::getTransferData( const datatransfer::DataFlavor& aFlavor )
{
::osl::ResettableMutexGuard aGuard( m_aMutex ); if ( m_bDisposed ) throw lang::DisposedException(); // TODO
if (!m_pNativeImpl->m_pObj) 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
auto pDataObject(m_pNativeImpl->get<IDataObject>()); if ( !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;
HRESULT hr;
{
osl::ResettableMutexGuardScopedReleaser own_releaser(aGuard);
SolarMutexReleaser releaser;
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 elseif ( 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 );
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
