diff options
Diffstat (limited to 'embedserv/source')
31 files changed, 9563 insertions, 0 deletions
diff --git a/embedserv/source/embed/docholder.cxx b/embedserv/source/embed/docholder.cxx new file mode 100644 index 000000000..a4b546219 --- /dev/null +++ b/embedserv/source/embed/docholder.cxx @@ -0,0 +1,1376 @@ +/* -*- 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 <docholder.hxx> +#include <embeddoc.hxx> +#include <intercept.hxx> +#include <syswinwrapper.hxx> +#include <iipaobj.hxx> +#include <common.h> + +#if !defined WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include <windows.h> + +#include <com/sun/star/awt/XTopWindow.hpp> +#include <com/sun/star/awt/PosSize.hpp> +#include <com/sun/star/awt/XView.hpp> +#include <com/sun/star/awt/Toolkit.hpp> +#include <com/sun/star/awt/XSystemChildFactory.hpp> +#include <com/sun/star/awt/XSystemDependentWindowPeer.hpp> +#include <com/sun/star/awt/XSystemDependentMenuPeer.hpp> +#include <com/sun/star/awt/WindowAttribute.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/bridge/XBridgeSupplier2.hpp> +#include <com/sun/star/bridge/ModelDependent.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/document/MacroExecMode.hpp> +#include <com/sun/star/embed/EmbedMapUnits.hpp> +#include <com/sun/star/embed/XVisualObject.hpp> +#include <com/sun/star/frame/TerminationVetoException.hpp> +#include <com/sun/star/frame/XComponentLoader.hpp> +#include <com/sun/star/frame/Frame.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/frame/Desktop.hpp> +#include <com/sun/star/frame/XStatusListener.hpp> +#include <com/sun/star/lang/SystemDependent.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/task/InteractionHandler.hpp> +#include <com/sun/star/ui/XUIElement.hpp> +#include <com/sun/star/util/CloseVetoException.hpp> +#include <com/sun/star/util/XCloseBroadcaster.hpp> +#include <com/sun/star/util/XCloseable.hpp> +#include <com/sun/star/util/XModifyBroadcaster.hpp> +#include <comphelper/processfactory.hxx> +#include <o3tl/any.hxx> +#include <osl/diagnose.h> +#include <rtl/process.h> + +using namespace ::com::sun::star; + +// add mutex locking ??? + +DocumentHolder::DocumentHolder( + const uno::Reference<lang::XMultiServiceFactory >& xFactory, + const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl >& xOleAccess ) + : + m_bAllowInPlace(true), + m_pIOleIPSite(nullptr), + m_pIOleIPFrame(nullptr), + m_pIOleIPUIWindow(nullptr), + m_pCHatchWin(nullptr), + m_xOleAccess( xOleAccess ), + m_pInterceptor(nullptr), + m_xFactory( xFactory ), + m_bOnDeactivate(false), + m_hWndxWinParent(nullptr), + m_hWndxWinCont(nullptr), + m_nMenuHandle(nullptr), + m_nMenuShared(nullptr), + m_nOLEMenu(nullptr), + m_nMacroExecMode( document::MacroExecMode::USE_CONFIG ), + m_bLink( false ) +{ + uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory)); + xDesktop->addTerminateListener( static_cast<frame::XTerminateListener*>(this) ); +} + + +DocumentHolder::~DocumentHolder() +{ + delete m_pCHatchWin; + + ClearInterceptorInternally(); +} + + +void DocumentHolder::LoadDocInFrame( bool bPluginMode ) +{ + uno::Reference<frame::XComponentLoader> xComponentLoader( + m_xFrame,uno::UNO_QUERY); + if( xComponentLoader.is() && m_xDocument.is() ) + { + uno::Reference< task::XInteractionHandler2 > xHandler( + task::InteractionHandler::createWithParent(comphelper::getComponentContext(m_xFactory), nullptr) ); + + sal_Int32 nLen = 3; + uno::Sequence<beans::PropertyValue> aSeq( nLen ); + + aSeq[0] = beans::PropertyValue( + "Model", + -1, + uno::Any(uno::Reference<uno::XInterface>(m_xDocument, uno::UNO_QUERY)), + beans::PropertyState_DIRECT_VALUE); + + aSeq[1] = beans::PropertyValue( + "ReadOnly", + -1, + uno::Any(false), + beans::PropertyState_DIRECT_VALUE); + + aSeq[2] = beans::PropertyValue( + "NoAutoSave", + -1, + uno::Any(true), + beans::PropertyState_DIRECT_VALUE); + + if ( bPluginMode ) + { + aSeq.realloc( ++nLen ); + aSeq[nLen-1] = beans::PropertyValue( + "PluginMode", + -1, + uno::Any(sal_Int16(3)), + beans::PropertyState_DIRECT_VALUE); + } + + aSeq.realloc( nLen+=2 ); + aSeq[nLen-2] = beans::PropertyValue( + "InteractionHandler", + -1, + uno::Any(xHandler), + beans::PropertyState_DIRECT_VALUE); + + aSeq[nLen-1] = beans::PropertyValue( + "MacroExecutionMode", + -1, + uno::Any(m_nMacroExecMode), + beans::PropertyState_DIRECT_VALUE); + + xComponentLoader->loadComponentFromURL( + "private:object", + "_self", + 0, + aSeq); + + const uno::Sequence< beans::PropertyValue > aResArgs = m_xDocument->getArgs(); + for ( beans::PropertyValue const & prop : aResArgs ) + if ( prop.Name == "MacroExecutionMode" ) + { + prop.Value >>= m_nMacroExecMode; + break; + } + } +} + +void DocumentHolder::OnPosRectChanged(LPRECT lpRect) const +{ + lpRect->left += m_aBorder.left; + lpRect->right -= m_aBorder.right; + lpRect->top += m_aBorder.top; + lpRect->bottom -= m_aBorder.bottom; + if(m_pIOleIPSite) + m_pIOleIPSite->OnPosRectChange(lpRect); +} + + +void DocumentHolder::DisableInplaceActivation(BOOL b) +{ + m_bAllowInPlace = ! b; +} + +BOOL DocumentHolder::isActive() const +{ + return m_pIOleIPSite != nullptr; +} + +HRESULT DocumentHolder::InPlaceActivate( + LPOLECLIENTSITE pActiveSite, + BOOL fIncludeUI) +{ + m_bOnDeactivate = false; + + if(!m_bAllowInPlace) + return ERROR; + + HRESULT hr; + HWND hWndSite; + RECT rcPos; + RECT rcClip; + OLEINPLACEFRAMEINFO frameInfo; + + if (nullptr==pActiveSite) + return ResultFromScode(E_INVALIDARG); + + if (nullptr!=m_pIOleIPSite) + { + if (fIncludeUI) + UIActivate(); + + return NOERROR; + } + + if ( !m_xDocument.is() ) + return ERROR; + + //1. Initialization, obtaining interfaces, OnInPlaceActivate. + hr=pActiveSite->QueryInterface( + IID_IOleInPlaceSite, + reinterpret_cast<void**>(&m_pIOleIPSite)); + + if (FAILED(hr)) + return hr; + + hr=m_pIOleIPSite->CanInPlaceActivate(); + + if (NOERROR!=hr) + { + m_pIOleIPSite->Release(); + m_pIOleIPSite=nullptr; + return ResultFromScode(E_FAIL); + } + + m_pIOleIPSite->OnInPlaceActivate(); + + //2. Get the site window + //3. and determine container frame and + // document window for tools and menus, as well + // as frameInfo for accelerators + m_pIOleIPSite->GetWindow(&hWndSite); + + frameInfo.cb=sizeof(OLEINPLACEFRAMEINFO); + m_pIOleIPSite->GetWindowContext( + &m_pIOleIPFrame,&m_pIOleIPUIWindow,&rcPos,&rcClip,&frameInfo); + + // initialize the office as, with hwnd as parentwindow + uno::Any aAny; + uno::Sequence<sal_Int8> aProcessIdent(16); + rtl_getGlobalProcessId(reinterpret_cast<sal_uInt8*>(aProcessIdent.getArray())); + + try + { + if(!m_xEditWindow.is()) + { // determine XWindow and window handle of parent + HWND hWndxWinParent(nullptr); + uno::Reference<awt::XWindow> xWin; + + uno::Reference<awt::XToolkit2> xToolkit = + awt::Toolkit::create(comphelper::getComponentContext(m_xFactory)); + + // create system window wrapper for hwnd + if( !m_pCHatchWin ) + m_pCHatchWin = new winwrap::CHatchWin( + m_hInstance,this); + + if(m_pCHatchWin->Init(hWndSite,/*ID_HATCHWINDOW*/2000, nullptr)) { + m_pCHatchWin->RectsSet(&rcPos,&rcClip); //set visible area + hWndxWinParent = m_pCHatchWin->Window(); + ShowWindow(hWndxWinParent,SW_SHOW); //Make visible. + } + else { + // no success initializing hatch window + delete m_pCHatchWin; + m_pCHatchWin = nullptr; + hWndxWinParent = hWndSite; + } + + xWin.set( + xToolkit->createSystemChild( + uno::Any(sal_Int64(hWndxWinParent)), + aProcessIdent, + lang::SystemDependent::SYSTEM_WIN32), + uno::UNO_QUERY); + + if(xWin.is()) { + xWin->setPosSize( + m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0, + m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0, + rcPos.right-rcPos.left, + rcPos.bottom - rcPos.top, + awt::PosSize::POSSIZE); + xWin->setVisible(true); + + m_xEditWindow = xWin; + m_hWndxWinParent = hWndxWinParent; + } + else + return ERROR; + } + else { + if(m_hWndxWinParent) { + SetParent(m_hWndxWinParent,hWndSite); + ShowWindow(m_hWndxWinParent,SW_SHOW); //Make visible. + } + + if ( !m_xFrame.is() ) + // initially set size to "empty", this guarantees that the final resize + // is always executed (will be done by "SetObjectRects" after getting internal border) + m_xEditWindow->setPosSize( + 0, + 0, + 0, + 0, + awt::PosSize::POSSIZE); + m_xEditWindow->setVisible(true); + } + + if(m_xContainerWindow.is()) { + if(m_hWndxWinCont) { + if(m_pIOleIPFrame) { + HWND hWndCont; + m_pIOleIPFrame->GetWindow(&hWndCont); + SetParent(m_hWndxWinCont,hWndCont); + ShowWindow(m_hWndxWinCont,SW_SHOW); + } + } + m_xContainerWindow->setVisible(true); + } + + if(m_xFrame.is()) + m_xFrame->activate(); + else { + // create frame and initialize it with the created window + m_xFrame = frame::Frame::create( comphelper::getComponentContext(m_xFactory) ); + m_xFrame->initialize(m_xEditWindow); + + m_xFrame->registerDispatchProviderInterceptor( CreateNewInterceptor() ); + + m_xLayoutManager.set( m_xFrame->getLayoutManager(), uno::UNO_QUERY ); + + if(m_xLayoutManager.is()) + m_xLayoutManager->setDockingAreaAcceptor(this); + + // load the model into the frame + LoadDocInFrame( true ); + + uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory)); + xDesktop->getFrames()->append(m_xFrame); + + // determine the menuhandle to get menuitems. + if(m_xLayoutManager.is()) { + uno::Reference< css::ui::XUIElement > xUIEl( + m_xLayoutManager->getElement( + "private:resource/menubar/menubar")); + OSL_ENSURE(xUIEl.is(),"no menubar"); + uno::Reference<awt::XSystemDependentMenuPeer> xSDMP( + xUIEl->getRealInterface(), + uno::UNO_QUERY); + aAny = xSDMP->getMenuHandle( + aProcessIdent,lang::SystemDependent::SYSTEM_WIN32); + sal_Int64 tmp; + if( aAny >>= tmp ) + m_nMenuHandle = HMENU(tmp); + m_xLayoutManager->hideElement( + "private:resource/menubar/menubar" ); + } + } + + // TODO/cd: Workaround for status indicator bug. It always makes the + // document window visible, when someone tries to use the status + // indicator. As we save our document when we get the deactivation + // from OLE this conflict to hide floating windows. + if(m_xLayoutManager.is()) + m_xLayoutManager->setVisible(true); + + // get document border and resize rects according to border + GetDocumentBorder( &m_aBorder ); + SetObjectRects( &rcPos, &rcClip ); + + if ( m_xOleAccess.is() ) + { + LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument(); + if ( aDocLock.GetEmbedDocument() ) + aDocLock.GetEmbedDocument()->ShowObject(); + } + + // setTitle(m_aDocumentNamePart); + if (fIncludeUI) + hr=UIActivate(); + + m_pIOleIPSite->DiscardUndoState(); + } + catch( const uno::Exception& ) + { + hr = ERROR; + } + + return hr; +} + + +void DocumentHolder::InPlaceDeactivate() +{ + m_bOnDeactivate = true; + + UIDeactivate(); + if(m_xFrame.is()) m_xFrame->deactivate(); + + if(m_xEditWindow.is()) { + m_xEditWindow->setVisible(false); + ShowWindow(m_hWndxWinParent,SW_HIDE); + SetParent(m_hWndxWinParent,nullptr); + } + + if(m_xContainerWindow.is()) { + m_xContainerWindow->setVisible(false); + ShowWindow(m_hWndxWinCont,SW_HIDE); + SetParent(m_hWndxWinCont,nullptr); + } + + // TODO/cd: Workaround for status indicator bug. It always makes the + // document window visible, when someone tries to use the status + // indicator. As we save our document when we get the deactivation + // from OLE this conflict to hide floating windows. + if (m_xLayoutManager.is()) + m_xLayoutManager->setVisible(false); + + if (nullptr!=m_pIOleIPSite) + m_pIOleIPSite->OnInPlaceDeactivate(); + + if(m_pIOleIPFrame) m_pIOleIPFrame->Release(); m_pIOleIPFrame = nullptr; + if(m_pIOleIPUIWindow) m_pIOleIPUIWindow->Release(); m_pIOleIPUIWindow = nullptr; + if(m_pIOleIPSite) m_pIOleIPSite->Release(); m_pIOleIPSite = nullptr; + + if ( m_xOleAccess.is() ) + { + LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument(); + if ( aDocLock.GetEmbedDocument() ) + { + aDocLock.GetEmbedDocument()->SaveObject(); + } + } + + return; +} + + +HRESULT DocumentHolder::UIActivate() +{ + // 1. Call IOleInPlaceSite::UIActivate + if (nullptr!=m_pIOleIPSite) + m_pIOleIPSite->OnUIActivate(); + + //2. Critical for accelerators to work initially. + SetFocus(m_pCHatchWin->Window()); + // if(m_xEditWindow.is()) m_xEditWindow->setFocus(); + + //3. Set the active object + + OLECHAR starOffice[] = {'S','t','a','r','O','f','f','i','c','e',0}; + CComPtr< IOleInPlaceActiveObject > pObj = new CIIAObj( this ); + + if (nullptr!=m_pIOleIPFrame) + m_pIOleIPFrame->SetActiveObject( + pObj, starOffice ); + + if (nullptr!=m_pIOleIPUIWindow) + m_pIOleIPUIWindow->SetActiveObject( + pObj, starOffice ); + + //4. Create the shared menu. + InPlaceMenuCreate(); + + return NOERROR; +} + +void DocumentHolder::UIDeactivate() +{ + //1. Remove the shared menu. + InPlaceMenuDestroy(); + + if (nullptr!=m_pIOleIPFrame) + m_pIOleIPFrame->SetActiveObject(nullptr, nullptr); + + if (nullptr!=m_pIOleIPUIWindow) + m_pIOleIPUIWindow->SetActiveObject(nullptr, nullptr); + + //3. Call IOleInPlaceSite::OnUIDeactivate + if (nullptr!=m_pIOleIPSite) + m_pIOleIPSite->OnUIDeactivate(FALSE); + + return; +} + +static void CopyToOLEMenu(HMENU hOrig,WORD origPos,HMENU hDest,WORD destPos) +{ + HMENU subMenu(nullptr); + wchar_t buffer[256]; + + subMenu = GetSubMenu(hOrig,origPos); + GetMenuStringW(hOrig,origPos,buffer,256,MF_BYPOSITION); + InsertMenuW(hDest,destPos,MF_BYPOSITION | MF_POPUP, + reinterpret_cast<UINT_PTR>(subMenu),buffer); + + MENUITEMINFOW mi = {}; + mi.cbSize = sizeof(mi); + mi.fMask = MIIM_DATA; + if(GetMenuItemInfoW(hOrig,origPos,TRUE,&mi)) + SetMenuItemInfoW(hDest,destPos,TRUE,&mi); +} + +BOOL DocumentHolder::InPlaceMenuCreate() +{ + HMENU hMenu; + OLEMENUGROUPWIDTHS mgw; + + for (UINT i=0; i<6; i++) + mgw.width[i]=0; + + //We already have popup menu handles in m_pFR->m_phMenu[] + + //Create the new shared menu and let container do its thing + hMenu=CreateMenu(); + m_pIOleIPFrame->InsertMenus(hMenu,&mgw); + + int count = GetMenuItemCount(m_nMenuHandle); + int help = count-1; + + // start with 1, because we don't include "File" + WORD pos = static_cast<WORD>(mgw.width[0]); + CopyToOLEMenu(m_nMenuHandle,1,hMenu,pos); + mgw.width[1] = 1; + + // insert object menu here + pos = static_cast<WORD>(mgw.width[0] + mgw.width[1] + mgw.width[2]); + for(WORD i = 2; i < help-1; ++i,++pos) + CopyToOLEMenu(m_nMenuHandle,i,hMenu,pos); + mgw.width[3] = help - 3; + + // insert help menu + pos = static_cast<WORD>(mgw.width[0] + mgw.width[1] + mgw.width[2] + + mgw.width[3] + mgw.width[4]); + CopyToOLEMenu(m_nMenuHandle,WORD(help),hMenu,pos); + mgw.width[5] = 1; + + m_nMenuShared = hMenu; + m_nOLEMenu = OleCreateMenuDescriptor(m_nMenuShared,&mgw); + + uno::Reference<awt::XSystemDependentWindowPeer> xSysDepWin(m_xContainerWindow,uno::UNO_QUERY); + if(xSysDepWin.is()) { + uno::Sequence<sal_Int8> aProcessIdent(16); + rtl_getGlobalProcessId(reinterpret_cast<sal_uInt8*>(aProcessIdent.getArray())); + uno::Any aAny = xSysDepWin->getWindowHandle(aProcessIdent,lang::SystemDependent::SYSTEM_WIN32); + sal_Int64 tmp; + aAny >>= tmp; + HWND aHwnd = reinterpret_cast<HWND>(tmp); + m_pIOleIPFrame->SetMenu( + m_nMenuShared,m_nOLEMenu,aHwnd); + } + else + m_pIOleIPFrame->SetMenu( + m_nMenuShared,m_nOLEMenu,::GetWindow(m_hWndxWinParent,GW_CHILD)); + return TRUE; +} + +BOOL DocumentHolder::InPlaceMenuDestroy() +{ + if( nullptr == m_nMenuShared ) + return TRUE; + + m_pIOleIPFrame->SetMenu(nullptr,nullptr,nullptr); + + OleDestroyMenuDescriptor(m_nOLEMenu); + m_nOLEMenu = nullptr; + return TRUE; +} + +void DocumentHolder::OpenIntoWindow() +{ + // not implemented +} + +BOOL DocumentHolder::Undo() +{ + // not implemented + return false; +} + + +void DocumentHolder::FreeOffice() +{ + uno::Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory)); + xDesktop->removeTerminateListener( + static_cast<frame::XTerminateListener*>(this) ); +} + +void DocumentHolder::DisconnectFrameDocument( bool bComplete ) +{ + try + { + uno::Reference< util::XModifyBroadcaster > xModifiable( m_xDocument, uno::UNO_QUERY_THROW ); + xModifiable->removeModifyListener( static_cast<util::XModifyListener*>(this) ); + } + catch( const uno::Exception& ) + {} + + try + { + uno::Reference< util::XCloseBroadcaster > xBroadcaster( + m_xDocument, uno::UNO_QUERY_THROW ); + xBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) ); + } + catch( const uno::Exception& ) + {} + + try + { + uno::Reference< util::XCloseBroadcaster > xBroadcaster( + m_xFrame, uno::UNO_QUERY_THROW ); + xBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) ); + } + catch( const uno::Exception& ) + {} + + if ( bComplete ) + { + m_xFrame.clear(); + m_pIDispatch = nullptr; + m_xDocument.clear(); + } +} + +void DocumentHolder::CloseDocument() +{ + DisconnectFrameDocument(); + + uno::Reference< util::XCloseable > xCloseable( + m_xDocument, uno::UNO_QUERY ); + + if ( xCloseable.is() ) + { + try + { + xCloseable->close( true ); + } + catch( const uno::Exception& ) + {} + } + + m_pIDispatch = nullptr; + m_xDocument.clear(); +} + + +void DocumentHolder::CloseFrame() +{ + try + { + uno::Reference< util::XCloseBroadcaster > xBroadcaster( + m_xFrame, uno::UNO_QUERY_THROW ); + xBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) ); + } + catch( const uno::Exception& ) + {} + + uno::Reference<util::XCloseable> xCloseable( + m_xFrame,uno::UNO_QUERY); + if(xCloseable.is()) + try { + xCloseable->close(true); + } + catch( const uno::Exception& ) { + } + else if (m_xFrame.is()) + m_xFrame->dispose(); + + m_xFrame.clear(); +} + +void DocumentHolder::SetDocument( const uno::Reference< frame::XModel >& xDoc, bool bLink ) +{ + if ( m_xDocument.is() ) + CloseDocument(); + + m_xDocument = xDoc; + m_bLink = bLink; + + uno::Reference< util::XCloseBroadcaster > xBroadcaster( + m_xDocument, uno::UNO_QUERY ); + + if ( xBroadcaster.is() ) + xBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) ); + + if ( m_xDocument.is() && !m_bLink ) + { + // set the document mode to embedded + uno::Sequence< beans::PropertyValue > aSeq(1); + aSeq[0].Name = "SetEmbedded"; + aSeq[0].Value <<= true; + m_xDocument->attachResource(OUString(),aSeq); + } +} + +bool DocumentHolder::ExecuteSuspendCloseFrame() +{ + if ( m_xFrame.is() && m_xFactory.is() ) + { + try + { + uno::Reference< frame::XController > xController = m_xFrame->getController(); + if ( xController.is() ) + { + if ( !xController->suspend( true ) ) + return false; + + FreeOffice(); + try + { + uno::Reference<util::XCloseable> xCloseable( m_xFrame, uno::UNO_QUERY ); + if ( xCloseable.is() ) + xCloseable->close(true); + else + { + m_xFrame->dispose(); + } + } + catch( const util::CloseVetoException& ) + { + // should be called if the frame could not be closed + xController->suspend( false ); + } + } + } + catch( uno::Exception& ) + { + } + + m_xFrame.clear(); + } + + return true; +} + +uno::Reference< frame::XFrame2 > DocumentHolder::DocumentFrame() +{ + if(! m_xFrame.is() ) + { + uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create(comphelper::getComponentContext(m_xFactory)); + + // the frame will be registered on desktop here, later when the document + // is loaded into the frame in ::show() method the terminate listener will be removed + // this is so only for outplace activation + m_xFrame.set( xDesktop->findFrame( "_blank", 0 ), uno::UNO_QUERY ); + + uno::Reference< util::XCloseBroadcaster > xBroadcaster( + m_xFrame, uno::UNO_QUERY ); + + if ( xBroadcaster.is() ) + { + xBroadcaster->addCloseListener( static_cast<util::XCloseListener*>(this) ); + FreeOffice(); // the frame is part of the desktop + } + } + + if( m_xFrame.is() ) + { + // intercept + m_xFrame->registerDispatchProviderInterceptor( CreateNewInterceptor() ); + } + + return m_xFrame; +} + + +uno::Reference< frame::XDispatchProviderInterceptor > DocumentHolder::CreateNewInterceptor() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + + ClearInterceptorInternally(); + + uno::Reference< frame::XDispatchProviderInterceptor > xInterceptor( m_pInterceptor = new Interceptor( m_xOleAccess, this, m_bLink ) ); + m_xInterceptorLocker = xInterceptor; + return xInterceptor; +} + +void DocumentHolder::ClearInterceptorInternally() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + uno::Reference< frame::XDispatchProviderInterceptor > xInterceptor( m_xInterceptorLocker ); + if ( xInterceptor.is() && m_pInterceptor ) + m_pInterceptor->DisconnectDocHolder(); + + m_xInterceptorLocker.clear(); + m_pInterceptor = nullptr; +} + +void DocumentHolder::ClearInterceptor() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + m_xInterceptorLocker.clear(); + m_pInterceptor = nullptr; +} + + +void DocumentHolder::show() +{ + try + { + if(m_xFrame.is()) + { + m_xFrame->activate(); + uno::Reference<awt::XTopWindow> xTopWindow( + m_xFrame->getContainerWindow(),uno::UNO_QUERY); + if(xTopWindow.is()) + xTopWindow->toFront(); + } + else if( DocumentFrame().is() ) + { + LoadDocInFrame( false ); + + // get rid of second closer if it is there + uno::Reference< beans::XPropertySet > xLMProps( m_xFrame->getLayoutManager(), uno::UNO_QUERY ); + if ( xLMProps.is() ) + { + xLMProps->setPropertyValue("MenuBarCloser", + uno::makeAny( uno::Reference< frame::XStatusListener >() ) ); + } + + if ( !m_bLink ) + { + try + { + uno::Reference< util::XModifyBroadcaster > xModifiable( m_xDocument, uno::UNO_QUERY_THROW ); + xModifiable->addModifyListener( static_cast<util::XModifyListener*>(this) ); + } + catch( const uno::Exception& ) + {} + } + + if ( !m_bLink ) + setTitle(m_aDocumentNamePart); + } + } + catch( const uno::Exception& ) + { + OSL_FAIL( "Can not show the frame!" ); + } + +} + +void DocumentHolder::resizeWin( const SIZEL& rNewSize ) +{ + LockedEmbedDocument_Impl aDocLock; + + if ( m_xOleAccess.is() ) + aDocLock = m_xOleAccess->GetEmbedDocument(); + + if ( m_xFrame.is() && aDocLock.GetEmbedDocument() ) + { + uno::Reference< awt::XWindow > xWindow = m_xFrame->getContainerWindow(); + uno::Reference< awt::XView > xView( xWindow, uno::UNO_QUERY ); + + if ( xWindow.is() && xView.is() ) + { + float fScale = 1; + xView->setZoom( fScale, fScale ); + + SIZEL aOldSize; + GetExtent( &aOldSize ); + + if ( aOldSize.cx != rNewSize.cx || aOldSize.cy != rNewSize.cy ) + { + HDC hdc = GetDC( nullptr ); + SetMapMode( hdc, MM_HIMETRIC ); + + POINT aOldOffset; + aOldOffset.x = aOldSize.cx; + aOldOffset.y = aOldSize.cy; + bool bIsOk = LPtoDP( hdc, &aOldOffset, 1 ); + + POINT aNewOffset; + aNewOffset.x = rNewSize.cx; + aNewOffset.y = rNewSize.cy; + bIsOk = LPtoDP( hdc, &aNewOffset, 1 ); + + ReleaseDC( nullptr, hdc ); + + awt::Rectangle aWinRect = xWindow->getPosSize(); + + sal_Int32 aWidthDelta = aWinRect.Width - aOldOffset.x; + sal_Int32 aHeightDelta = aWinRect.Height - aOldOffset.y; + + if ( aWidthDelta > 0 && aHeightDelta > 0 ) + xWindow->setPosSize(0, + 0, + aNewOffset.x + aWidthDelta, + aNewOffset.y + aHeightDelta, + awt::PosSize::SIZE ); + } + } + } +} + +void DocumentHolder::setTitle(const OUString& aDocumentName) +{ + if(m_xFrame.is()) + { + if(m_aFilterName.getLength() == 0) + { + OUString aFilterName; + uno::Sequence<beans::PropertyValue> aSeq; + if(m_xDocument.is()) + { + aSeq = m_xDocument->getArgs(); + for(beans::PropertyValue const & prop : std::as_const(aSeq)) + { + if(prop.Name == "FilterName") + { + prop.Value >>= aFilterName; + break; + } + } + } + + if(aFilterName.getLength()) + { + uno::Reference<container::XNameAccess> xNameAccess( + m_xFactory->createInstance("com.sun.star.document.FilterFactory"), + uno::UNO_QUERY); + try { + if(xNameAccess.is() && + (xNameAccess->getByName(aFilterName) >>= aSeq)) + { + for(beans::PropertyValue const & prop : std::as_const(aSeq)) + if(prop.Name == "UIName") + { + prop.Value >>= m_aFilterName; + break; + } + } + } + catch(const uno::Exception& ) { + // nothing better to do here + m_aFilterName = aFilterName; + } + } + } + // set the title + static const sal_Unicode u[] = { ' ','(',0 }; + static const sal_Unicode c[] = { ')',0 }; + OUString aTotalName(m_aFilterName); + aTotalName += OUString(u); + aTotalName += aDocumentName; + aTotalName += OUString(c); + try { + m_xFrame->setTitle( aTotalName ); + } + catch( const uno::Exception& ) { + } + } + + m_aDocumentNamePart = aDocumentName; + + if(m_pInterceptor) + { + ::osl::ClearableMutexGuard aGuard( m_aMutex ); + + Interceptor* pTmpInter = nullptr; + uno::Reference< frame::XDispatchProviderInterceptor > xLock( m_xInterceptorLocker ); + if ( xLock.is() && m_pInterceptor ) + pTmpInter = m_pInterceptor; + + aGuard.clear(); + + if ( pTmpInter ) + pTmpInter->generateFeatureStateEvent(); + } +} + + +void DocumentHolder::setContainerName(const OUString& aContainerName) +{ + m_aContainerName = aContainerName; +} + + +void DocumentHolder::hide() +{ + if(m_xFrame.is()) m_xFrame->deactivate(); + + //todo: sendadvise + // after hiding the window it is always allowed to InPlaceActivate it + m_bAllowInPlace = true; +} + +IDispatch* DocumentHolder::GetIDispatch() +{ + if ( !m_pIDispatch && m_xDocument.is() ) + { + const OUString aServiceName ( + "com.sun.star.bridge.OleBridgeSupplier2" ); + uno::Reference< bridge::XBridgeSupplier2 > xSupplier( + m_xFactory->createInstance( aServiceName ), uno::UNO_QUERY ); + + if ( xSupplier.is() ) + { + uno::Sequence< sal_Int8 > aProcId( 16 ); + rtl_getGlobalProcessId( reinterpret_cast<sal_uInt8*>(aProcId.getArray()) ); + + try { + uno::Any anyResult = xSupplier->createBridge( + uno::makeAny( m_xDocument ), + aProcId, + bridge::ModelDependent::UNO, + bridge::ModelDependent::OLE ); + + if ( auto var = o3tl::tryAccess<sal_uIntPtr>(anyResult) ) + { + VARIANT* pVariant = reinterpret_cast<VARIANT*>(*var); + if ( pVariant->vt == VT_DISPATCH ) + m_pIDispatch = pVariant->pdispVal; + + VariantClear( pVariant ); + CoTaskMemFree( pVariant ); + } + } + catch ( const uno::Exception& ) + {} + } + } + + return m_pIDispatch; +} + +HRESULT DocumentHolder::GetDocumentBorder( RECT *pRect ) +{ + if ( pRect && m_xDocument.is() ) + { + const uno::Sequence< beans::PropertyValue > aArgs = m_xDocument->getArgs(); + for ( beans::PropertyValue const & prop : aArgs ) + if ( prop.Name == "DocumentBorder" ) + { + uno::Sequence< sal_Int32 > aRect; + if ( ( prop.Value >>= aRect ) && aRect.getLength() == 4 ) + { + pRect->left = aRect[0]; + pRect->top = aRect[1]; + pRect->right = aRect[2]; + pRect->bottom = aRect[3]; + + return S_OK; + } + + break; + } + } + + return E_FAIL; +} + +HRESULT DocumentHolder::SetExtent( const SIZEL *pSize ) +{ + if ( pSize ) + { + uno::Reference< embed::XVisualObject > xVisObj( m_xDocument, uno::UNO_QUERY ); + if ( xVisObj.is() ) + { + try + { + awt::Size aNewSize( pSize->cx, pSize->cy ); + + sal_Int32 aMapMode = xVisObj->getMapUnit( DVASPECT_CONTENT ); + + // TODO/LATER: in future UNO API should be used for the conversion, currently there is no + if ( aMapMode == embed::EmbedMapUnits::TWIP ) + { + // conversion from ONE_100TH_MM + aNewSize.Width = aNewSize.Width * 144 / 254; + aNewSize.Height = aNewSize.Height * 144 / 254; + } + + + xVisObj->setVisualAreaSize( DVASPECT_CONTENT, aNewSize ); + + return S_OK; + } + catch( const uno::Exception& ) + {} + } + } + + return E_FAIL; +} + +HRESULT DocumentHolder::GetExtent( SIZEL *pSize ) +{ + if ( pSize ) + { + uno::Reference< embed::XVisualObject > xVisObj( m_xDocument, uno::UNO_QUERY ); + if ( xVisObj.is() ) + { + try + { + awt::Size aDocSize = xVisObj->getVisualAreaSize( DVASPECT_CONTENT ); + + sal_Int32 aMapMode = xVisObj->getMapUnit( DVASPECT_CONTENT ); + + // TODO/LATER: in future UNO API should be used for the conversion, currently there is no + if ( aMapMode == embed::EmbedMapUnits::TWIP ) + { + // conversion to ONE_100TH_MM + aDocSize.Width = aDocSize.Width * 254 / 144; + aDocSize.Height = aDocSize.Height * 254 / 144; + } + + pSize->cx = aDocSize.Width; + pSize->cy = aDocSize.Height; + + return S_OK; + } + catch( const uno::Exception& ) + {} + } + } + + return E_FAIL; +} + + +HRESULT DocumentHolder::SetContRects(LPCRECT aRect) +{ + if(m_xContainerWindow.is()) { + RECT wi = {}; + if(m_pIOleIPFrame) { + m_pIOleIPFrame->GetBorder(&wi); + m_xContainerWindow->setPosSize( + 0,0, + wi.right - wi.left, + wi.bottom - wi.top, + awt::PosSize::POSSIZE); + } + else + m_xContainerWindow->setPosSize( + 0,0, + aRect->right - aRect->left, + aRect->bottom - aRect->top, + awt::PosSize::POSSIZE); + return NOERROR; + } + else { + return ERROR; + } +} + + +HRESULT DocumentHolder::SetObjectRects(LPCRECT aRect, LPCRECT aClip) +{ + auto rect = *aRect; + rect.left -= m_aBorder.left; + rect.right += m_aBorder.right; + rect.top -= m_aBorder.top; + rect.bottom += m_aBorder.bottom; + auto clip = *aClip; + clip.left -= m_aBorder.left; + clip.right += m_aBorder.right; + clip.top -= m_aBorder.top; + clip.bottom += m_aBorder.bottom; + + if(m_pCHatchWin) + m_pCHatchWin->RectsSet(&rect, &clip); + if(m_xEditWindow.is()) { + m_xEditWindow->setVisible(false); + m_xEditWindow->setPosSize( + m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0, + m_pCHatchWin ? HATCHWIN_BORDERWIDTHDEFAULT : 0, + rect.right - rect.left, + rect.bottom - rect.top, + awt::PosSize::POSSIZE); + m_xEditWindow->setVisible(true); + } + return NOERROR; +} + + +css::uno::Reference< css::awt::XWindow> SAL_CALL DocumentHolder::getContainerWindow() +{ + if(m_xContainerWindow.is()) + return m_xContainerWindow; + + uno::Reference<awt::XWindow> xWin; + + uno::Reference<awt::XToolkit2> xToolkit = awt::Toolkit::create( comphelper::getComponentContext(m_xFactory) ); + + if(m_pIOleIPFrame) { + HWND hWnd; + m_pIOleIPFrame->GetWindow(&hWnd); + + uno::Sequence<sal_Int8> aProcessIdent(16); + rtl_getGlobalProcessId(reinterpret_cast<sal_uInt8*>(aProcessIdent.getArray())); + + xWin.set( + xToolkit->createSystemChild( + uno::Any(sal_Int64(hWnd)), + aProcessIdent, + lang::SystemDependent::SYSTEM_WIN32), + uno::UNO_QUERY); + + RECT wi = {}; + if(xWin.is() && m_pIOleIPFrame->GetBorder(&wi) == NOERROR) { + xWin->setVisible(true); + xWin->setPosSize( + 0,0, + wi.right-wi.left, + wi.bottom - wi.top, + awt::PosSize::POSSIZE); + + uno::Reference<awt::XSystemDependentWindowPeer> xSysWin( + xWin,uno::UNO_QUERY); + if(xSysWin.is()) { + uno::Any aAny = xSysWin->getWindowHandle( + aProcessIdent,lang::SystemDependent::SYSTEM_WIN32); + sal_Int64 tmp; + if( aAny >>= tmp ) + SetContainerWindowHandle(reinterpret_cast<HWND>(tmp)); + } + } + } + + m_xContainerWindow= xWin; + return xWin; +} + + +sal_Bool SAL_CALL DocumentHolder::requestDockingAreaSpace( const css::awt::Rectangle& RequestedSpace ) +{ + if(m_bOnDeactivate) + return true; + + BORDERWIDTHS bw; + SetRect(&bw, + RequestedSpace.X,RequestedSpace.Y, + RequestedSpace.Width,RequestedSpace.Height); + if( m_pIOleIPFrame ) + return m_pIOleIPFrame->RequestBorderSpace(&bw) == NOERROR ; + else + return false; +} + + +void SAL_CALL DocumentHolder::setDockingAreaSpace( const css::awt::Rectangle& BorderSpace ) +{ + if(m_bOnDeactivate) + return; + + BORDERWIDTHS bw; + SetRect(&bw, + BorderSpace.X,BorderSpace.Y, + BorderSpace.Width,BorderSpace.Height); + if( m_pIOleIPFrame ) { + RECT aRect; + GetClientRect(m_hWndxWinCont,&aRect); + HRGN hrgn1 = CreateRectRgn( + 0,0, + aRect.right,BorderSpace.Y); + HRGN hrgn2 = CreateRectRgn(aRect.right-BorderSpace.Width,0,aRect.right,aRect.bottom); + CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR); + DeleteObject(hrgn2); + hrgn2 = CreateRectRgn(0,aRect.bottom-BorderSpace.Height,aRect.right,aRect.bottom); + CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR); + DeleteObject(hrgn2); + hrgn2 = CreateRectRgn(0,0,BorderSpace.X,aRect.bottom); + CombineRgn(hrgn1,hrgn1,hrgn2,RGN_OR); + DeleteObject(hrgn2); + + SetWindowRgn(m_hWndxWinCont,hrgn1,true); + // not:: DeleteObject(hrgn1); + m_pIOleIPFrame->SetBorderSpace(&bw); + } +} + + +void SAL_CALL DocumentHolder::disposing( const css::lang::EventObject& aSource ) +{ + if ( m_xDocument.is() && m_xDocument == aSource.Source ) + { + m_pIDispatch = nullptr; + m_xDocument.clear(); + } + + if( m_xFrame.is() && m_xFrame == aSource.Source ) + m_xFrame.clear(); +} + + +void SAL_CALL +DocumentHolder::queryClosing( + const lang::EventObject& aSource, + sal_Bool /*bGetsOwnership*/ +) +{ + if (!m_bLink + && ((m_xDocument.is() && m_xDocument == aSource.Source) + || (m_xFrame.is() && m_xFrame == aSource.Source))) + throw util::CloseVetoException(); +} + + +void SAL_CALL +DocumentHolder::notifyClosing( + const lang::EventObject& aSource ) +{ + try + { + uno::Reference< util::XCloseBroadcaster > xEventBroadcaster( + aSource.Source, uno::UNO_QUERY_THROW ); + xEventBroadcaster->removeCloseListener( static_cast<util::XCloseListener*>(this) ); + } + catch( const uno::Exception& ) + {} + + if ( m_xDocument.is() && m_xDocument == aSource.Source ) + { + // can happen only in case of links + m_pIDispatch = nullptr; + m_xDocument.clear(); + m_xFrame.clear(); + + LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument(); + if ( aDocLock.GetEmbedDocument() ) + aDocLock.GetEmbedDocument()->OLENotifyClosing(); + } + else if( m_xFrame.is() && m_xFrame == aSource.Source ) + m_xFrame.clear(); +} + +void SAL_CALL +DocumentHolder::queryTermination( + const lang::EventObject& /*aSource*/ +) +{ + if ( m_xDocument.is() ) + throw frame::TerminationVetoException(); +} + +void SAL_CALL +DocumentHolder::notifyTermination( + const lang::EventObject& aSource +) +{ + OSL_ENSURE( !m_xDocument.is(), "Just a disaster..." ); + uno::Reference< frame::XDesktop > xDesktop( + aSource.Source, uno::UNO_QUERY ); + + if ( xDesktop.is() ) + xDesktop->removeTerminateListener( static_cast<frame::XTerminateListener*>(this) ); +} + + +void SAL_CALL DocumentHolder::modified( const lang::EventObject& /*aEvent*/ ) +{ + if ( m_xOleAccess.is() ) + { + LockedEmbedDocument_Impl aDocLock = m_xOleAccess->GetEmbedDocument(); + if ( aDocLock.GetEmbedDocument() ) + aDocLock.GetEmbedDocument()->notify(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/ed_idataobj.cxx b/embedserv/source/embed/ed_idataobj.cxx new file mode 100644 index 000000000..2f0b4d960 --- /dev/null +++ b/embedserv/source/embed/ed_idataobj.cxx @@ -0,0 +1,293 @@ +/* -*- 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 <embeddoc.hxx> + +#include <com/sun/star/uno/Any.h> +#include <com/sun/star/uno/Exception.hpp> +#include <com/sun/star/datatransfer/XTransferable.hpp> + + +#include <osl/thread.h> + +using namespace ::com::sun::star; + + +// EmbedDocument_Impl + + +sal_uInt64 EmbedDocument_Impl::getMetaFileHandle_Impl( bool isEnhMeta ) +{ + sal_uInt64 pResult = NULL; + + uno::Reference< datatransfer::XTransferable > xTransferable( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if ( xTransferable.is() ) + { + datatransfer::DataFlavor aFlavor; + + if ( isEnhMeta ) + { + aFlavor.MimeType = "application/x-openoffice-emf;windows_formatname=\"Image EMF\""; + aFlavor.HumanPresentableName = "Enhanced Windows MetaFile"; + } + else + { + aFlavor.MimeType = "application/x-openoffice-wmf;windows_formatname=\"Image WMF\""; + aFlavor.HumanPresentableName = "Windows GDIMetaFile"; + } + + aFlavor.DataType = cppu::UnoType<sal_uInt64>::get(); + + uno::Any aAny = xTransferable->getTransferData( aFlavor ); + aAny >>= pResult; + } + + return pResult; +} + + +// IDataObject + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetData( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) +{ + if ( !pFormatetc ) + return DV_E_FORMATETC; + + if ( !pMedium ) + return STG_E_MEDIUMFULL; + + if ( pFormatetc->dwAspect == DVASPECT_THUMBNAIL + || pFormatetc->dwAspect == DVASPECT_ICON + || pFormatetc->dwAspect == DVASPECT_DOCPRINT ) + return DV_E_DVASPECT; + + if ( pFormatetc->cfFormat == CF_ENHMETAFILE ) + { + if ( !( pFormatetc->tymed & TYMED_ENHMF ) ) + return DV_E_TYMED; + + HENHMETAFILE hMeta = reinterpret_cast<HENHMETAFILE>( getMetaFileHandle_Impl( true ) ); + + if ( hMeta ) + { + pMedium->tymed = TYMED_ENHMF; + pMedium->hEnhMetaFile = hMeta; + pMedium->pUnkForRelease = nullptr; + + return S_OK; + } + + return STG_E_MEDIUMFULL; + } + else if ( pFormatetc->cfFormat == CF_METAFILEPICT ) + { + if ( !( pFormatetc->tymed & TYMED_MFPICT ) ) + return DV_E_TYMED; + + HGLOBAL hMeta = reinterpret_cast<HGLOBAL>( getMetaFileHandle_Impl( false ) ); + + if ( hMeta ) + { + pMedium->tymed = TYMED_MFPICT; + pMedium->hMetaFilePict = hMeta; + pMedium->pUnkForRelease = nullptr; + + return S_OK; + } + + return STG_E_MEDIUMFULL; + } + else + { + CLIPFORMAT cf_embSource = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embed Source" )); + CLIPFORMAT cf_embObj = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + if ( pFormatetc->cfFormat == cf_embSource || pFormatetc->cfFormat == cf_embObj ) + { + if ( !( pFormatetc->tymed & TYMED_ISTORAGE ) ) + return DV_E_TYMED; + + CComPtr< IStorage > pNewStg; + HRESULT hr = StgCreateDocfile( nullptr, STGM_CREATE | STGM_READWRITE | STGM_DELETEONRELEASE, 0, &pNewStg ); + if ( FAILED( hr ) || !pNewStg ) return STG_E_MEDIUMFULL; + + hr = SaveTo_Impl( pNewStg ); + if ( FAILED( hr ) ) return STG_E_MEDIUMFULL; + + pMedium->tymed = TYMED_ISTORAGE; + pMedium->pstg = pNewStg; + pMedium->pstg->AddRef(); + pMedium->pUnkForRelease = static_cast<IUnknown*>(pNewStg); + + return S_OK; + } + } + + return DV_E_FORMATETC; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) +{ + if ( !pFormatetc ) + return DV_E_FORMATETC; + + if ( !pMedium ) + return STG_E_MEDIUMFULL; + + if ( pFormatetc->dwAspect == DVASPECT_THUMBNAIL + || pFormatetc->dwAspect == DVASPECT_ICON + || pFormatetc->dwAspect == DVASPECT_DOCPRINT ) + return DV_E_DVASPECT; + + CLIPFORMAT cf_embSource = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embed Source" )); + CLIPFORMAT cf_embObj = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + + if ( pFormatetc->cfFormat == cf_embSource || pFormatetc->cfFormat == cf_embObj ) + { + if ( !( pFormatetc->tymed & TYMED_ISTORAGE ) ) + return DV_E_TYMED; + + if ( !pMedium->pstg ) return STG_E_MEDIUMFULL; + + HRESULT hr = SaveTo_Impl( pMedium->pstg ); + if ( FAILED( hr ) ) return STG_E_MEDIUMFULL; + + pMedium->tymed = TYMED_ISTORAGE; + pMedium->pUnkForRelease = nullptr; + + return S_OK; + } + + return DV_E_FORMATETC; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::QueryGetData( FORMATETC * pFormatetc ) +{ + if ( pFormatetc ) + { + if ( pFormatetc->dwAspect == DVASPECT_THUMBNAIL + || pFormatetc->dwAspect == DVASPECT_ICON + || pFormatetc->dwAspect == DVASPECT_DOCPRINT ) + return DV_E_DVASPECT; + + if ( pFormatetc->cfFormat == CF_ENHMETAFILE ) + { + if ( !( pFormatetc->tymed & TYMED_ENHMF ) ) + return DV_E_TYMED; + + return S_OK; + } + else if ( pFormatetc->cfFormat == CF_METAFILEPICT ) + { + if ( !( pFormatetc->tymed & TYMED_MFPICT ) ) + return DV_E_TYMED; + + return S_OK; + } + else + { + CLIPFORMAT cf_embSource = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embed Source" )); + CLIPFORMAT cf_embObj = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + if ( pFormatetc->cfFormat == cf_embSource || pFormatetc->cfFormat == cf_embObj ) + { + if ( !( pFormatetc->tymed & TYMED_ISTORAGE ) ) + return DV_E_TYMED; + + return S_OK; + } + } + } + + return DV_E_FORMATETC; + +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetCanonicalFormatEtc( FORMATETC * pFormatetcIn, FORMATETC * pFormatetcOut ) +{ + if ( !pFormatetcIn || !pFormatetcOut ) + return DV_E_FORMATETC; + + pFormatetcOut->ptd = nullptr; + pFormatetcOut->cfFormat = pFormatetcIn->cfFormat; + pFormatetcOut->dwAspect = DVASPECT_CONTENT; + + if ( pFormatetcIn->cfFormat == CF_ENHMETAFILE ) + { + pFormatetcOut->tymed = TYMED_ENHMF; + return S_OK; + } + else if ( pFormatetcIn->cfFormat == CF_METAFILEPICT ) + { + pFormatetcOut->tymed = TYMED_MFPICT; + return S_OK; + } + else + { + CLIPFORMAT cf_embSource = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embed Source" )); + CLIPFORMAT cf_embObj = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + if ( pFormatetcIn->cfFormat == cf_embSource || pFormatetcIn->cfFormat == cf_embObj ) + { + pFormatetcOut->tymed = TYMED_ISTORAGE; + return S_OK; + } + } + + return DV_E_FORMATETC; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetData( FORMATETC * /*pFormatetc*/, STGMEDIUM * /*pMedium*/, BOOL /*fRelease*/ ) +{ + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC ** /*ppFormatetc*/ ) +{ + if ( dwDirection == DATADIR_GET ) + return OLE_S_USEREG; + + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection ) +{ + if ( !m_pDAdviseHolder ) + if ( !SUCCEEDED( CreateDataAdviseHolder( &m_pDAdviseHolder ) ) || !m_pDAdviseHolder ) + return E_OUTOFMEMORY; + + return m_pDAdviseHolder->Advise( static_cast<IDataObject*>(this), pFormatetc, advf, pAdvSink, pdwConnection ); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::DUnadvise( DWORD dwConnection ) +{ + if ( !m_pDAdviseHolder ) + if ( !SUCCEEDED( CreateDataAdviseHolder( &m_pDAdviseHolder ) ) || !m_pDAdviseHolder ) + return E_OUTOFMEMORY; + + return m_pDAdviseHolder->Unadvise( dwConnection ); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise ) +{ + if ( !m_pDAdviseHolder ) + if ( !SUCCEEDED( CreateDataAdviseHolder( &m_pDAdviseHolder ) ) || !m_pDAdviseHolder ) + return E_OUTOFMEMORY; + + return m_pDAdviseHolder->EnumAdvise( ppenumAdvise ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/ed_iinplace.cxx b/embedserv/source/embed/ed_iinplace.cxx new file mode 100644 index 000000000..0c6e869e6 --- /dev/null +++ b/embedserv/source/embed/ed_iinplace.cxx @@ -0,0 +1,87 @@ +/* -*- 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 <embeddoc.hxx> +#include <osl/diagnose.h> + + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetWindow(HWND *hWnd) +{ + OSL_ENSURE(m_pDocHolder,"no document for inplace activation"); + + *hWnd = m_pDocHolder->GetTopMostWinHandle(); + if(*hWnd != nullptr) + return NOERROR; + else + return ERROR; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::ContextSensitiveHelp(BOOL) +{ + return NOERROR; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::InPlaceDeactivate() +{ + // no locking is used since the OLE must use the same thread always + if ( m_bIsInVerbHandling ) + return E_UNEXPECTED; + + BooleanGuard_Impl aGuard( m_bIsInVerbHandling ); + + m_pDocHolder->InPlaceDeactivate(); + + // the inplace object needs the notification after the storing ( on deactivating ) + // if it happens before the storing the replacement might not be updated + notify(); + + return NOERROR; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::UIDeactivate() +{ + // no locking is used since the OLE must use the same thread always + if ( m_bIsInVerbHandling ) + return E_UNEXPECTED; + + BooleanGuard_Impl aGuard( m_bIsInVerbHandling ); + + + m_pDocHolder->UIDeactivate(); + + // the inplace object needs the notification after the storing ( on deactivating ) + // if it happens before the storing the replacement might not be updated + notify(); + + return NOERROR; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetObjectRects(LPCRECT aRect, LPCRECT aClip) +{ + OSL_ENSURE(m_pDocHolder,"no document for inplace activation"); + + return m_pDocHolder->SetObjectRects(aRect,aClip); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::ReactivateAndUndo() +{ + return E_NOTIMPL; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/ed_ioleobject.cxx b/embedserv/source/embed/ed_ioleobject.cxx new file mode 100644 index 000000000..a84b1c2bd --- /dev/null +++ b/embedserv/source/embed/ed_ioleobject.cxx @@ -0,0 +1,470 @@ +/* -*- 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 <embeddoc.hxx> +#include <osl/diagnose.h> +#include <o3tl/char16_t2wchar_t.hxx> +#include <com/sun/star/beans/PropertyValue.hpp> + + +using namespace ::com::sun::star; + +// IOleObject + + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetClientSite( IOleClientSite* pSite ) +{ + m_pClientSite = pSite; + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetClientSite( IOleClientSite** pSite ) +{ + *pSite = m_pClientSite; + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetHostNames( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj ) +{ + // the code should be ignored for links + if ( !m_aFileName.getLength() ) + { + m_pDocHolder->setTitle(o3tl::toU(szContainerObj)); + m_pDocHolder->setContainerName(o3tl::toU(szContainerApp)); + } + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Close( DWORD dwSaveOption ) +{ + HRESULT hr = S_OK; + + if ( m_pDocHolder->HasFrame() ) + { + if ( dwSaveOption == 2 && m_aFileName.getLength() ) + { + // ask the user about saving + if ( m_pDocHolder->ExecuteSuspendCloseFrame() ) + { + m_pDocHolder->CloseDocument(); + return S_OK; + } + else + return OLE_E_PROMPTSAVECANCELLED; + } + + if ( dwSaveOption != 1 ) + hr = SaveObject(); // ADVF_DATAONSTOP); + + m_pDocHolder->CloseFrame(); + OLENotifyDeactivation(); + } + + m_pDocHolder->FreeOffice(); + m_pDocHolder->CloseDocument(); + + OLENotifyClosing(); + + return hr; +} + + +HRESULT EmbedDocument_Impl::OLENotifyClosing() +{ + AdviseSinkHashMap aAHM(m_aAdviseHashMap); + + for (auto const& advise : aAHM) + { + if (advise.second) + advise.second->OnClose(); + } + + return S_OK; + +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetMoniker( DWORD /*dwWhichMoniker*/, IMoniker * /*pmk*/ ) +{ + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetMoniker( DWORD /*dwAssign*/, DWORD /*dwWhichMoniker*/, IMoniker ** /*ppmk*/ ) +{ + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::InitFromData( IDataObject * /*pDataObject*/, BOOL /*fCreation*/, DWORD /*dwReserved*/ ) +{ + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetClipboardData( DWORD /*dwReserved*/, IDataObject ** /*ppDataObject*/ ) +{ + return E_NOTIMPL; +} + +/** + * Well, this is a not so very inefficient way to deliver + * + */ + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::DoVerb( + LONG iVerb, + LPMSG, + IOleClientSite *pActiveSite, + LONG, + HWND, + LPCRECT ) +{ + // no locking is used since the OLE must use the same thread always + if ( m_bIsInVerbHandling ) + return OLEOBJ_S_CANNOT_DOVERB_NOW; + + // an object can not handle any Verbs in Hands off mode + if ( m_pMasterStorage == nullptr || m_pOwnStream == nullptr ) + return OLE_E_CANT_BINDTOSOURCE; + + + BooleanGuard_Impl aGuard( m_bIsInVerbHandling ); + + if ( iVerb == OLEIVERB_PRIMARY ) + { + if ( m_aFileName.getLength() ) + { + // that should be a link + iVerb = OLEIVERB_OPEN; + } + else + iVerb = OLEIVERB_SHOW; + } + + try + { + switch(iVerb) { + case OLEIVERB_DISCARDUNDOSTATE: + // free any undostate? + break; + case OLEIVERB_INPLACEACTIVATE: + OSL_ENSURE(m_pDocHolder,"no document for inplace activation"); + + return m_pDocHolder->InPlaceActivate(pActiveSite,FALSE); + case OLEIVERB_UIACTIVATE: + OSL_ENSURE(m_pDocHolder,"no document for inplace activation"); + + return m_pDocHolder->InPlaceActivate(pActiveSite,TRUE); + case OLEIVERB_PRIMARY: + case OLEIVERB_SHOW: + OSL_ENSURE(m_pDocHolder,"no document for inplace activation"); + + if(m_pDocHolder->isActive()) + return NOERROR; //Already active + + if(SUCCEEDED( + m_pDocHolder->InPlaceActivate( + pActiveSite,TRUE))) + return NOERROR; + + [[fallthrough]]; + case OLEIVERB_OPEN: + OSL_ENSURE(m_pDocHolder,"no document to open"); + + // the commented code could be useful in case + // outer window would be resized depending from inner one + // RECTL aEmbArea; + // m_pDocHolder->GetVisArea( &aEmbArea ); + // m_pDocHolder->show(); + // m_pDocHolder->SetVisArea( &aEmbArea ); + + if(m_pDocHolder->isActive()) + { + m_pDocHolder->InPlaceDeactivate(); + m_pDocHolder->DisableInplaceActivation(true); + } + + SIZEL aEmbSize; + m_pDocHolder->GetExtent( &aEmbSize ); + m_pDocHolder->show(); + m_pDocHolder->resizeWin( aEmbSize ); + + if ( m_pClientSite ) + m_pClientSite->OnShowWindow( TRUE ); + + notify(); + break; + case OLEIVERB_HIDE: + OSL_ENSURE(m_pDocHolder,"no document to hide"); + + if(m_pDocHolder->isActive()) + m_pDocHolder->InPlaceDeactivate(); + else { + m_pDocHolder->hide(); + + if( m_pClientSite ) + m_pClientSite->OnShowWindow(FALSE); + } + break; + default: + break; + } + } + catch( const uno::Exception& ) + { + return OLEOBJ_S_CANNOT_DOVERB_NOW; + } + + return NOERROR; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::EnumVerbs( IEnumOLEVERB ** /*ppEnumOleVerb*/ ) +{ + return OLE_S_USEREG; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Update() +{ + return S_OK; +// HRESULT hr = CACHE_E_NOCACHE_UPDATED; +// return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::IsUpToDate() +{ + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetUserClassID( CLSID *pClsid ) +{ + return GetClassID( pClsid ); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetUserType( DWORD /*dwFormOfTypeUe*/, LPOLESTR * /*pszUserType*/ ) +{ + return OLE_S_USEREG; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetExtent( DWORD /*dwDrawAspect*/, SIZEL *psizel ) +{ + if ( !psizel ) + return E_FAIL; + + m_pDocHolder->SetExtent( psizel ); + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetExtent( DWORD /*dwDrawAspect*/, SIZEL * psizel ) +{ + if ( !psizel ) + return E_INVALIDARG; + + if ( FAILED( m_pDocHolder->GetExtent( psizel ) ) ) + { + // return default values + psizel->cx = 500; + psizel->cy = 500; + } + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Advise( IAdviseSink *pAdvSink, DWORD *pdwConnection ) +{ + if ( m_nAdviseNum == 0xFFFFFFFF ) + return E_OUTOFMEMORY; + + pAdvSink->AddRef(); + m_aAdviseHashMap.insert( std::pair< DWORD, IAdviseSink* >( m_nAdviseNum, pAdvSink ) ); + *pdwConnection = m_nAdviseNum++; + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Unadvise( DWORD dwConnection ) +{ + auto iAdvise = m_aAdviseHashMap.find( dwConnection ); + if ( iAdvise != m_aAdviseHashMap.end() ) + { + iAdvise->second->Release(); + m_aAdviseHashMap.erase( iAdvise ); + } + else + return OLE_E_NOCONNECTION; + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::EnumAdvise( IEnumSTATDATA ** /*ppenumAdvise*/ ) +{ + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetMiscStatus( DWORD /*dwAspect*/, DWORD * /*pdwStatus*/ ) +{ + return OLE_S_USEREG; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SetColorScheme( LOGPALETTE * /*pLogpal*/ ) +{ + return E_NOTIMPL; +} + + +// IDispatch + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetTypeInfoCount( unsigned int FAR* pctinfo ) +{ + if ( m_pDocHolder->GetIDispatch() ) + return m_pDocHolder->GetIDispatch()->GetTypeInfoCount( pctinfo ); + + return E_NOTIMPL; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetTypeInfo( unsigned int iTInfo, LCID lcid, ITypeInfo FAR* FAR* ppTInfo ) +{ + if ( m_pDocHolder->GetIDispatch() ) + return m_pDocHolder->GetIDispatch()->GetTypeInfo( iTInfo, lcid, ppTInfo ); + + return DISP_E_BADINDEX; // the only error that can be returned +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetIDsOfNames( REFIID riid, + OLECHAR FAR* FAR* rgszNames, + unsigned int cNames, + LCID lcid, + DISPID FAR* rgDispId ) +{ + if ( m_pDocHolder->GetIDispatch() ) + return m_pDocHolder->GetIDispatch()->GetIDsOfNames( riid, rgszNames, cNames, lcid, rgDispId ); + + for ( unsigned int ind = 0; ind < cNames; ind++ ) + rgDispId[ind] = DISPID_UNKNOWN; + + return DISP_E_UNKNOWNNAME; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Invoke( DISPID dispIdMember, + REFIID riid, + LCID lcid, + WORD wFlags, + DISPPARAMS FAR* pDispParams, + VARIANT FAR* pVarResult, + EXCEPINFO FAR* pExcepInfo, + unsigned int FAR* puArgErr ) +{ + if ( m_pDocHolder->GetIDispatch() ) + return m_pDocHolder->GetIDispatch()->Invoke( dispIdMember, + riid, + lcid, + wFlags, + pDispParams, + pVarResult, + pExcepInfo, + puArgErr ); + + return DISP_E_MEMBERNOTFOUND; +} + + +// IExternalConnection + +DWORD STDMETHODCALLTYPE EmbedDocument_Impl::AddConnection( DWORD , DWORD ) +{ + return AddRef(); +} + +DWORD STDMETHODCALLTYPE EmbedDocument_Impl::ReleaseConnection( DWORD , DWORD , BOOL ) +{ + return Release(); +} + +// C++ - methods + +HRESULT EmbedDocument_Impl::SaveObject() +{ + HRESULT hr = S_OK; + + if(m_pClientSite) { + hr = m_pClientSite->SaveObject(); + + for (auto const& advise : m_aAdviseHashMap) + if (advise.second) + advise.second->OnSave(); + } + else if ( m_aFileName.getLength() && IsDirty() == S_OK ) + { + OUString aPreservFileName = m_aFileName; + + // in case of links the containers does not provide client site sometimes + hr = Save( static_cast<LPCOLESTR>(nullptr), FALSE ); // triggers saving to the link location + SaveCompleted(o3tl::toW(aPreservFileName.getStr())); + } + + notify( false ); + + return hr; +} + + +HRESULT EmbedDocument_Impl::ShowObject() +{ + HRESULT hr = S_OK; + + if(m_pClientSite) + hr = m_pClientSite->ShowObject(); + + return hr; +} + + +void EmbedDocument_Impl::notify( bool bDataChanged ) +{ + for (auto const& advise : m_aAdviseHashMap) + if (advise.second) + advise.second->OnViewChange( DVASPECT_CONTENT, -1 ); + + if ( m_pDAdviseHolder && bDataChanged ) + m_pDAdviseHolder->SendOnDataChange( static_cast<IDataObject*>(this), 0, 0 ); +} + +void EmbedDocument_Impl::Deactivate() +{ + HRESULT hr = S_OK; + + if ( m_pDocHolder->HasFrame() ) + { + hr = SaveObject(); + m_pDocHolder->CloseFrame(); + OLENotifyDeactivation(); + } +} + +HRESULT EmbedDocument_Impl::OLENotifyDeactivation() +{ + HRESULT hr = S_OK; + + if ( m_pClientSite ) + hr = m_pClientSite->OnShowWindow( FALSE ); + + return hr; + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/ed_ipersiststr.cxx b/embedserv/source/embed/ed_ipersiststr.cxx new file mode 100644 index 000000000..905055cc9 --- /dev/null +++ b/embedserv/source/embed/ed_ipersiststr.cxx @@ -0,0 +1,973 @@ +/* -*- 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 <string_view> + +#include <embeddoc.hxx> +#include <com/sun/star/uno/Exception.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/io/TempFile.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/io/XOutputStream.hpp> +#include <com/sun/star/io/XSeekable.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/frame/XLoadable.hpp> +#include <com/sun/star/util/XModifiable.hpp> +#include <com/sun/star/frame/XStorable.hpp> +#include <com/sun/star/util/URLTransformer.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> + +#include <comphelper/processfactory.hxx> +#include <o3tl/char16_t2wchar_t.hxx> +#include <osl/mutex.hxx> +#include <osl/diagnose.h> +#include <sal/types.h> + +#include "guid.hxx" + +#include <string.h> + +#define EXT_STREAM_LENGTH 4 + +namespace { + +const sal_Int32 nConstBufferSize = 32000; + +} + +using namespace ::com::sun::star; + +const OUString aOfficeEmbedStreamName( "package_stream" ); +const OUString aExtentStreamName( "properties_stream" ); + +static uno::Reference< io::XInputStream > createTempXInStreamFromIStream( + uno::Reference< lang::XMultiServiceFactory > const & xFactory, + IStream *pStream ) +{ + uno::Reference< io::XInputStream > xResult; + + if ( !pStream ) + return xResult; + + uno::Reference < io::XOutputStream > xTempOut( io::TempFile::create(comphelper::getComponentContext(xFactory)), + uno::UNO_QUERY_THROW ); + ULARGE_INTEGER nNewPos; + LARGE_INTEGER const aZero = { 0, 0 }; + HRESULT hr = pStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos ); + if ( FAILED( hr ) ) return xResult; + + STATSTG aStat; + hr = pStream->Stat( &aStat, STATFLAG_NONAME ); + if ( FAILED( hr ) ) return xResult; + + sal_uInt32 nSize = static_cast<sal_uInt32>(aStat.cbSize.QuadPart); + sal_uInt32 nCopied = 0; + uno::Sequence< sal_Int8 > aBuffer( nConstBufferSize ); + try + { + sal_uInt32 nRead = 0; + do + { + pStream->Read( aBuffer.getArray(), nConstBufferSize, &nRead ); + + if ( nRead < nConstBufferSize ) + aBuffer.realloc( nRead ); + + xTempOut->writeBytes( aBuffer ); + nCopied += nRead; + } while( nRead == nConstBufferSize ); + + if ( nCopied == nSize ) + { + uno::Reference < io::XSeekable > xTempSeek ( xTempOut, uno::UNO_QUERY ); + if ( xTempSeek.is() ) + { + xTempSeek->seek ( 0 ); + xResult.set( xTempOut, uno::UNO_QUERY ); + } + } + } + catch( const uno::Exception& ) + { + } + + return xResult; +} + +static HRESULT copyXTempOutToIStream( uno::Reference< io::XOutputStream > const & xTempOut, IStream* pStream ) +{ + if ( !xTempOut.is() || !pStream ) + return E_FAIL; + + uno::Reference < io::XSeekable > xTempSeek ( xTempOut, uno::UNO_QUERY ); + if ( !xTempSeek.is() ) + return E_FAIL; + + xTempSeek->seek ( 0 ); + + uno::Reference< io::XInputStream > xTempIn ( xTempOut, uno::UNO_QUERY ); + if ( !xTempSeek.is() ) + return E_FAIL; + + // Seek to zero and truncate the stream + ULARGE_INTEGER nNewPos; + LARGE_INTEGER const aZero = { 0, 0 }; + HRESULT hr = pStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos ); + if ( FAILED( hr ) ) return E_FAIL; + ULARGE_INTEGER const aUZero = { 0, 0 }; + hr = pStream->SetSize( aUZero ); + if ( FAILED( hr ) ) return E_FAIL; + + uno::Sequence< sal_Int8 > aBuffer( nConstBufferSize ); + sal_uInt32 nReadBytes = 0; + + do + { + try { + nReadBytes = xTempIn->readBytes( aBuffer, nConstBufferSize ); + } + catch( const uno::Exception& ) + { + return E_FAIL; + } + + sal_uInt32 nWritten = 0; + hr = pStream->Write( aBuffer.getArray(), nReadBytes, &nWritten ); + if ( !SUCCEEDED( hr ) || nWritten != nReadBytes ) + return E_FAIL; + + } while( nReadBytes == nConstBufferSize ); + + return S_OK; +} + + +// EmbedDocument_Impl + + +EmbedDocument_Impl::EmbedDocument_Impl( const uno::Reference< lang::XMultiServiceFactory >& xFactory, const GUID* guid ) +: m_refCount( 0 ) +, m_xFactory( xFactory ) +, m_guid( *guid ) +, m_bIsDirty( false ) +, m_nAdviseNum( 0 ) +, m_bIsInVerbHandling( false ) +//, m_bLoadedFromFile( sal_False ) +{ + m_xOwnAccess = new EmbeddedDocumentInstanceAccess_Impl( this ); + m_pDocHolder = new DocumentHolder( xFactory, m_xOwnAccess ); + m_pDocHolder->acquire(); +} + +EmbedDocument_Impl::~EmbedDocument_Impl() +{ + m_pDocHolder->FreeOffice(); + + if ( m_pDocHolder->HasFrame() && m_pDocHolder->IsLink() ) + { + // a link with frame should be only disconnected, not closed + m_pDocHolder->DisconnectFrameDocument( true ); + } + else + { + m_pDocHolder->CloseDocument(); + m_pDocHolder->CloseFrame(); + } + + m_pDocHolder->release(); +} + +uno::Sequence< beans::PropertyValue > EmbedDocument_Impl::fillArgsForLoading_Impl( uno::Reference< io::XInputStream > const & xStream, DWORD /*nStreamMode*/, LPCOLESTR pFilePath ) +{ + uno::Sequence< beans::PropertyValue > aArgs( 3 ); + + sal_Int32 nInd = 0; // must not be bigger than the preset size + aArgs[nInd].Name = "FilterName"; + aArgs[nInd++].Value <<= getFilterNameFromGUID_Impl( &m_guid ); + + if ( xStream.is() ) + { + aArgs[nInd].Name = "InputStream"; + aArgs[nInd++].Value <<= xStream; + aArgs[nInd].Name = "URL"; + aArgs[nInd++].Value <<= OUString( "private:stream" ); + } + else + { + aArgs[nInd].Name = "URL"; + + OUString sDocUrl; + if ( pFilePath ) + { + uno::Reference< util::XURLTransformer > aTransformer( util::URLTransformer::create(comphelper::getComponentContext(m_xFactory)) ); + util::URL aURL; + + aURL.Complete = o3tl::toU(pFilePath); + + if ( aTransformer->parseSmart( aURL, OUString() ) ) + sDocUrl = aURL.Complete; + } + + aArgs[nInd++].Value <<= sDocUrl; + } + + aArgs.realloc( nInd ); + + // aArgs[].Name = "ReadOnly"; + // aArgs[].Value <<= sal_False; //( ( nStreamMode & ( STGM_READWRITE | STGM_WRITE ) ) ? sal_True : sal_False ); + + return aArgs; +} + +uno::Sequence< beans::PropertyValue > EmbedDocument_Impl::fillArgsForStoring_Impl( uno::Reference< io::XOutputStream > const & xStream) +{ + uno::Sequence< beans::PropertyValue > aArgs( xStream.is() ? 2 : 1 ); + + aArgs[0].Name = "FilterName"; + aArgs[0].Value <<= getFilterNameFromGUID_Impl( &m_guid ); + + if ( xStream.is() ) + { + aArgs[1].Name = "OutputStream"; + aArgs[1].Value <<= xStream; + } + + return aArgs; +} + +HRESULT EmbedDocument_Impl::SaveTo_Impl( IStorage* pStg ) +{ + if ( !pStg || pStg == m_pMasterStorage ) + return E_FAIL; + + // for saveto operation the master storage + // should not enter NoScribble mode + CComPtr< IStream > pOrigOwn = m_pOwnStream; + CComPtr< IStream > pOrigExt = m_pExtStream; + HRESULT hr = Save( pStg, false ); + pStg->Commit( STGC_ONLYIFCURRENT ); + m_pOwnStream = pOrigOwn; + m_pExtStream = pOrigExt; + + return hr; +} + + +// IUnknown + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::QueryInterface( REFIID riid, void FAR* FAR* ppv ) +{ + if(IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppv = static_cast<IUnknown*>(static_cast<IPersistStorage*>(this)); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersist)) + { + AddRef(); + *ppv = static_cast<IPersist*>(static_cast<IPersistStorage*>(this)); + return S_OK; + } + else if (IsEqualIID(riid, IID_IExternalConnection)) + { + AddRef(); + *ppv = static_cast<IExternalConnection*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersistStorage)) + { + AddRef(); + *ppv = static_cast<IPersistStorage*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IDataObject)) + { + AddRef(); + *ppv = static_cast<IDataObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleObject)) + { + AddRef(); + *ppv = static_cast<IOleObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleWindow)) + { + AddRef(); + *ppv = static_cast<IOleWindow*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleInPlaceObject)) + { + AddRef(); + *ppv = static_cast<IOleInPlaceObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersistFile)) + { + AddRef(); + *ppv = static_cast<IPersistFile*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IDispatch)) + { + AddRef(); + *ppv = static_cast<IDispatch*>(this); + return S_OK; + } + + *ppv = nullptr; + return ResultFromScode(E_NOINTERFACE); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) EmbedDocument_Impl::AddRef() +{ + return osl_atomic_increment( &m_refCount); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) EmbedDocument_Impl::Release() +{ + // if there is a time when the last reference is destructed, that means that only internal pointers are alive + // after the following call either the refcount is increased or the pointers are empty + if ( m_refCount == 1 ) + m_xOwnAccess->ClearEmbedDocument(); + + sal_Int32 nCount = osl_atomic_decrement( &m_refCount ); + if ( nCount == 0 ) + delete this; + return nCount; +} + + +// IPersist + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetClassID( CLSID* pClassId ) +{ + *pClassId = m_guid; + return S_OK; +} + + +// IPersistStorage + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::IsDirty() +{ + // the link modified state is controlled by the document + if ( m_bIsDirty && !m_aFileName.getLength() ) + return S_OK; + + uno::Reference< util::XModifiable > xMod( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if ( xMod.is() ) + return xMod->isModified() ? S_OK : S_FALSE; + return S_FALSE; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::InitNew( IStorage *pStg ) +{ + HRESULT hr = CO_E_ALREADYINITIALIZED; + + if ( !m_pDocHolder->GetDocument().is() ) + { + + STATSTG aStat; + hr = pStg->Stat( &aStat, STATFLAG_NONAME ); + if ( FAILED( hr ) ) return E_FAIL; + + DWORD nStreamMode = aStat.grfMode; + + hr = E_FAIL; + if ( m_xFactory.is() && pStg ) + { + uno::Reference< frame::XModel > aDocument( + m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ), + uno::UNO_QUERY ); + if ( aDocument.is() ) + { + m_pDocHolder->SetDocument( aDocument ); + + uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if( xLoadable.is() ) + { + try + { + xLoadable->initNew(); + // xLoadable->load( fillArgsForLoading_Impl( uno::Reference< io::XInputStream >(), nStreamMode ) ); + hr = S_OK; + } + catch( const uno::Exception& ) + { + } + } + + if ( hr == S_OK ) + { + wchar_t const * aCurType = getStorageTypeFromGUID_Impl( &m_guid ); // ??? + CLIPFORMAT cf = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + hr = WriteFmtUserTypeStg( pStg, + cf, // ??? + const_cast<wchar_t *>(aCurType) ); + + if ( hr == S_OK ) + { + hr = pStg->CreateStream( o3tl::toW(aOfficeEmbedStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &m_pOwnStream ); + + if ( hr == S_OK && m_pOwnStream ) + { + hr = pStg->CreateStream( o3tl::toW(aExtentStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &m_pExtStream ); + + if ( hr == S_OK && m_pExtStream ) + { + + m_pMasterStorage = pStg; + m_bIsDirty = true; + } + else + hr = E_FAIL; + } + else + hr = E_FAIL; + } + else + hr = E_FAIL; + } + + if ( hr != S_OK ) + m_pDocHolder->CloseDocument(); + } + } + } + + return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Load( IStorage *pStg ) +{ + if ( m_pDocHolder->GetDocument().is() ) + return CO_E_ALREADYINITIALIZED; + + if ( !m_xFactory.is() || !pStg ) + return E_FAIL; + + HRESULT hr = E_FAIL; + + STATSTG aStat; + hr = pStg->Stat( &aStat, STATFLAG_NONAME ); + if ( FAILED( hr ) ) return E_FAIL; + + DWORD nStreamMode = aStat.grfMode; + hr = pStg->OpenStream( o3tl::toW(aOfficeEmbedStreamName.getStr()), + nullptr, + nStreamMode & 0x73, + 0, + &m_pOwnStream ); + if ( !m_pOwnStream ) hr = E_FAIL; + + if ( SUCCEEDED( hr ) ) + { + hr = pStg->OpenStream( o3tl::toW(aExtentStreamName.getStr()), + nullptr, + nStreamMode & 0x73, + 0, + &m_pExtStream ); + if ( !m_pExtStream ) hr = E_FAIL; + } + + // RECTL aRectToSet; + SIZEL aSizeToSet; + if ( SUCCEEDED( hr ) ) + { + ULARGE_INTEGER nNewPos; + LARGE_INTEGER const aZero = { 0, 0 }; + hr = m_pExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos ); + if ( SUCCEEDED( hr ) ) + { + sal_uInt32 nRead; + sal_Int32 aInf[EXT_STREAM_LENGTH]; + hr = m_pExtStream->Read( aInf, sizeof aInf, &nRead ); + if ( nRead != sizeof aInf ) hr = E_FAIL; + + if ( SUCCEEDED( hr ) ) + { + // aRectToSet.left = *((sal_Int32*)aInf); + // aRectToSet.top = *((sal_Int32*)&aInf[4]); + // aRectToSet.right = *((sal_Int32*)&aInf[8]); + // aRectToSet.bottom = *((sal_Int32*)&aInf[12]); + aSizeToSet.cx = aInf[2] - aInf[0]; + aSizeToSet.cy = aInf[3] - aInf[1]; + } + } + } + + if ( SUCCEEDED( hr ) ) + { + hr = E_FAIL; + + uno::Reference < io::XInputStream > xTempIn = createTempXInStreamFromIStream( m_xFactory, m_pOwnStream ); + if ( xTempIn.is() ) + { + uno::Reference< frame::XModel > aDocument( + m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ), + uno::UNO_QUERY ); + if ( aDocument.is() ) + { + m_pDocHolder->SetDocument( aDocument ); + + uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if( xLoadable.is() ) + { + try + { + xLoadable->load( fillArgsForLoading_Impl( xTempIn, nStreamMode ) ); + m_pMasterStorage = pStg; + hr = m_pDocHolder->SetExtent( &aSizeToSet ); + // hr = m_pDocHolder->SetVisArea( &aRectToSet ); + } + catch( const uno::Exception& ) + { + } + } + + if ( FAILED( hr ) ) + m_pDocHolder->CloseDocument(); + } + } + } + + if ( FAILED( hr ) ) + { + m_pOwnStream = CComPtr< IStream >(); + m_pExtStream = CComPtr< IStream >(); + hr = pStg->DestroyElement( o3tl::toW(aOfficeEmbedStreamName.getStr()) ); + hr = pStg->DestroyElement( o3tl::toW(aExtentStreamName.getStr()) ); + + OSL_ENSURE( SUCCEEDED( hr ), "Can not destroy created stream!" ); + if ( FAILED( hr ) ) + hr = E_FAIL; + } + + return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Save( IStorage *pStgSave, BOOL fSameAsLoad ) +{ + if ( !m_pDocHolder->GetDocument().is() || !m_xFactory.is() || !pStgSave || !m_pOwnStream || !m_pExtStream ) + return E_FAIL; + + CComPtr< IStream > pTargetStream; + CComPtr< IStream > pNewExtStream; + + if ( !fSameAsLoad && pStgSave != m_pMasterStorage ) + { + OSL_ENSURE( m_pMasterStorage, "How could the document be initialized without storage!??" ); + HRESULT hr = m_pMasterStorage->CopyTo( NULL, nullptr, nullptr, pStgSave ); + if ( FAILED( hr ) ) return E_FAIL; + + STATSTG aStat; + hr = pStgSave->Stat( &aStat, STATFLAG_NONAME ); + if ( FAILED( hr ) ) return E_FAIL; + + DWORD nStreamMode = aStat.grfMode; + hr = pStgSave->CreateStream( o3tl::toW(aOfficeEmbedStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &pTargetStream ); + if ( FAILED( hr ) || !pTargetStream ) return E_FAIL; + + hr = pStgSave->CreateStream( o3tl::toW(aExtentStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &pNewExtStream ); + if ( FAILED( hr ) || !pNewExtStream ) return E_FAIL; + } + else + { + pTargetStream = m_pOwnStream; + pNewExtStream = m_pExtStream; + } + + HRESULT hr = E_FAIL; + + uno::Reference < io::XOutputStream > xTempOut( io::TempFile::create(comphelper::getComponentContext(m_xFactory)), + uno::UNO_QUERY_THROW ); + + uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if( xStorable.is() ) + { + try + { + xStorable->storeToURL( "private:stream", + fillArgsForStoring_Impl( xTempOut ) ); + hr = copyXTempOutToIStream( xTempOut, pTargetStream ); + if ( SUCCEEDED( hr ) ) + { + // no need to truncate the stream, the size of the stream is always the same + ULARGE_INTEGER nNewPos; + LARGE_INTEGER const aZero = { 0, 0 }; + hr = pNewExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos ); + if ( SUCCEEDED( hr ) ) + { + SIZEL aSize; + hr = m_pDocHolder->GetExtent( &aSize ); + + if ( SUCCEEDED( hr ) ) + { + sal_uInt32 nWritten; + sal_Int32 aInf[EXT_STREAM_LENGTH] = {0, 0, aSize.cx, aSize.cy}; + + hr = pNewExtStream->Write( aInf, sizeof aInf, &nWritten ); + if ( nWritten != sizeof aInf ) hr = E_FAIL; + + if ( SUCCEEDED( hr ) ) + { + m_pOwnStream = CComPtr< IStream >(); + m_pExtStream = CComPtr< IStream >(); + if ( fSameAsLoad || pStgSave == m_pMasterStorage ) + { + uno::Reference< util::XModifiable > xMod( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if ( xMod.is() ) + xMod->setModified( false ); + m_bIsDirty = false; + } + } + } + } + } + } + catch( const uno::Exception& ) + { + } + } + + return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SaveCompleted( IStorage *pStgNew ) +{ + // m_pOwnStream == NULL && m_pMasterStorage != NULL means the object is in NoScribble mode + // m_pOwnStream == NULL && m_pMasterStorage == NULL means the object is in HandsOff mode + + if ( m_pOwnStream || m_pExtStream ) + return E_UNEXPECTED; + + if ( !m_pMasterStorage && !pStgNew ) + return E_INVALIDARG; + + if ( pStgNew ) + m_pMasterStorage = pStgNew; + + STATSTG aStat; + HRESULT hr = m_pMasterStorage->Stat( &aStat, STATFLAG_NONAME ); + if ( FAILED( hr ) ) return E_OUTOFMEMORY; + + DWORD nStreamMode = aStat.grfMode; + hr = m_pMasterStorage->OpenStream( o3tl::toW(aOfficeEmbedStreamName.getStr()), + nullptr, + nStreamMode & 0x73, + 0, + &m_pOwnStream ); + if ( FAILED( hr ) || !m_pOwnStream ) return E_OUTOFMEMORY; + + hr = m_pMasterStorage->OpenStream( o3tl::toW(aExtentStreamName.getStr()), + nullptr, + nStreamMode & 0x73, + 0, + &m_pExtStream ); + if ( FAILED( hr ) || !m_pExtStream ) return E_OUTOFMEMORY; + + for (auto const& advise : m_aAdviseHashMap) + { + if ( advise.second ) + advise.second->OnSave(); + } + + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::HandsOffStorage() +{ + m_pMasterStorage = CComPtr< IStorage >(); + m_pOwnStream = CComPtr< IStream >(); + m_pExtStream = CComPtr< IStream >(); + + return S_OK; +} + + +// IPersistFile + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Load( LPCOLESTR pszFileName, DWORD /*dwMode*/ ) +{ + if ( m_pDocHolder->GetDocument().is() ) + return CO_E_ALREADYINITIALIZED; + + if ( !m_xFactory.is() ) + return E_FAIL; + + DWORD nStreamMode = STGM_CREATE | STGM_READWRITE | STGM_DELETEONRELEASE | STGM_SHARE_EXCLUSIVE; + HRESULT hr = StgCreateDocfile( nullptr, + nStreamMode , + 0, + &m_pMasterStorage ); + + if ( FAILED( hr ) || !m_pMasterStorage ) return E_FAIL; + + std::u16string_view aCurType = getServiceNameFromGUID_Impl( &m_guid ); // ??? + CLIPFORMAT cf = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + hr = WriteFmtUserTypeStg( m_pMasterStorage, + cf, // ??? + const_cast<LPOLESTR>( o3tl::toW(aCurType.data())) ); + if ( FAILED( hr ) ) return E_FAIL; + + hr = m_pMasterStorage->SetClass( m_guid ); + if ( FAILED( hr ) ) return E_FAIL; + + hr = m_pMasterStorage->CreateStream( o3tl::toW(aOfficeEmbedStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &m_pOwnStream ); + if ( FAILED( hr ) || !m_pOwnStream ) return E_FAIL; + + hr = m_pMasterStorage->CreateStream( o3tl::toW(aExtentStreamName.getStr()), + STGM_CREATE | ( nStreamMode & 0x73 ), + 0, + 0, + &m_pExtStream ); + if ( FAILED( hr ) || !m_pExtStream ) return E_FAIL; + + + uno::Reference< frame::XModel > aDocument( + m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ), + uno::UNO_QUERY ); + if ( aDocument.is() ) + { + m_pDocHolder->SetDocument( aDocument, true ); + + uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY ); + if( xLoadable.is() ) + { + try + { + xLoadable->load( fillArgsForLoading_Impl( uno::Reference< io::XInputStream >(), + STGM_READWRITE, + pszFileName ) ); + hr = S_OK; + + m_aFileName = o3tl::toU(pszFileName); + } + catch( const uno::Exception& ) + { + } + } + + if ( hr == S_OK ) + { + aCurType = getServiceNameFromGUID_Impl( &m_guid ); // ??? + cf = static_cast<CLIPFORMAT>(RegisterClipboardFormatW( L"Embedded Object" )); + hr = WriteFmtUserTypeStg( m_pMasterStorage, + cf, // ??? + const_cast<LPOLESTR>( o3tl::toW(aCurType.data())) ); + + if ( SUCCEEDED( hr ) ) + { + // no need to truncate the stream, the size of the stream is always the same + ULARGE_INTEGER nNewPos; + LARGE_INTEGER const aZero = { 0, 0 }; + hr = m_pExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos ); + if ( SUCCEEDED( hr ) ) + { + SIZEL aSize; + hr = m_pDocHolder->GetExtent( &aSize ); + + if ( SUCCEEDED( hr ) ) + { + sal_uInt32 nWritten; + sal_Int32 aInf[EXT_STREAM_LENGTH] = {0, 0, aSize.cx, aSize.cy}; + + hr = m_pExtStream->Write( aInf, sizeof aInf, &nWritten ); + if ( nWritten != sizeof aInf ) hr = E_FAIL; + } + } + } + + if ( SUCCEEDED( hr ) ) + m_bIsDirty = true; + else + hr = E_FAIL; + } + + if ( FAILED( hr ) ) + { + m_pDocHolder->CloseDocument(); + m_pOwnStream = nullptr; + m_pExtStream = nullptr; + m_pMasterStorage = nullptr; + } + } + + return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::Save( LPCOLESTR pszFileName, BOOL fRemember ) +{ + if ( !m_pDocHolder->GetDocument().is() || !m_xFactory.is() ) + return E_FAIL; + + HRESULT hr = E_FAIL; + + // TODO/LATER: currently there is no hands off state implemented + try + { + uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetDocument(), uno::UNO_QUERY_THROW ); + + if ( !pszFileName ) + xStorable->store(); + else + { + util::URL aURL; + aURL.Complete = o3tl::toU( pszFileName ); + + uno::Reference< util::XURLTransformer > aTransformer( util::URLTransformer::create(comphelper::getComponentContext(m_xFactory)) ); + + if ( aTransformer->parseSmart( aURL, OUString() ) && aURL.Complete.getLength() ) + { + if ( fRemember ) + { + xStorable->storeAsURL( aURL.Complete, fillArgsForStoring_Impl( uno::Reference< io::XOutputStream >() ) ); + m_aFileName = aURL.Complete; + } + else + xStorable->storeToURL( aURL.Complete, fillArgsForStoring_Impl( uno::Reference< io::XOutputStream >() ) ); + } + } + + hr = S_OK; + } + catch( const uno::Exception& ) + { + } + + return hr; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::SaveCompleted( LPCOLESTR pszFileName ) +{ + // the different file name would mean error here + m_aFileName = o3tl::toU(pszFileName); + return S_OK; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedDocument_Impl::GetCurFile( LPOLESTR *ppszFileName ) +{ + CComPtr<IMalloc> pMalloc; + + HRESULT hr = CoGetMalloc( 1, &pMalloc ); + if ( FAILED( hr ) || !pMalloc ) return E_FAIL; + + *ppszFileName = static_cast<LPOLESTR>( pMalloc->Alloc( sizeof( sal_Unicode ) * ( m_aFileName.getLength() + 1 ) ) ); + wcsncpy( *ppszFileName, o3tl::toW(m_aFileName.getStr()), m_aFileName.getLength() + 1 ); + + return m_aFileName.getLength() ? S_OK : S_FALSE; +} + + +LockedEmbedDocument_Impl EmbeddedDocumentInstanceAccess_Impl::GetEmbedDocument() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + return LockedEmbedDocument_Impl( m_pEmbedDocument ); +} + +void EmbeddedDocumentInstanceAccess_Impl::ClearEmbedDocument() +{ + ::osl::MutexGuard aGuard( m_aMutex ); + m_pEmbedDocument = nullptr; +} + + +LockedEmbedDocument_Impl::LockedEmbedDocument_Impl() +: m_pEmbedDocument( nullptr ) +{} + +LockedEmbedDocument_Impl::LockedEmbedDocument_Impl( EmbedDocument_Impl* pEmbedDocument ) +: m_pEmbedDocument( pEmbedDocument ) +{ + if ( m_pEmbedDocument ) + m_pEmbedDocument->AddRef(); +} + +LockedEmbedDocument_Impl::LockedEmbedDocument_Impl( const LockedEmbedDocument_Impl& aDocLock ) +: m_pEmbedDocument( aDocLock.m_pEmbedDocument ) +{ + if ( m_pEmbedDocument ) + m_pEmbedDocument->AddRef(); +} + +LockedEmbedDocument_Impl& LockedEmbedDocument_Impl::operator=( const LockedEmbedDocument_Impl& aDocLock ) +{ + if ( m_pEmbedDocument ) + m_pEmbedDocument->Release(); + + m_pEmbedDocument = aDocLock.m_pEmbedDocument; + if ( m_pEmbedDocument ) + m_pEmbedDocument->AddRef(); + + return *this; +} + +LockedEmbedDocument_Impl::~LockedEmbedDocument_Impl() +{ + if ( m_pEmbedDocument ) + m_pEmbedDocument->Release(); +} + +void LockedEmbedDocument_Impl::ExecuteMethod( sal_Int16 nId ) +{ + if ( m_pEmbedDocument ) + { + if ( nId == OLESERV_SAVEOBJECT ) + m_pEmbedDocument->SaveObject(); + else if ( nId == OLESERV_CLOSE ) + m_pEmbedDocument->Close( 0 ); + else if ( nId == OLESERV_NOTIFY ) + m_pEmbedDocument->notify(); + else if ( nId == OLESERV_NOTIFYCLOSING ) + m_pEmbedDocument->OLENotifyClosing(); + else if ( nId == OLESERV_SHOWOBJECT ) + m_pEmbedDocument->ShowObject(); + else if ( nId == OLESERV_DEACTIVATE ) + m_pEmbedDocument->Deactivate(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/esdll.cxx b/embedserv/source/embed/esdll.cxx new file mode 100644 index 000000000..bfffe73bb --- /dev/null +++ b/embedserv/source/embed/esdll.cxx @@ -0,0 +1,66 @@ +/* -*- 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 . + */ + +#define _WIN32_DCOM + +#include <stdafx.h> + +#include <atlbase.h> +CComModule _Module; +#include <atlcom.h> + +BEGIN_OBJECT_MAP(ObjectMap) +#if defined __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wmissing-field-initializers" +#endif +END_OBJECT_MAP() +#if defined __clang__ +#pragma clang diagnostic pop +#endif + +// DLL Entry Point + + +#include <syswinwrapper.hxx> +#include <docholder.hxx> + + +HINSTANCE DocumentHolder::m_hInstance; + +extern "C" +BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) +{ + DocumentHolder::m_hInstance = hInstance; + if (!winwrap::HatchWindowRegister(hInstance)) + return FALSE; + + if (dwReason == DLL_PROCESS_ATTACH) + { + _Module.Init(ObjectMap, hInstance); + DisableThreadLibraryCalls(hInstance); + } + else if (dwReason == DLL_PROCESS_DETACH) + { + _Module.Term(); + } + return TRUE; // ok +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/guid.cxx b/embedserv/source/embed/guid.cxx new file mode 100644 index 000000000..5b284a8a9 --- /dev/null +++ b/embedserv/source/embed/guid.cxx @@ -0,0 +1,131 @@ +/* -*- 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 <common.h> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/container/XNameAccess.hpp> + +#include "guid.hxx" + +wchar_t const * getStorageTypeFromGUID_Impl( GUID const * guid ) +{ + if ( *guid == OID_WriterTextServer ) + return L"soffice.StarWriterDocument.6"; + + if ( *guid == OID_WriterOASISTextServer ) + return L"LibreOffice.WriterDocument.1"; + + if ( *guid == OID_CalcServer ) + return L"soffice.StarCalcDocument.6"; + + if ( *guid == OID_CalcOASISServer ) + return L"LibreOffice.CalcDocument.1"; + + if ( *guid == OID_DrawingServer ) + return L"soffice.StarDrawDocument.6"; + + if ( *guid == OID_DrawingOASISServer ) + return L"LibreOffice.DrawDocument.1"; + + if ( *guid == OID_PresentationServer ) + return L"soffice.StarImpressDocument.6"; + + if ( *guid == OID_PresentationOASISServer ) + return L"LibreOffice.ImpressDocument.1"; + + if ( *guid == OID_MathServer ) + return L"soffice.StarMathDocument.6"; + + if ( *guid == OID_MathOASISServer ) + return L"LibreOffice.MathDocument.1"; + + return L""; +} + +std::u16string_view getServiceNameFromGUID_Impl( GUID const * guid ) +{ + if ( *guid == OID_WriterTextServer ) + return u"com.sun.star.comp.Writer.TextDocument"; + + if ( *guid == OID_WriterOASISTextServer ) + return u"com.sun.star.comp.Writer.TextDocument"; + + if ( *guid == OID_CalcServer ) + return u"com.sun.star.comp.Calc.SpreadsheetDocument"; + + if ( *guid == OID_CalcOASISServer ) + return u"com.sun.star.comp.Calc.SpreadsheetDocument"; + + if ( *guid == OID_DrawingServer ) + return u"com.sun.star.comp.Draw.DrawingDocument"; + + if ( *guid == OID_DrawingOASISServer ) + return u"com.sun.star.comp.Draw.DrawingDocument"; + + if ( *guid == OID_PresentationServer ) + return u"com.sun.star.comp.Draw.PresentationDocument"; + + if ( *guid == OID_PresentationOASISServer ) + return u"com.sun.star.comp.Draw.PresentationDocument"; + + if ( *guid == OID_MathServer ) + return u"com.sun.star.comp.Math.FormulaDocument"; + + if ( *guid == OID_MathOASISServer ) + return u"com.sun.star.comp.Math.FormulaDocument"; + + return u""; +} + +OUString getFilterNameFromGUID_Impl( GUID const * guid ) +{ + if ( *guid == OID_WriterTextServer ) + return "StarOffice XML (Writer)"; + + if ( *guid == OID_WriterOASISTextServer ) + return "writer8"; + + if ( *guid == OID_CalcServer ) + return "StarOffice XML (Calc)"; + + if ( *guid == OID_CalcOASISServer ) + return "calc8"; + + if ( *guid == OID_DrawingServer ) + return "StarOffice XML (Draw)"; + + if ( *guid == OID_DrawingOASISServer ) + return "draw8"; + + if ( *guid == OID_PresentationServer ) + return "StarOffice XML (Impress)"; + + if ( *guid == OID_PresentationOASISServer ) + return "impress8"; + + if ( *guid == OID_MathServer ) + return "StarOffice XML (Math)"; + + if ( *guid == OID_MathOASISServer ) + return "math8"; + + return OUString(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/guid.hxx b/embedserv/source/embed/guid.hxx new file mode 100644 index 000000000..eca39c288 --- /dev/null +++ b/embedserv/source/embed/guid.hxx @@ -0,0 +1,39 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_EMBED_GUID_HXX +#define INCLUDED_EMBEDSERV_SOURCE_EMBED_GUID_HXX + +#include <sal/config.h> + +#include <string_view> + +#include <rtl/ustring.hxx> + +#include <common.h> + +OUString getFilterNameFromGUID_Impl( GUID const * ); + +std::u16string_view getServiceNameFromGUID_Impl( GUID const * ); + +wchar_t const * getStorageTypeFromGUID_Impl( GUID const * guid ); + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/iipaobj.cxx b/embedserv/source/embed/iipaobj.cxx new file mode 100644 index 000000000..6947b1ea6 --- /dev/null +++ b/embedserv/source/embed/iipaobj.cxx @@ -0,0 +1,116 @@ +/* -*- 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 <iipaobj.hxx> +#include <embeddoc.hxx> + + +CIIAObj::CIIAObj(DocumentHolder* pDocHolder) + : m_refCount( 0 ), + m_rDocHolder( pDocHolder ) +{ +} + + +CIIAObj::~CIIAObj() +{ + return; +} + +/* IUnknown methods */ + +STDMETHODIMP CIIAObj::QueryInterface(REFIID riid, LPVOID FAR *ppv) +{ + *ppv=nullptr; + + if(IID_IUnknown==riid || + IID_IOleWindow==riid || + IID_IOleInPlaceActiveObject==riid) + *ppv=this; + + //AddRef any interface we'll return. + if (nullptr!=*ppv) + { + static_cast<LPUNKNOWN>(*ppv)->AddRef(); + return NOERROR; + } + + return ResultFromScode(E_NOINTERFACE); +} + + +STDMETHODIMP_(ULONG) CIIAObj::AddRef() +{ + return osl_atomic_increment( &m_refCount); +} + +STDMETHODIMP_(ULONG) CIIAObj::Release() +{ + sal_Int32 nCount = osl_atomic_decrement( &m_refCount); + if ( nCount == 0 ) + delete this; + + return nCount; +} + +/* IOleInPlaceActiveObject methods*/ + +STDMETHODIMP CIIAObj::GetWindow(HWND *) +{ + return NOERROR; +} + +STDMETHODIMP CIIAObj::ContextSensitiveHelp(BOOL) +{ + return NOERROR; +} + +STDMETHODIMP CIIAObj::TranslateAccelerator(LPMSG) +{ + return NOERROR; +} + +STDMETHODIMP CIIAObj::OnFrameWindowActivate(BOOL) +{ + return NOERROR; +} + +STDMETHODIMP CIIAObj::OnDocWindowActivate(BOOL) +{ + return NOERROR; +} + +STDMETHODIMP CIIAObj::ResizeBorder( + LPCRECT pRect,LPOLEINPLACEUIWINDOW,BOOL bFrame) +{ + if(!bFrame) return NOERROR; + + if ( !m_rDocHolder.is() ) + return E_FAIL; + + return m_rDocHolder->SetContRects(pRect); +} + + +STDMETHODIMP CIIAObj::EnableModeless(BOOL) +{ + return NOERROR; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/intercept.cxx b/embedserv/source/embed/intercept.cxx new file mode 100644 index 000000000..ebe949137 --- /dev/null +++ b/embedserv/source/embed/intercept.cxx @@ -0,0 +1,491 @@ +/* -*- 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 <cppuhelper/weak.hxx> +#include <cppuhelper/interfacecontainer.hxx> + +#include <embeddoc.hxx> +#include <docholder.hxx> +#include <intercept.hxx> + +using namespace ::com::sun::star; + + +#define IUL 6 + + +uno::Sequence< OUString > Interceptor::m_aInterceptedURL(IUL); + +class StatusChangeListenerContainer + : public cppu::OMultiTypeInterfaceContainerHelperVar<OUString> +{ +public: + explicit StatusChangeListenerContainer(osl::Mutex& aMutex) + : cppu::OMultiTypeInterfaceContainerHelperVar<OUString>(aMutex) + { + } +}; + + +void +Interceptor::addEventListener( + const uno::Reference<lang::XEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( ! m_pDisposeEventListeners ) + m_pDisposeEventListeners = + new comphelper::OInterfaceContainerHelper2( m_aMutex ); + + m_pDisposeEventListeners->addInterface( Listener ); +} + + +void +Interceptor::removeEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pDisposeEventListeners ) + m_pDisposeEventListeners->removeInterface( Listener ); +} + + +void Interceptor::dispose() +{ + lang::EventObject aEvt; + aEvt.Source = static_cast< frame::XDispatch* >( this ); + + osl::MutexGuard aGuard(m_aMutex); + + if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() ) + m_pDisposeEventListeners->disposeAndClear( aEvt ); + + if(m_pStatCL) + m_pStatCL->disposeAndClear( aEvt ); + + m_xSlaveDispatchProvider = nullptr; + m_xMasterDispatchProvider = nullptr; +} + + +Interceptor::Interceptor( + const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl >& xOleAccess, + DocumentHolder* pDocH, + bool bLink ) + : m_xOleAccess( xOleAccess ), + m_xDocHLocker( static_cast< ::cppu::OWeakObject* >( pDocH ) ), + m_pDocH(pDocH), + m_pDisposeEventListeners(nullptr), + m_pStatCL(nullptr), + m_bLink( bLink ) +{ + m_aInterceptedURL[0] = ".uno:Save"; + m_aInterceptedURL[1] = ".uno:SaveAll"; + m_aInterceptedURL[2] = ".uno:CloseDoc"; + m_aInterceptedURL[3] = ".uno:CloseWin"; + m_aInterceptedURL[4] = ".uno:CloseFrame"; + m_aInterceptedURL[5] = ".uno:SaveAs"; +} + + +Interceptor::~Interceptor() +{ + delete m_pDisposeEventListeners; + delete m_pStatCL; + + DocumentHolder* pTmpDocH = nullptr; + uno::Reference< uno::XInterface > xLock; + { + osl::MutexGuard aGuard(m_aMutex); + xLock = m_xDocHLocker.get(); + if ( xLock.is() ) + pTmpDocH = m_pDocH; + } + + if ( pTmpDocH ) + pTmpDocH->ClearInterceptor(); +} + +void Interceptor::DisconnectDocHolder() +{ + osl::MutexGuard aGuard(m_aMutex); + m_xDocHLocker.clear(); + m_pDocH = nullptr; + m_xOleAccess = nullptr; +} + +//XDispatch +void SAL_CALL +Interceptor::dispatch( + const util::URL& URL, + const uno::Sequence< + beans::PropertyValue >& Arguments ) +{ + ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl > xOleAccess; + { + osl::MutexGuard aGuard(m_aMutex); + xOleAccess = m_xOleAccess; + } + + if ( xOleAccess.is() ) + { + LockedEmbedDocument_Impl aDocLock = xOleAccess->GetEmbedDocument(); + if ( aDocLock.GetEmbedDocument() ) + { + if( !m_bLink && URL.Complete == m_aInterceptedURL[0]) + aDocLock.GetEmbedDocument()->SaveObject(); + else if(!m_bLink + && ( URL.Complete == m_aInterceptedURL[2] || + URL.Complete == m_aInterceptedURL[3] || + URL.Complete == m_aInterceptedURL[4] ) ) + aDocLock.GetEmbedDocument()->Close( 0 ); + else if ( URL.Complete == m_aInterceptedURL[5] ) + { + uno::Sequence< beans::PropertyValue > aNewArgs = Arguments; + sal_Int32 nInd = 0; + + while( nInd < aNewArgs.getLength() ) + { + if ( aNewArgs[nInd].Name == "SaveTo" ) + { + aNewArgs[nInd].Value <<= true; + break; + } + nInd++; + } + + if ( nInd == aNewArgs.getLength() ) + { + aNewArgs.realloc( nInd + 1 ); + aNewArgs[nInd].Name = "SaveTo"; + aNewArgs[nInd].Value <<= true; + } + + uno::Reference< frame::XDispatch > xDispatch = m_xSlaveDispatchProvider->queryDispatch( + URL, "_self", 0 ); + if ( xDispatch.is() ) + xDispatch->dispatch( URL, aNewArgs ); + } + } + } +} + + +void Interceptor::generateFeatureStateEvent() +{ + if( m_pStatCL ) + { + DocumentHolder* pTmpDocH = nullptr; + uno::Reference< uno::XInterface > xLock; + { + osl::MutexGuard aGuard(m_aMutex); + xLock = m_xDocHLocker.get(); + if ( xLock.is() ) + pTmpDocH = m_pDocH; + } + + OUString aTitle; + if ( pTmpDocH ) + aTitle = pTmpDocH->getTitle(); + + for(int i = 0; i < IUL; ++i) + { + if( i == 1 || (m_bLink && i != 5) ) + continue; + + cppu::OInterfaceContainerHelper* pICH = + m_pStatCL->getContainer(m_aInterceptedURL[i]); + uno::Sequence<uno::Reference<uno::XInterface> > aSeq; + if(pICH) + aSeq = pICH->getElements(); + if(!aSeq.getLength()) + continue; + + frame::FeatureStateEvent aStateEvent; + aStateEvent.IsEnabled = true; + aStateEvent.Requery = false; + if(i == 0) + { + + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[0]; + aStateEvent.FeatureDescriptor = "Update"; + aStateEvent.State <<= "($1) " + aTitle; + + } + else if ( i == 5 ) + { + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[5]; + aStateEvent.FeatureDescriptor = "SaveCopyTo"; + aStateEvent.State <<= OUString("($3)"); + } + else + { + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[i]; + aStateEvent.FeatureDescriptor = "Close and Return"; + aStateEvent.State <<= "($2) " + aTitle; + + } + + for(uno::Reference<uno::XInterface> const & k : std::as_const(aSeq)) + { + uno::Reference<frame::XStatusListener> Control(k,uno::UNO_QUERY); + if(Control.is()) + Control->statusChanged(aStateEvent); + + } + } + } +} + + +void SAL_CALL +Interceptor::addStatusListener( + const uno::Reference< + frame::XStatusListener >& Control, + const util::URL& URL ) +{ + if(!Control.is()) + return; + + if( !m_bLink && URL.Complete == m_aInterceptedURL[0] ) + { // Save + DocumentHolder* pTmpDocH = nullptr; + uno::Reference< uno::XInterface > xLock; + { + osl::MutexGuard aGuard(m_aMutex); + xLock = m_xDocHLocker.get(); + if ( xLock.is() ) + pTmpDocH = m_pDocH; + } + + OUString aTitle; + if ( pTmpDocH ) + aTitle = pTmpDocH->getTitle(); + + frame::FeatureStateEvent aStateEvent; + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[0]; + aStateEvent.FeatureDescriptor = "Update"; + aStateEvent.IsEnabled = true; + aStateEvent.Requery = false; + aStateEvent.State <<= "($1) " + aTitle; + Control->statusChanged(aStateEvent); + + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_pStatCL) + m_pStatCL = + new StatusChangeListenerContainer(m_aMutex); + } + + m_pStatCL->addInterface(URL.Complete,Control); + return; + } + + sal_Int32 i = 2; + if ( !m_bLink + && ( URL.Complete == m_aInterceptedURL[i] || + URL.Complete == m_aInterceptedURL[++i] || + URL.Complete == m_aInterceptedURL[++i] ) ) + { // Close and return + DocumentHolder* pTmpDocH = nullptr; + uno::Reference< uno::XInterface > xLock; + { + osl::MutexGuard aGuard(m_aMutex); + xLock = m_xDocHLocker.get(); + if ( xLock.is() ) + pTmpDocH = m_pDocH; + } + + OUString aTitle; + if ( pTmpDocH ) + aTitle = pTmpDocH->getTitle(); + + frame::FeatureStateEvent aStateEvent; + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[i]; + aStateEvent.FeatureDescriptor = "Close and Return"; + aStateEvent.IsEnabled = true; + aStateEvent.Requery = false; + aStateEvent.State <<= "($2) " + aTitle; + Control->statusChanged(aStateEvent); + + + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_pStatCL) + m_pStatCL = + new StatusChangeListenerContainer(m_aMutex); + } + + m_pStatCL->addInterface(URL.Complete,Control); + return; + } + + if(URL.Complete == m_aInterceptedURL[5]) + { // SaveAs + frame::FeatureStateEvent aStateEvent; + aStateEvent.FeatureURL.Complete = m_aInterceptedURL[5]; + aStateEvent.FeatureDescriptor = "SaveCopyTo"; + aStateEvent.IsEnabled = true; + aStateEvent.Requery = false; + aStateEvent.State <<= OUString("($3)"); + Control->statusChanged(aStateEvent); + + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_pStatCL) + m_pStatCL = + new StatusChangeListenerContainer(m_aMutex); + } + + m_pStatCL->addInterface(URL.Complete,Control); + return; + } + +} + + +void SAL_CALL +Interceptor::removeStatusListener( + const uno::Reference< + frame::XStatusListener >& Control, + const util::URL& URL ) +{ + if(!(Control.is() && m_pStatCL)) + return; + else { + m_pStatCL->removeInterface(URL.Complete,Control); + return; + } +} + + +//XInterceptorInfo +uno::Sequence< OUString > +SAL_CALL +Interceptor::getInterceptedURLs( ) +{ + // now implemented as update + if ( m_bLink ) + { + uno::Sequence< OUString > aResult( 2 ); + aResult[0] = m_aInterceptedURL[1]; + aResult[1] = m_aInterceptedURL[5]; + + return aResult; + } + + return m_aInterceptedURL; +} + + +// XDispatchProvider + +uno::Reference< frame::XDispatch > SAL_CALL +Interceptor::queryDispatch( + const util::URL& URL, + const OUString& TargetFrameName, + sal_Int32 SearchFlags ) +{ + osl::MutexGuard aGuard(m_aMutex); + if( !m_bLink && URL.Complete == m_aInterceptedURL[0] ) + return static_cast<frame::XDispatch*>(this); + else if(URL.Complete == m_aInterceptedURL[1]) + return nullptr; + else if( !m_bLink && URL.Complete == m_aInterceptedURL[2] ) + return static_cast<frame::XDispatch*>(this); + else if( !m_bLink && URL.Complete == m_aInterceptedURL[3] ) + return static_cast<frame::XDispatch*>(this); + else if( !m_bLink && URL.Complete == m_aInterceptedURL[4] ) + return static_cast<frame::XDispatch*>(this); + else if(URL.Complete == m_aInterceptedURL[5]) + return static_cast<frame::XDispatch*>(this); + else { + if(m_xSlaveDispatchProvider.is()) + return m_xSlaveDispatchProvider->queryDispatch( + URL,TargetFrameName,SearchFlags); + else + return uno::Reference<frame::XDispatch>(nullptr); + } +} + +uno::Sequence< uno::Reference< frame::XDispatch > > SAL_CALL +Interceptor::queryDispatches( + const uno::Sequence<frame::DispatchDescriptor >& Requests ) +{ + uno::Sequence< uno::Reference< frame::XDispatch > > aRet; + osl::MutexGuard aGuard(m_aMutex); + if(m_xSlaveDispatchProvider.is()) + aRet = m_xSlaveDispatchProvider->queryDispatches(Requests); + else + aRet.realloc(Requests.getLength()); + + for(sal_Int32 i = 0; i < Requests.getLength(); ++i) + if ( !m_bLink && m_aInterceptedURL[0] == Requests[i].FeatureURL.Complete ) + aRet[i] = static_cast<frame::XDispatch*>(this); + else if(m_aInterceptedURL[1] == Requests[i].FeatureURL.Complete) + aRet[i] = nullptr; + else if( !m_bLink && m_aInterceptedURL[2] == Requests[i].FeatureURL.Complete ) + aRet[i] = static_cast<frame::XDispatch*>(this); + else if( !m_bLink && m_aInterceptedURL[3] == Requests[i].FeatureURL.Complete ) + aRet[i] = static_cast<frame::XDispatch*>(this); + else if( !m_bLink && m_aInterceptedURL[4] == Requests[i].FeatureURL.Complete ) + aRet[i] = static_cast<frame::XDispatch*>(this); + else if(m_aInterceptedURL[5] == Requests[i].FeatureURL.Complete) + aRet[i] = static_cast<frame::XDispatch*>(this); + + return aRet; +} + + +//XDispatchProviderInterceptor + +uno::Reference< frame::XDispatchProvider > SAL_CALL +Interceptor::getSlaveDispatchProvider( ) +{ + osl::MutexGuard aGuard(m_aMutex); + return m_xSlaveDispatchProvider; +} + +void SAL_CALL +Interceptor::setSlaveDispatchProvider( + const uno::Reference< frame::XDispatchProvider >& NewDispatchProvider ) +{ + osl::MutexGuard aGuard(m_aMutex); + m_xSlaveDispatchProvider = NewDispatchProvider; +} + + +uno::Reference< frame::XDispatchProvider > SAL_CALL +Interceptor::getMasterDispatchProvider( ) +{ + osl::MutexGuard aGuard(m_aMutex); + return m_xMasterDispatchProvider; +} + + +void SAL_CALL +Interceptor::setMasterDispatchProvider( + const uno::Reference< frame::XDispatchProvider >& NewSupplier ) +{ + osl::MutexGuard aGuard(m_aMutex); + m_xMasterDispatchProvider = NewSupplier; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/register.cxx b/embedserv/source/embed/register.cxx new file mode 100644 index 000000000..46b18d5fd --- /dev/null +++ b/embedserv/source/embed/register.cxx @@ -0,0 +1,79 @@ +/* -*- 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 <servprov.hxx> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/registry/XRegistryKey.hpp> +#include <com/sun/star/registry/InvalidRegistryException.hpp> +#include <rtl/ustring.h> +#include <cppuhelper/factory.hxx> + + +using namespace ::com::sun::star; + +/// @throws uno::Exception +static uno::Reference<uno::XInterface> EmbedServer_createInstance( + const uno::Reference<lang::XMultiServiceFactory> & xSMgr) +{ + uno::Reference<uno::XInterface > xService = *new EmbedServer_Impl( xSMgr ); + return xService; +} + +static OUString EmbedServer_getImplementationName() throw() +{ + return "com.sun.star.comp.ole.EmbedServer"; + +} + +static uno::Sequence< OUString > EmbedServer_getSupportedServiceNames() throw() +{ + uno::Sequence<OUString> aServiceNames { "com.sun.star.document.OleEmbeddedServerRegistration" }; + return aServiceNames; +} + +extern "C" { + +SAL_DLLPUBLIC_EXPORT void * emser_component_getFactory( const char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ ) +{ + void * pRet = nullptr; + + OUString aImplName( OUString::createFromAscii( pImplName ) ); + uno::Reference< lang::XSingleServiceFactory > xFactory; + + if(pServiceManager && aImplName.equals( EmbedServer_getImplementationName() ) ) + { + xFactory= ::cppu::createOneInstanceFactory( static_cast< lang::XMultiServiceFactory*>(pServiceManager), + EmbedServer_getImplementationName(), + EmbedServer_createInstance, + EmbedServer_getSupportedServiceNames() ); + } + + if (xFactory.is()) + { + xFactory->acquire(); + pRet = xFactory.get(); + } + + return pRet; +} + +} // extern "C" + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/servprov.cxx b/embedserv/source/embed/servprov.cxx new file mode 100644 index 000000000..ec7628bd3 --- /dev/null +++ b/embedserv/source/embed/servprov.cxx @@ -0,0 +1,227 @@ +/* -*- 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 <stdafx.h> +#include <servprov.hxx> +#include <embeddoc.hxx> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <osl/diagnose.h> +#include <osl/mutex.hxx> +#include <osl/thread.h> +#include <sal/log.hxx> + +using namespace com::sun::star; + +const GUID* const guidList[ SUPPORTED_FACTORIES_NUM ] = { + &OID_WriterTextServer, + &OID_WriterOASISTextServer, + &OID_CalcServer, + &OID_CalcOASISServer, + &OID_DrawingServer, + &OID_DrawingOASISServer, + &OID_PresentationServer, + &OID_PresentationOASISServer, + &OID_MathServer, + &OID_MathOASISServer +}; + +namespace { + +class CurThreadData +{ + public: + CurThreadData(); + virtual ~CurThreadData(); + + bool setData(void *pData); + + void* getData(); + + protected: + oslThreadKey m_hKey; +}; + +} + +CurThreadData::CurThreadData() : m_hKey(osl_createThreadKey( nullptr )) +{ +} + +CurThreadData::~CurThreadData() +{ + osl_destroyThreadKey(m_hKey); +} + +bool CurThreadData::setData(void *pData) +{ + OSL_ENSURE( m_hKey, "No thread key!" ); + return osl_setThreadKeyData(m_hKey, pData); +} + +void *CurThreadData::getData() +{ + OSL_ENSURE( m_hKey, "No thread key!" ); + return osl_getThreadKeyData(m_hKey); +} + +static void o2u_attachCurrentThread() +{ + static CurThreadData oleThreadData; + + if ( oleThreadData.getData() != nullptr ) + { + HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED); + if (!SUCCEEDED(hr)) + { // FIXME: is it a problem that this ends up in STA currently? + assert(RPC_E_CHANGED_MODE == hr); + SAL_INFO("embedserv.ole", + "CoInitializeEx fail: probably thread is in STA already?"); + } + oleThreadData.setData(reinterpret_cast<void*>(true)); + } +} + + +// EmbedServer_Impl + +EmbedServer_Impl::EmbedServer_Impl( const uno::Reference<lang::XMultiServiceFactory>& xFactory): + m_xFactory( xFactory) +{ + for( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ ) + { + m_pOLEFactories[nInd] = new EmbedProviderFactory_Impl( m_xFactory, guidList[nInd] ); + m_pOLEFactories[nInd]->registerClass(); + } +} + +EmbedServer_Impl::~EmbedServer_Impl() +{ + for( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ ) + { + if ( m_pOLEFactories[nInd] ) + m_pOLEFactories[nInd]->deregisterClass(); + } +} + +OUString EmbedServer_Impl::getImplementationName() +{ + return "com.sun.star.comp.ole.EmbedServer"; +} + +sal_Bool EmbedServer_Impl::supportsService(OUString const & ServiceName) +{ + return cppu::supportsService(this, ServiceName); +} + +css::uno::Sequence<OUString> EmbedServer_Impl::getSupportedServiceNames() +{ + return css::uno::Sequence<OUString>{ + "com.sun.star.document.OleEmbeddedServerRegistration"}; +} + +// EmbedProviderFactory_Impl + +EmbedProviderFactory_Impl::EmbedProviderFactory_Impl(const uno::Reference<lang::XMultiServiceFactory>& xFactory, const GUID* pGuid) + : m_refCount( 0 ) + , m_guid( *pGuid ) + , m_xFactory( xFactory ) +{ +} + +EmbedProviderFactory_Impl::~EmbedProviderFactory_Impl() +{ +} + +bool EmbedProviderFactory_Impl::registerClass() +{ + HRESULT hresult; + + o2u_attachCurrentThread(); + + hresult = CoRegisterClassObject( + m_guid, + this, + CLSCTX_LOCAL_SERVER, + REGCLS_MULTIPLEUSE, + &m_factoryHandle); + + return (hresult == NOERROR); +} + +bool EmbedProviderFactory_Impl::deregisterClass() +{ + HRESULT hresult = CoRevokeClassObject( m_factoryHandle ); + + return (hresult == NOERROR); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedProviderFactory_Impl::QueryInterface(REFIID riid, void FAR* FAR* ppv) +{ + if(IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppv = static_cast<IUnknown*>(static_cast<IClassFactory*>(this)); + return NOERROR; + } + else if (IsEqualIID(riid, IID_IClassFactory)) + { + AddRef(); + *ppv = static_cast<IClassFactory*>(this); + return NOERROR; + } + + *ppv = nullptr; + return ResultFromScode(E_NOINTERFACE); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) EmbedProviderFactory_Impl::AddRef() +{ + return osl_atomic_increment( &m_refCount); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) EmbedProviderFactory_Impl::Release() +{ + ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex()); + sal_Int32 nCount = --m_refCount; + if ( nCount == 0 ) + { + delete this; + } + + return nCount; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedProviderFactory_Impl::CreateInstance(IUnknown FAR* punkOuter, + REFIID riid, + void FAR* FAR* ppv) +{ + punkOuter = nullptr; + + IUnknown* pEmbedDocument = static_cast<IUnknown*>(static_cast<IPersistStorage*>( new EmbedDocument_Impl( m_xFactory, &m_guid ) )); + + return pEmbedDocument->QueryInterface( riid, ppv ); +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP EmbedProviderFactory_Impl::LockServer( int /*fLock*/ ) +{ + return NOERROR; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/syswinwrapper.cxx b/embedserv/source/embed/syswinwrapper.cxx new file mode 100644 index 000000000..7024a054c --- /dev/null +++ b/embedserv/source/embed/syswinwrapper.cxx @@ -0,0 +1,435 @@ +/* -*- 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 <docholder.hxx> +#include <syswinwrapper.hxx> + +/* + * CWindow::CWindow + * CWindow::~CWindow + * + * Constructor Parameters: + * hInst HINSTANCE of the task owning us. + */ + + +using namespace winwrap; + + +#define HWWL_STRUCTURE 0 + +//Notification codes for WM_COMMAND messages +#define HWN_BORDERDOUBLECLICKED 1 +#define CBHATCHWNDEXTRA (sizeof(LONG)) +#define SZCLASSHATCHWIN L"hatchwin" + +typedef CHatchWin *PCHatchWin; + +winwrap::CWindow::CWindow(HINSTANCE hInst) +{ + m_hInst=hInst; + m_hWnd=nullptr; + return; +} + +winwrap::CWindow::~CWindow() +{ + if (IsWindow(m_hWnd)) + DestroyWindow(m_hWnd); + + return; +} + + +/* + * CWindow::Window + * + * Purpose: + * Returns the window handle associated with this object. + * + * Return Value: + * HWND Window handle for this object + */ + +HWND winwrap::CWindow::Window() +{ + return m_hWnd; +} + + +/* + * CWindow::Instance + * + * Purpose: + * Returns the instance handle associated with this object. + * + * Return Value: + * HINSTANCE Instance handle of the module stored here. + */ + +HINSTANCE winwrap::CWindow::Instance() +{ + return m_hInst; +} + +/* + * HatchWindowRegister + * + * Purpose: + * Registers the hatch window class for use with CHatchWin. + * + * Parameters: + * hInst HINSTANCE under which to register. + * + * Return Value: + * BOOL TRUE if successful, FALSE otherwise. + */ + +BOOL winwrap::HatchWindowRegister(HINSTANCE hInst) +{ + WNDCLASSW wc; + + //Must have CS_DBLCLKS for border! + wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; + wc.hInstance = hInst; + wc.cbClsExtra = 0; + wc.lpfnWndProc = HatchWndProc; + wc.cbWndExtra = CBHATCHWNDEXTRA; + wc.hIcon = nullptr; + wc.hCursor = LoadCursor(nullptr, IDC_ARROW); + wc.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1); + wc.lpszMenuName = nullptr; + wc.lpszClassName = SZCLASSHATCHWIN; + + return RegisterClassW(&wc) != 0; +} + + +/* + * CHatchWin:CHatchWin + * CHatchWin::~CHatchWin + * + * Constructor Parameters: + * hInst HINSTANCE of the application we're in. + */ + +CHatchWin::CHatchWin(HINSTANCE hInst,const DocumentHolder* pDocHolder) + : CWindow(hInst), + m_aTracker() +{ + m_hWnd=nullptr; + m_hWndKid=nullptr; + m_hWndAssociate=nullptr; + m_uID=0; + + m_dBorderOrg=GetProfileIntW(L"windows" + , L"OleInPlaceBorderWidth" + , HATCHWIN_BORDERWIDTHDEFAULT); + + m_dBorder=m_dBorderOrg; + SetRect(&m_rcPos, 0, 0, 0, 0); + SetRect(&m_rcClip, 0, 0, 0, 0); + + m_pDocHolder = pDocHolder; + return; +} + + +CHatchWin::~CHatchWin() +{ + /* + * Chances are this was already destroyed when a document + * was destroyed. + */ + if (nullptr!=m_hWnd && IsWindow(m_hWnd)) + DestroyWindow(m_hWnd); + + return; +} + + +/* + * CHatchWin::Init + * + * Purpose: + * Instantiates a hatch window within a given parent with a + * default rectangle. This is not initially visible. + * + * Parameters: + * hWndParent HWND of the parent of this window + * uID WORD identifier for this window (send in + * notifications to associate window). + * hWndAssoc HWND of the initial associate. + * + * Return Value: + * BOOL TRUE if the function succeeded, FALSE otherwise. + */ + +BOOL CHatchWin::Init(HWND hWndParent, WORD uID, HWND hWndAssoc) +{ + m_hWndParent = hWndParent; + m_hWnd=CreateWindowExW( + WS_EX_NOPARENTNOTIFY, SZCLASSHATCHWIN + , SZCLASSHATCHWIN, WS_CHILD | WS_CLIPSIBLINGS + | WS_CLIPCHILDREN, 0, 0, 100, 100, hWndParent + , reinterpret_cast<HMENU>(UINT_PTR(uID)), m_hInst, this); + + m_uID=uID; + m_hWndAssociate=hWndAssoc; + + return (nullptr!=m_hWnd); +} + + +void CHatchWin::SetTrans() +{ + HRGN hrgn = CreateRectRgn(0,0,0,0); + SetWindowRgn(m_hWnd,hrgn,true); +} + +/* + * CHatchWin::HwndAssociateSet + * CHatchWin::HwndAssociateGet + * + * Purpose: + * Sets (Set) or retrieves (Get) the associate window of the + * hatch window. + * + * Parameters: (Set only) + * hWndAssoc HWND to set as the associate. + * + * Return Value: + * HWND Previous (Set) or current (Get) associate + * window. + */ + +HWND CHatchWin::HwndAssociateSet(HWND hWndAssoc) +{ + HWND hWndT=m_hWndAssociate; + + m_hWndAssociate=hWndAssoc; + return hWndT; +} + + +HWND CHatchWin::HwndAssociateGet() +{ + return m_hWndAssociate; +} + + +/* + * CHatchWin::RectsSet + * + * Purpose: + * Changes the size and position of the hatch window and the child + * window within it using a position rectangle for the child and + * a clipping rectangle for the hatch window and child. The hatch + * window occupies prcPos expanded by the hatch border and clipped + * by prcClip. The child window is fit to prcPos to give the + * proper scaling, but it clipped to the hatch window which + * therefore clips it to prcClip without affecting the scaling. + * + * Parameters: + * prcPos LPRECT providing the position rectangle. + * prcClip LPRECT providing the clipping rectangle. + * + * Return Value: + * None + */ + +void CHatchWin::RectsSet(LPRECT prcPos, LPRECT prcClip) +{ + RECT rc; + RECT rcPos; + + m_rcPos=*prcPos; + m_rcClip=*prcClip; + + //Calculate the rectangle for the hatch window, then clip it. + rcPos=*prcPos; + InflateRect(&rcPos, m_dBorder, m_dBorder); + IntersectRect(&rc, &rcPos, prcClip); + + SetWindowPos(m_hWnd, nullptr, rc.left, rc.top, rc.right-rc.left + , rc.bottom-rc.top, SWP_NOZORDER | SWP_NOACTIVATE); + + /* + * Set the rectangle of the child window to be at m_dBorder + * from the top and left but with the same size as prcPos + * contains. The hatch window will clip it. + */ +// SetWindowPos(m_hWndKid, NULL, rcPos.left-rc.left+m_dBorder +// , rcPos.top-rc.top+m_dBorder, prcPos->right-prcPos->left +// , prcPos->bottom-prcPos->top, SWP_NOZORDER | SWP_NOACTIVATE); + + RECT newRC; + GetClientRect(m_hWnd,&newRC); + m_aTracker = Tracker( + &newRC, + Tracker::hatchInside | + Tracker::hatchedBorder | + Tracker::resizeInside + ); + + return; +} + + +/* + * CHatchWin::ChildSet + * + * Purpose: + * Assigns a child window to this hatch window. + * + * Parameters: + * hWndKid HWND of the child window. + * + * Return Value: + * None + */ + +void CHatchWin::ChildSet(HWND hWndKid) +{ + m_hWndKid=hWndKid; + + if (nullptr!=hWndKid) + { + SetParent(hWndKid, m_hWnd); + + //Ensure this is visible when the hatch window becomes visible. + ShowWindow(hWndKid, SW_SHOW); + } + + return; +} + + +/* + * CHatchWin::ShowHatch + * + * Purpose: + * Turns hatching on and off; turning the hatching off changes + * the size of the window to be exactly that of the child, leaving + * everything else the same. The result is that we don't have + * to turn off drawing because our own WM_PAINT will never be + * called. + * + * Parameters: + * fHatch BOOL indicating to show (TRUE) or hide (FALSE) + the hatching. + * + * Return Value: + * None + */ + +void CHatchWin::ShowHatch(BOOL fHatch) +{ + /* + * All we have to do is set the border to zero and + * call SetRects again with the last rectangles the + * child sent to us. + */ + m_dBorder=fHatch ? m_dBorderOrg : 0; + RectsSet(&m_rcPos, &m_rcClip); + return; +} + + +/* + * HatchWndProc + * + * Purpose: + * Standard window procedure for the Hatch Window + */ + +LRESULT APIENTRY winwrap::HatchWndProc( + HWND hWnd, UINT iMsg + , WPARAM wParam, LPARAM lParam) +{ + PCHatchWin phw; + HDC hDC; + PAINTSTRUCT ps; + + phw=reinterpret_cast<PCHatchWin>(GetWindowLongPtrW(hWnd, HWWL_STRUCTURE)); + POINT ptMouse; + + switch (iMsg) + { + case WM_CREATE: + phw=static_cast<PCHatchWin>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams); + SetWindowLongPtrW(hWnd, HWWL_STRUCTURE, reinterpret_cast<LONG_PTR>(phw)); + break; + case WM_PAINT: + hDC=BeginPaint(hWnd,&ps); + //Always draw the hatching. + phw->m_aTracker.Draw(hDC); + EndPaint(hWnd,&ps); + break; + case WM_LBUTTONDOWN: + GetCursorPos(&ptMouse); + ScreenToClient(hWnd,&ptMouse); + + // track in case we have to + if(phw->m_aTracker.Track(hWnd,ptMouse,FALSE,GetParent(hWnd))) + { + RECT aRect = phw->m_aTracker.m_rect; + TransformRect(&aRect,hWnd,GetParent(hWnd)); + phw->m_pDocHolder->OnPosRectChanged(&aRect); + } + break; + case WM_LBUTTONUP: + case WM_MOUSEMOVE: + GetCursorPos(&ptMouse); + ScreenToClient(hWnd,&ptMouse); + phw->m_aTracker.SetCursor(hWnd,HTCLIENT); + break; + case WM_SETFOCUS: + //We need this since the container will SetFocus to us. + if (nullptr!=phw->m_hWndKid) + SetFocus(phw->m_hWndKid); + + break; + case WM_LBUTTONDBLCLK: + /* + * If the double click was within m_dBorder of an + * edge, send the HWN_BORDERDOUBLECLICKED notification. + * + * Because we're always sized just larger than our child + * window by the border width, we can only *get* this + * message when the mouse is on the border. So we can + * just send the notification. + */ + if (nullptr!=phw->m_hWndAssociate) + { + SendMessageW( + phw->m_hWndAssociate, WM_COMMAND, + MAKEWPARAM(phw->m_uID, HWN_BORDERDOUBLECLICKED), + reinterpret_cast<LPARAM>(hWnd)); + } + + break; + default: + return DefWindowProcW(hWnd, iMsg, wParam, lParam); + } + + return 0; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/embed/tracker.cxx b/embedserv/source/embed/tracker.cxx new file mode 100644 index 000000000..00260481c --- /dev/null +++ b/embedserv/source/embed/tracker.cxx @@ -0,0 +1,831 @@ +/* -*- 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 <algorithm> + +#include <sal/types.h> + +#include <stdafx.h> +#include <stddef.h> +#include <syswinwrapper.hxx> + + +static HCURSOR afxCursors[10] = { nullptr, }; +static HBRUSH afxHalftoneBrush = nullptr; + +namespace { + +// the struct below is used to determine the qualities of a particular handle +struct AFX_HANDLEINFO +{ + size_t nOffsetX; // offset within RECT for X coordinate + size_t nOffsetY; // offset within RECT for Y coordinate + int nCenterX; // adjust X by Width()/2 * this number + int nCenterY; // adjust Y by Height()/2 * this number + int nHandleX; // adjust X by handle size * this number + int nHandleY; // adjust Y by handle size * this number + int nInvertX; // handle converts to this when X inverted + int nInvertY; // handle converts to this when Y inverted +}; + +} + +// this array describes all 8 handles (clock-wise) +const AFX_HANDLEINFO afxHandleInfo[] = +{ + // corner handles (top-left, top-right, bottom-right, bottom-left + { offsetof(RECT, left), offsetof(RECT, top), 0, 0, 0, 0, 1, 3 }, + { offsetof(RECT, right), offsetof(RECT, top), 0, 0, -1, 0, 0, 2 }, + { offsetof(RECT, right), offsetof(RECT, bottom), 0, 0, -1, -1, 3, 1 }, + { offsetof(RECT, left), offsetof(RECT, bottom), 0, 0, 0, -1, 2, 0 }, + + // side handles (top, right, bottom, left) + { offsetof(RECT, left), offsetof(RECT, top), 1, 0, 0, 0, 4, 6 }, + { offsetof(RECT, right), offsetof(RECT, top), 0, 1, -1, 0, 7, 5 }, + { offsetof(RECT, left), offsetof(RECT, bottom), 1, 0, 0, -1, 6, 4 }, + { offsetof(RECT, left), offsetof(RECT, top), 0, 1, 0, 0, 5, 7 } +}; + +namespace { + +// the struct below gives us information on the layout of a RECT struct and +// the relationship between its members +struct AFX_RECTINFO +{ + size_t nOffsetAcross; // offset of opposite point (ie. left->right) + int nSignAcross; // sign relative to that point (ie. add/subtract) +}; + +} + +// this array is indexed by the offset of the RECT member / sizeof(int) +const AFX_RECTINFO afxRectInfo[] = +{ + { offsetof(RECT, right), +1 }, + { offsetof(RECT, bottom), +1 }, + { offsetof(RECT, left), -1 }, + { offsetof(RECT, top), -1 }, +}; + + +static HBRUSH HalftoneBrush() +{ + if (afxHalftoneBrush == nullptr) + { + WORD grayPattern[8]; + for (int i = 0; i < 8; i++) + grayPattern[i] = static_cast<WORD>(0x5555 << (i & 1)); + HBITMAP grayBitmap = CreateBitmap(8, 8, 1, 1, &grayPattern); + if (grayBitmap != nullptr) + { + afxHalftoneBrush = CreatePatternBrush(grayBitmap); + DeleteObject(grayBitmap); + } + } + return afxHalftoneBrush; +} + + +static void DrawDragRect( + HDC hDC,LPRECT lpRect,SIZE size, + LPRECT lpRectLast,SIZE sizeLast, + HBRUSH hBrush = nullptr,HBRUSH hBrushLast = nullptr) +{ + // first, determine the update region and select it + HRGN rgnNew; + HRGN rgnOutside,rgnInside; + rgnOutside = CreateRectRgnIndirect(lpRect); + RECT rect = *lpRect; + InflateRect(&rect,-size.cx, -size.cy); + IntersectRect(&rect,&rect,lpRect); + rgnInside = CreateRectRgnIndirect(&rect); + rgnNew = CreateRectRgn(0, 0, 0, 0); + CombineRgn(rgnNew,rgnOutside,rgnInside,RGN_XOR); + + HBRUSH hBrushOld = nullptr; + if (hBrush == nullptr) + hBrush = HalftoneBrush(); + if (hBrushLast == nullptr) + hBrushLast = hBrush; + + HRGN rgnLast(nullptr); + HRGN rgnUpdate(nullptr); + if (lpRectLast != nullptr) + { + // find difference between new region and old region + rgnLast = CreateRectRgn(0, 0, 0, 0); + SetRectRgn( + rgnOutside, + lpRectLast->left, + lpRectLast->top, + lpRectLast->right, + lpRectLast->bottom); + rect = *lpRectLast; + InflateRect(&rect,-sizeLast.cx, -sizeLast.cy); + IntersectRect(&rect,&rect, lpRectLast); + SetRectRgn(rgnInside,rect.left,rect.top,rect.right,rect.bottom); + CombineRgn(rgnLast,rgnOutside,rgnInside, RGN_XOR); + +// // only diff them if brushes are the same + if (hBrush == hBrushLast) + { + rgnUpdate = CreateRectRgn(0, 0, 0, 0); + CombineRgn(rgnUpdate,rgnLast,rgnNew, RGN_XOR); + } + } + if (hBrush != hBrushLast && lpRectLast != nullptr) + { + // brushes are different -- erase old region first + SelectClipRgn(hDC,rgnLast); + GetClipBox(hDC,&rect); + hBrushOld = static_cast<HBRUSH>(SelectObject(hDC,static_cast<HGDIOBJ>(hBrushLast))); + PatBlt(hDC,rect.left,rect.top,(rect.right-rect.left),(rect.bottom-rect.top),PATINVERT); + + SelectObject(hDC,static_cast<HGDIOBJ>(hBrushOld)); + hBrushOld = nullptr; + } + + // draw into the update/new region + SelectClipRgn(hDC,rgnUpdate); + + GetClipBox(hDC,&rect); + hBrushOld = static_cast<HBRUSH>(SelectObject(hDC, static_cast<HGDIOBJ>(hBrush))); + PatBlt(hDC,rect.left, rect.top,(rect.right-rect.left),(rect.bottom-rect.top), PATINVERT); + + // cleanup DC + if (hBrushOld != nullptr) + SelectObject(hDC, static_cast<HGDIOBJ>(hBrushOld)); + SelectClipRgn(hDC,nullptr); +} + + +void winwrap::TransformRect(LPRECT rect,HWND pWnd,HWND pWndClipTo) +{ + POINT pt; + pt.x = rect->left;pt.y = rect->top; + ClientToScreen(pWnd,&pt); + ScreenToClient(pWndClipTo,&pt); + rect->left = pt.x; rect->top = pt.y; + + pt.x = rect->right;pt.y = rect->bottom; + ClientToScreen(pWnd,&pt); + ScreenToClient(pWndClipTo,&pt); + rect->right = pt.x; rect->bottom = pt.y; +} + + +static void NormalizeRect(LPRECT rp) +{ + if(rp->left > rp->right) { + UINT tmp = rp->left; + rp->left = rp->right; + rp->right = tmp; + } + + if(rp->top > rp->bottom) { + UINT tmp = rp->top; + rp->top = rp->bottom; + rp->bottom = tmp; + } +} + + +using namespace winwrap; + + +Tracker::Tracker() +{ +} + + +Tracker::Tracker(LPCRECT lpSrcRect, UINT nStyle) +{ + Construct(); + CopyRect(&m_rect,lpSrcRect); + m_nStyle = nStyle; +} + +static HBRUSH afxHatchBrush = nullptr; +static HPEN afxBlackDottedPen = nullptr; +static int afxHandleSize = 0; + + +void Tracker::Construct() +{ + static bool bInitialized = false; + if (!bInitialized) + { + if (afxHatchBrush == nullptr) + { + // create the hatch pattern + bitmap + WORD hatchPattern[8]; + WORD wPattern = 0x1111; + for (int i = 0; i < 4; i++) + { + hatchPattern[i] = wPattern; + hatchPattern[i+4] = wPattern; + wPattern <<= 1; + } + HBITMAP hatchBitmap = CreateBitmap(8, 8, 1, 1,&hatchPattern); + + // create black hatched brush + afxHatchBrush = CreatePatternBrush(hatchBitmap); + DeleteObject(hatchBitmap); + } + + if (afxBlackDottedPen == nullptr) + { + // create black dotted pen + afxBlackDottedPen = CreatePen(PS_DOT, 0, RGB(0, 0, 0)); + } + + // get default handle size from Windows profile setting + static const WCHAR szWindows[] = L"windows"; + static const WCHAR szInplaceBorderWidth[] = L"oleinplaceborderwidth"; + afxHandleSize = GetProfileIntW(szWindows, szInplaceBorderWidth, 4); + bInitialized = true; + + afxCursors[0] = afxCursors[2] = LoadCursor(nullptr,IDC_SIZENWSE); + afxCursors[4] = afxCursors[6] = LoadCursor(nullptr,IDC_SIZENS); + afxCursors[1] = afxCursors[3] = LoadCursor(nullptr,IDC_SIZENESW); + afxCursors[5] = afxCursors[7] = LoadCursor(nullptr,IDC_SIZEWE); + afxCursors[8] = LoadCursor(nullptr,IDC_SIZEALL); + } + + m_nStyle = 0; + m_nHandleSize = afxHandleSize; + m_sizeMin.cy = m_sizeMin.cx = m_nHandleSize*2; + + SetRectEmpty(&m_rectLast); + m_sizeLast.cx = m_sizeLast.cy = 0; + m_bErase = FALSE; + m_bFinalErase = FALSE; +} + +Tracker::~Tracker() +{ +} + + +int Tracker::HitTest(POINT point) const +{ + TrackerHit hitResult = hitNothing; + + RECT rectTrue; + GetTrueRect(&rectTrue); + NormalizeRect(&rectTrue); + if (PtInRect(&rectTrue,point)) + { + if ((m_nStyle & (resizeInside|resizeOutside)) != 0) + hitResult = static_cast<TrackerHit>(HitTestHandles(point)); + else + hitResult = hitMiddle; + } + return hitResult; +} + + +BOOL Tracker::SetCursor(HWND pWnd, UINT nHitTest) const +{ + // trackers should only be in client area + if (nHitTest != HTCLIENT) + return FALSE; + + // convert cursor position to client co-ordinates + POINT point; + GetCursorPos(&point); + ScreenToClient(pWnd,&point); + + // do hittest and normalize hit + int nHandle = HitTestHandles(point); + if (nHandle < 0) + return FALSE; + + // need to normalize the hittest such that we get proper cursors + nHandle = NormalizeHit(nHandle); + + // handle special case of hitting area between handles + // (logically the same -- handled as a move -- but different cursor) + if (nHandle == hitMiddle && !PtInRect(&m_rect,point)) + { + // only for trackers with hatchedBorder (ie. in-place resizing) + if (m_nStyle & hatchedBorder) + nHandle = TrackerHit(9); + } + + ::SetCursor(afxCursors[nHandle]); + return TRUE; +} + + +BOOL Tracker::Track(HWND hWnd,POINT point,BOOL bAllowInvert, + HWND hWndClipTo) +{ + // perform hit testing on the handles + int nHandle = HitTestHandles(point); + if (nHandle < 0) + { + // didn't hit a handle, so just return FALSE + return FALSE; + } + + // otherwise, call helper function to do the tracking + m_bAllowInvert = bAllowInvert; + SetCursor(hWnd,nHandle); + return TrackHandle(nHandle, hWnd, point, hWndClipTo); +} + + +BOOL Tracker::TrackHandle(int nHandle,HWND hWnd,POINT point,HWND hWndClipTo) +{ + // don't handle if capture already set + if (GetCapture() != nullptr) + return FALSE; + + // save original width & height in pixels + int nWidth = m_rect.right - m_rect.left; + int nHeight = m_rect.bottom - m_rect.top; + + // set capture to the window which received this message + SetCapture(hWnd); + UpdateWindow(hWnd); + if (hWndClipTo != nullptr) + UpdateWindow(hWndClipTo); + RECT rectSave = m_rect; + + // find out what x/y coords we are supposed to modify + int *px, *py; + int xDiff, yDiff; + GetModifyPointers(nHandle, &px, &py, &xDiff, &yDiff); + xDiff = point.x - xDiff; + yDiff = point.y - yDiff; + + // get DC for drawing + HDC hDrawDC; + if (hWndClipTo != nullptr) + { + // clip to arbitrary window by using adjusted Window DC + hDrawDC = GetDCEx(hWndClipTo,nullptr, DCX_CACHE); + } + else + { + // otherwise, just use normal DC + hDrawDC = GetDC(hWnd); + } + + RECT rectOld; + bool bMoved = false; + + // get messages until capture lost or cancelled/accepted + for (;;) + { + MSG msg; + GetMessageW(&msg, nullptr, 0, 0); + + if (GetCapture() != hWnd) + break; + + switch (msg.message) + { + // handle movement/accept messages + case WM_LBUTTONUP: + case WM_MOUSEMOVE: + rectOld = m_rect; + // handle resize cases (and part of move) + if (px != nullptr) + *px = static_cast<int>(static_cast<short>(LOWORD(msg.lParam))) - xDiff; + if (py != nullptr) + *py = static_cast<int>(static_cast<short>(HIWORD(msg.lParam))) - yDiff; + + // handle move case + if (nHandle == hitMiddle) + { + m_rect.right = m_rect.left + nWidth; + m_rect.bottom = m_rect.top + nHeight; + } + // allow caller to adjust the rectangle if necessary + AdjustRect(nHandle,&m_rect); + + // only redraw and callback if the rect actually changed! + m_bFinalErase = (msg.message == WM_LBUTTONUP); + if (!EqualRect(&rectOld,&m_rect) || m_bFinalErase) + { + if (bMoved) + { + m_bErase = TRUE; + DrawTrackerRect(&rectOld,hWndClipTo,hDrawDC,hWnd); + } + OnChangedRect(rectOld); + if (msg.message != WM_LBUTTONUP) + bMoved = true; + } + if (m_bFinalErase) + goto ExitLoop; + + if (!EqualRect(&rectOld,&m_rect)) + { + m_bErase = FALSE; + DrawTrackerRect(&m_rect,hWndClipTo,hDrawDC,hWnd); + } + break; + + // handle cancel messages + case WM_KEYDOWN: + if (msg.wParam != VK_ESCAPE) + break; + [[fallthrough]]; + case WM_RBUTTONDOWN: + if (bMoved) + { + m_bErase = m_bFinalErase = TRUE; + DrawTrackerRect(&m_rect, hWndClipTo, hDrawDC, hWnd); + } + m_rect = rectSave; + goto ExitLoop; + + // just dispatch rest of the messages + default: + DispatchMessageW(&msg); + break; + } + } + + ExitLoop: + if (hWndClipTo != nullptr) + ReleaseDC(hWndClipTo,hDrawDC); + else + ReleaseDC(hWnd,hDrawDC); + ReleaseCapture(); + + // restore rect in case bMoved is still FALSE + if (!bMoved) + m_rect = rectSave; + m_bFinalErase = FALSE; + m_bErase = FALSE; + + // return TRUE only if rect has changed + return !EqualRect(&rectSave,&m_rect); +} + + +void Tracker::OnChangedRect(const RECT& /*rectOld*/) +{ +} + + +void Tracker::AdjustRect(int nHandle, LPRECT) +{ + if(nHandle == hitMiddle) + return; + + // convert the handle into locations within m_rect + int *px, *py; + GetModifyPointers(nHandle, &px, &py, nullptr, nullptr); + + // enforce minimum width + int nNewWidth = m_rect.right - m_rect.left; + int nAbsWidth = m_bAllowInvert ? abs(nNewWidth) : nNewWidth; + if (px != nullptr && nAbsWidth < m_sizeMin.cx) + { + nNewWidth = nAbsWidth != 0 ? nNewWidth / nAbsWidth : 1; + const AFX_RECTINFO* pRectInfo = + &afxRectInfo[px - reinterpret_cast<int*>(&m_rect)]; + *px = *reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&m_rect) + pRectInfo->nOffsetAcross) + + nNewWidth * m_sizeMin.cx * -pRectInfo->nSignAcross; + } + + // enforce minimum height + int nNewHeight = m_rect.bottom - m_rect.top; + int nAbsHeight = m_bAllowInvert ? abs(nNewHeight) : nNewHeight; + if (py != nullptr && nAbsHeight < m_sizeMin.cy) + { + nNewHeight = nAbsHeight != 0 ? nNewHeight / nAbsHeight : 1; + const AFX_RECTINFO* pRectInfo = + &afxRectInfo[py - reinterpret_cast<int*>(&m_rect)]; + *py = *reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&m_rect) + pRectInfo->nOffsetAcross) + + nNewHeight * m_sizeMin.cy * -pRectInfo->nSignAcross; + } +} + + +void Tracker::DrawTrackerRect( + LPRECT lpRect,HWND pWndClipTo,HDC pDC,HWND pWnd) +{ + // first, normalize the rectangle for drawing + RECT rect = *lpRect; + NormalizeRect(&rect); + + // convert to client coordinates + if (pWndClipTo != nullptr) + TransformRect(&rect,pWnd,pWndClipTo); + + SIZE size; + size.cx = 0; size.cy = 0; + if (!m_bFinalErase) + { + // otherwise, size depends on the style + if (m_nStyle & hatchedBorder) + { + size.cx = size.cy = std::max(1,GetHandleSize(&rect)-1); + InflateRect(&rect,size.cx,size.cy); + } + else + { + size.cx = 1; // CX_BORDER; + size.cy = 1; // CY_BORDER; + } + } + + // and draw it + if (m_bFinalErase || !m_bErase) + DrawDragRect(pDC,&rect,size,&m_rectLast,m_sizeLast); + + // remember last rectangles + m_rectLast = rect; + m_sizeLast = size; +} + + +void Tracker::Draw(HDC hDC) const +{ + // set initial DC state + SetMapMode(hDC,MM_TEXT); + SetViewportOrgEx(hDC,0, 0,nullptr); + SetWindowOrgEx(hDC,0, 0,nullptr); + + // get normalized rectangle + RECT rect = m_rect; + NormalizeRect(&rect); + + HPEN pOldPen = nullptr; + HBRUSH pOldBrush = nullptr; + HGDIOBJ pTemp; + int nOldROP; + + // draw lines + if ((m_nStyle & (dottedLine|solidLine)) != 0) + { + if (m_nStyle & dottedLine) + pOldPen = static_cast<HPEN>(SelectObject(hDC,afxBlackDottedPen)); + else + pOldPen = static_cast<HPEN>(SelectObject(hDC,reinterpret_cast<HGDIOBJ>(BLACK_PEN))); + pOldBrush = static_cast<HBRUSH>(SelectObject(hDC,reinterpret_cast<HGDIOBJ>(NULL_BRUSH))); + nOldROP = SetROP2(hDC,R2_COPYPEN); + InflateRect(&rect,+1, +1); // borders are one pixel outside + Rectangle(hDC,rect.left, rect.top, rect.right, rect.bottom); + SetROP2(hDC,nOldROP); + } + + // if hatchBrush is going to be used, need to unrealize it + if ((m_nStyle & (hatchInside|hatchedBorder)) != 0) + UnrealizeObject(static_cast<HGDIOBJ>(afxHatchBrush)); + + // hatch inside + if ((m_nStyle & hatchInside) != 0) + { + pTemp = SelectObject(hDC,reinterpret_cast<HGDIOBJ>(NULL_PEN)); + if (pOldPen == nullptr) + pOldPen = static_cast<HPEN>(pTemp); + pTemp = SelectObject(hDC,static_cast<HGDIOBJ>(afxHatchBrush)); + if (pOldBrush == nullptr) + pOldBrush = static_cast<HBRUSH>(pTemp); + SetBkMode(hDC,TRANSPARENT); + nOldROP = SetROP2(hDC,R2_MASKNOTPEN); + Rectangle(hDC,rect.left+1, rect.top+1, rect.right, rect.bottom); + SetROP2(hDC,nOldROP); + } + + // draw hatched border + if ((m_nStyle & hatchedBorder) != 0) + { + pTemp = SelectObject(hDC,static_cast<HGDIOBJ>(afxHatchBrush)); + if (pOldBrush == nullptr) + pOldBrush = static_cast<HBRUSH>(pTemp); + SetBkMode(hDC,OPAQUE); + RECT rectTrue; + GetTrueRect(&rectTrue); + PatBlt(hDC,rectTrue.left, rectTrue.top, rectTrue.right-rectTrue.left, + rect.top-rectTrue.top, 0x000F0001 /* Pn */); + PatBlt(hDC,rectTrue.left, rect.bottom, + rectTrue.right-rectTrue.left, + rectTrue.bottom-rect.bottom, 0x000F0001 /* Pn */); + PatBlt(hDC,rectTrue.left, rect.top, rect.left-rectTrue.left, + rect.bottom-rect.top, 0x000F0001 /* Pn */); + PatBlt(hDC,rect.right, rect.top, rectTrue.right-rect.right, + rect.bottom-rect.top, 0x000F0001 /* Pn */); + } + + // draw resize handles + if ((m_nStyle & (resizeInside|resizeOutside)) != 0) + { + UINT mask = GetHandleMask(); + HBRUSH hbrush = CreateSolidBrush(RGB(0,0,0)); + for (int i = 0; i < 8; ++i) + { + if (mask & (1<<i)) + { + GetHandleRect(static_cast<TrackerHit>(i), &rect); + // FillSolidRect(hDC,rect, RGB(0, 0, 0)); + FillRect(hDC,&rect,hbrush); + } + } + DeleteObject(hbrush); + } + + // cleanup pDC state + if (pOldPen != nullptr) + SelectObject(hDC,pOldPen); + if (pOldBrush != nullptr) + SelectObject(hDC,pOldBrush); + RestoreDC(hDC,-1); +} + + +void Tracker::GetHandleRect(int nHandle,RECT* pHandleRect) const +{ + // get normalized rectangle of the tracker + RECT rectT = m_rect; + NormalizeRect(&rectT); + if ((m_nStyle & (solidLine|dottedLine)) != 0) + InflateRect(&rectT,+1, +1); + + // since the rectangle itself was normalized, we also have to invert the + // resize handles. + nHandle = NormalizeHit(nHandle); + + // handle case of resize handles outside the tracker + int size = GetHandleSize(); + if (m_nStyle & resizeOutside) + InflateRect(&rectT,size-1, size-1); + + // calculate position of the resize handle + int nWidth = rectT.right - rectT.left; + int nHeight = rectT.bottom - rectT.top; + RECT rect; + const AFX_HANDLEINFO* pHandleInfo = &afxHandleInfo[nHandle]; + rect.left = *reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&rectT) + pHandleInfo->nOffsetX); + rect.top = *reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&rectT) + pHandleInfo->nOffsetY); + rect.left += size * pHandleInfo->nHandleX; + rect.top += size * pHandleInfo->nHandleY; + rect.left += pHandleInfo->nCenterX * (nWidth - size) / 2; + rect.top += pHandleInfo->nCenterY * (nHeight - size) / 2; + rect.right = rect.left + size; + rect.bottom = rect.top + size; + + *pHandleRect = rect; +} + + +int Tracker::GetHandleSize(LPRECT lpRect) const +{ + LPCRECT rect = lpRect == nullptr ? &m_rect : lpRect; + + int size = m_nHandleSize; + if (!(m_nStyle & resizeOutside)) + { + // make sure size is small enough for the size of the rect + int sizeMax = std::min(abs(rect->right - rect->left), + abs(rect->bottom - rect->top)); + if (size * 2 > sizeMax) + size = sizeMax / 2; + } + return size; +} + + +UINT Tracker::GetHandleMask() const +{ + UINT mask = 0x0F; // always have 4 corner handles + int size = m_nHandleSize*3; + if (abs(m_rect.right - m_rect.left) - size > 4) + mask |= 0x50; + if (abs(m_rect.bottom - m_rect.top) - size > 4) + mask |= 0xA0; + return mask; +} + + +void Tracker::GetTrueRect(LPRECT lpTrueRect) const +{ + RECT rect = m_rect; + NormalizeRect(&rect); + int nInflateBy = 0; + if ((m_nStyle & (resizeOutside|hatchedBorder)) != 0) + nInflateBy += GetHandleSize() - 1; + if ((m_nStyle & (solidLine|dottedLine)) != 0) + ++nInflateBy; + InflateRect(&rect,nInflateBy, nInflateBy); + *lpTrueRect = rect; +} + + +int Tracker::NormalizeHit(int nHandle) const +{ + if (nHandle == hitMiddle || nHandle == hitNothing) + return nHandle; + const AFX_HANDLEINFO* pHandleInfo = &afxHandleInfo[nHandle]; + if (m_rect.right - m_rect.left < 0) + { + nHandle = static_cast<TrackerHit>(pHandleInfo->nInvertX); + pHandleInfo = &afxHandleInfo[nHandle]; + } + if (m_rect.bottom - m_rect.top < 0) + nHandle = static_cast<TrackerHit>(pHandleInfo->nInvertY); + return nHandle; +} + + +int Tracker::HitTestHandles(POINT point) const +{ + RECT rect; + UINT mask = GetHandleMask(); + + // see if hit anywhere inside the tracker + GetTrueRect(&rect); + if (!PtInRect(&rect,point)) + return hitNothing; // totally missed + + // see if we hit a handle + for (int i = 0; i < 8; ++i) + { + if (mask & (1<<i)) + { + GetHandleRect(static_cast<TrackerHit>(i), &rect); + if (PtInRect(&rect,point)) + return static_cast<TrackerHit>(i); + } + } + + // last of all, check for non-hit outside of object, between resize handles + if ((m_nStyle & hatchedBorder) == 0) + { + rect = m_rect; + NormalizeRect(&rect); + if ((m_nStyle & (dottedLine|solidLine)) != 0) + InflateRect(&rect,+1, +1); + if (!PtInRect(&rect,point)) + return hitNothing; // must have been between resize handles + } + return hitMiddle; // no handle hit, but hit object (or object border) +} + + +void Tracker::GetModifyPointers( + int nHandle, int** ppx, int** ppy, int* px, int* py) +{ + if (nHandle == hitMiddle) + nHandle = hitTopLeft; // same as hitting top-left + + *ppx = nullptr; + *ppy = nullptr; + + // fill in the part of the rect that this handle modifies + // (Note: handles that map to themselves along a given axis when that + // axis is inverted don't modify the value on that axis) + + const AFX_HANDLEINFO* pHandleInfo = &afxHandleInfo[nHandle]; + if (pHandleInfo->nInvertX != nHandle) + { + *ppx = reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&m_rect) + pHandleInfo->nOffsetX); + if (px != nullptr) + *px = **ppx; + } + else + { + // middle handle on X axis + if (px != nullptr) + *px = m_rect.left + (m_rect.left-m_rect.right) / 2; + } + if (pHandleInfo->nInvertY != nHandle) + { + *ppy = reinterpret_cast<int*>(reinterpret_cast<BYTE*>(&m_rect) + pHandleInfo->nOffsetY); + if (py != nullptr) + *py = **ppy; + } + else + { + // middle handle on Y axis + if (py != nullptr) + *py = m_rect.top + (m_rect.top-m_rect.bottom) / 2; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/common.h b/embedserv/source/inc/common.h new file mode 100644 index 000000000..3fcc6712d --- /dev/null +++ b/embedserv/source/inc/common.h @@ -0,0 +1,50 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_COMMON_H +#define INCLUDED_EMBEDSERV_SOURCE_INC_COMMON_H + +#include "stdafx.h" +#include <initguid.h> + +#include <rtl/ustring.hxx> +#include <osl/interlck.h> +#include <comphelper/classids.hxx> + +#include "embservconst.h" + +namespace com::sun::star { + namespace lang { + class XMultiServiceFactory; + } + namespace frame { + class XModel; + } + namespace beans { + struct PropertyValue; + } + namespace io { + class XInputStream; + class XOutputStream; + } +} + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/docholder.hxx b/embedserv/source/inc/docholder.hxx new file mode 100644 index 000000000..7cb85af0f --- /dev/null +++ b/embedserv/source/inc/docholder.hxx @@ -0,0 +1,253 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_DOCHOLDER_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_DOCHOLDER_HXX + +#include "common.h" +#include <com/sun/star/frame/XLayoutManager.hpp> +#include <com/sun/star/util/XCloseListener.hpp> +#include <com/sun/star/frame/XTerminateListener.hpp> +#include <com/sun/star/util/XModifyListener.hpp> +#include <com/sun/star/frame/XFrame2.hpp> +#include <com/sun/star/frame/XDispatchProviderInterceptor.hpp> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/weakref.hxx> + +#include <rtl/ref.hxx> + +#include "embeddocaccess.hxx" + +class EmbedDocument_Impl; +class Interceptor; +class CIIAObj; + +namespace winwrap { + class CHatchWin; +} + + +class DocumentHolder : + public ::cppu::WeakImplHelper< + css::util::XCloseListener, + css::frame::XTerminateListener, + css::util::XModifyListener, + css::ui::XDockingAreaAcceptor> +{ +private: + ::osl::Mutex m_aMutex; + + bool m_bAllowInPlace; + LPOLEINPLACESITE m_pIOleIPSite; + LPOLEINPLACEFRAME m_pIOleIPFrame; + LPOLEINPLACEUIWINDOW m_pIOleIPUIWindow; + winwrap::CHatchWin* m_pCHatchWin; + + ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl > m_xOleAccess; + + css::uno::WeakReference< css::frame::XDispatchProviderInterceptor > m_xInterceptorLocker; + Interceptor* m_pInterceptor; + + css::uno::Reference< css::lang::XMultiServiceFactory > m_xFactory; + + RECT m_aBorder; + + // contains top level system window data + bool m_bOnDeactivate; + HWND m_hWndxWinParent; + HWND m_hWndxWinCont; + HMENU m_nMenuHandle; + HMENU m_nMenuShared; + HOLEMENU m_nOLEMenu; + css::uno::Reference< css::awt::XWindow> m_xEditWindow; + + css::uno::Reference< css::awt::XWindow> m_xContainerWindow; + + css::uno::Reference< css::frame::XModel > m_xDocument; + sal_Int16 m_nMacroExecMode; + + css::uno::Reference< css::frame::XLayoutManager> m_xLayoutManager; + + + css::uno::Reference< css::frame::XFrame2 > m_xFrame; + + OUString m_aContainerName,m_aDocumentNamePart,m_aFilterName; + + CComPtr< IDispatch > m_pIDispatch; + + bool m_bLink; + + + css::uno::Reference< css::frame::XFrame2 > DocumentFrame(); + + + css::uno::Reference< css::frame::XDispatchProviderInterceptor > + CreateNewInterceptor(); + + void ClearInterceptorInternally(); + + void LoadDocInFrame( bool bPluginMode ); +public: + + + // the instance to which we belong + static HINSTANCE m_hInstance; + + HWND GetEditWindowParentHandle() const + { + return m_hWndxWinParent; + } + + void SetContainerWindowHandle(HWND hWndxWinCont) + { + m_hWndxWinCont = hWndxWinCont; + } + + DocumentHolder( + const css::uno::Reference< css::lang::XMultiServiceFactory >& xFactory, + const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl >& xOleAccess ); + + ~DocumentHolder() override; + + // Methods for inplace activation + + + BOOL isActive() const; + void DisableInplaceActivation(BOOL); + HRESULT InPlaceActivate(LPOLECLIENTSITE,BOOL); + void InPlaceDeactivate(); + HRESULT UIActivate(); + void UIDeactivate(); + BOOL InPlaceMenuCreate(); + BOOL InPlaceMenuDestroy(); + + static void OpenIntoWindow(); + static BOOL Undo(); + + // further methods + + void SetDocument( + const css::uno::Reference< css::frame::XModel >& xDoc, + bool bLink = false + ); + + bool ExecuteSuspendCloseFrame(); + + void DisconnectFrameDocument( bool bComplete = false ); + void CloseDocument(); + void CloseFrame(); + void ClearInterceptor(); + void FreeOffice(); + + void resizeWin( const SIZEL& rNewSize ); + + void setTitle(const OUString& aDocumentName); + OUString getTitle() const { return m_aDocumentNamePart; } + + void setContainerName(const OUString& aContainerName); + OUString getContainerName() const { return m_aContainerName; } + void OnPosRectChanged(LPRECT lpRect) const; + void show(); + + bool HasFrame() { return m_xFrame.is(); } + bool IsLink() { return m_bLink; } + + /** hides the document window, even in case of an external container + * side managed window. + */ + + void hide(); + + IDispatch* GetIDispatch(); + + HRESULT GetDocumentBorder( RECT *pRect ); + // HRESULT SetVisArea( const RECTL *pRect ); + // HRESULT GetVisArea( RECTL *pRect ); + HRESULT SetExtent( const SIZEL *pSize ); + HRESULT GetExtent( SIZEL *pSize ); + // sets extension on the hatchwindow + HRESULT SetContRects(LPCRECT pRect); + HRESULT SetObjectRects(LPCRECT aRect, LPCRECT aClip); + + HWND GetTopMostWinHandle() const + { + return m_hWndxWinParent; + } + + css::uno::Reference< css::frame::XModel > + GetDocument() const + { + return m_xDocument; + } + + // XEventListener + virtual void SAL_CALL + disposing( const css::lang::EventObject& aSource ) override; + + // XCloseListener + virtual void SAL_CALL + queryClosing( + const css::lang::EventObject& aSource, + sal_Bool bGetsOwnership + ) override; + + virtual void SAL_CALL + notifyClosing( + const css::lang::EventObject& aSource + ) override; + + // XTerminateListener + virtual void SAL_CALL + queryTermination( + const css::lang::EventObject& aSource + ) override; + + virtual void SAL_CALL + notifyTermination( + const css::lang::EventObject& aSource + ) override; + + + // XModifyListener + virtual void SAL_CALL + modified( + const css::lang::EventObject& aEvent + ) override; + + // XDockingAreaAcceptor + + virtual css::uno::Reference< + css::awt::XWindow> SAL_CALL + getContainerWindow( + ) override; + + virtual sal_Bool SAL_CALL + requestDockingAreaSpace( + const css::awt::Rectangle& RequestedSpace + ) override; + + virtual void SAL_CALL + setDockingAreaSpace( + const css::awt::Rectangle& BorderSpace + ) override; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/embeddoc.hxx b/embedserv/source/inc/embeddoc.hxx new file mode 100644 index 000000000..488b142bc --- /dev/null +++ b/embedserv/source/inc/embeddoc.hxx @@ -0,0 +1,195 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_EMBEDDOC_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_EMBEDDOC_HXX + +#include "common.h" +#include <oleidl.h> +#include <objidl.h> + +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/uno/Sequence.h> +#include <unordered_map> + +#include "embeddocaccess.hxx" +#include "docholder.hxx" + +typedef std::unordered_map< DWORD, IAdviseSink* > AdviseSinkHashMap; + +class GDIMetaFile; +class CIIAObj; + +class EmbedDocument_Impl + : public IPersistStorage, + public IDataObject, + public IOleObject, + public IOleInPlaceObject, + public IPersistFile, + public IDispatch, + public IExternalConnection +{ +protected: + css::uno::Sequence< css::beans::PropertyValue > + fillArgsForLoading_Impl( css::uno::Reference< css::io::XInputStream > const & xStream, + DWORD nStreamMode, + LPCOLESTR pFilePath = nullptr ); + css::uno::Sequence< css::beans::PropertyValue > + fillArgsForStoring_Impl( css::uno::Reference< css::io::XOutputStream > const & xStream ); + + HRESULT SaveTo_Impl( IStorage* pStg ); + + sal_uInt64 getMetaFileHandle_Impl( bool isEnhMeta ); + +public: + EmbedDocument_Impl( const css::uno::Reference< css::lang::XMultiServiceFactory >& smgr, + const GUID* guid ); + virtual ~EmbedDocument_Impl(); + + /* IUnknown methods */ + STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppvObj) override; + STDMETHOD_(ULONG, AddRef)() override; + STDMETHOD_(ULONG, Release)() override; + + /* IPersistMethod */ + STDMETHOD(GetClassID)(CLSID *pClassID) override; + + /* IPersistStorage methods */ + STDMETHOD(IsDirty) () override; + STDMETHOD(InitNew) ( IStorage *pStg ) override; + STDMETHOD(Load) ( IStorage* pStr ) override; + STDMETHOD(Save) ( IStorage *pStgSave, BOOL fSameAsLoad ) override; + STDMETHOD(SaveCompleted) ( IStorage *pStgNew ) override; + STDMETHOD(HandsOffStorage) (void) override; + + /* IDataObject methods */ + STDMETHOD(GetData) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) override; + STDMETHOD(GetDataHere) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) override; + STDMETHOD(QueryGetData) ( FORMATETC * pFormatetc ) override; + STDMETHOD(GetCanonicalFormatEtc) ( FORMATETC * pFormatetcIn, FORMATETC * pFormatetcOut ) override; + STDMETHOD(SetData) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium, BOOL fRelease ) override; + STDMETHOD(EnumFormatEtc) ( DWORD dwDirection, IEnumFORMATETC ** ppFormatetc ) override; + STDMETHOD(DAdvise) ( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection ) override; + STDMETHOD(DUnadvise) ( DWORD dwConnection ) override; + STDMETHOD(EnumDAdvise) ( IEnumSTATDATA ** ppenumAdvise ) override; + + /* IOleObject methods */ + STDMETHOD(SetClientSite) ( IOleClientSite* pSite ) override; + STDMETHOD(GetClientSite) ( IOleClientSite** pSite ) override; + STDMETHOD(SetHostNames) ( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj ) override; + STDMETHOD(Close) ( DWORD dwSaveOption) override; + STDMETHOD(SetMoniker) ( DWORD dwWhichMoniker, IMoniker *pmk ) override; + STDMETHOD(GetMoniker) ( DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk ) override; + STDMETHOD(InitFromData) ( IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved ) override; + STDMETHOD(GetClipboardData) ( DWORD dwReserved, IDataObject **ppDataObject ) override; + STDMETHOD(DoVerb) ( LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect ) override; + STDMETHOD(EnumVerbs) ( IEnumOLEVERB **ppEnumOleVerb ) override; + STDMETHOD(Update) () override; + STDMETHOD(IsUpToDate) () override; + STDMETHOD(GetUserClassID) ( CLSID *pClsid ) override; + STDMETHOD(GetUserType) ( DWORD dwFormOfType, LPOLESTR *pszUserType ) override; + STDMETHOD(SetExtent) ( DWORD dwDrawAspect, SIZEL *psizel ) override; + STDMETHOD(GetExtent) ( DWORD dwDrawAspect, SIZEL *psizel ) override; + STDMETHOD(Advise) ( IAdviseSink *pAdvSink, DWORD *pdwConnection ) override; + STDMETHOD(Unadvise) ( DWORD dwConnection ) override; + STDMETHOD(EnumAdvise) ( IEnumSTATDATA **ppenumAdvise ) override; + STDMETHOD(GetMiscStatus) ( DWORD dwAspect, DWORD *pdwStatus ) override; + STDMETHOD(SetColorScheme) ( LOGPALETTE *pLogpal ) override; + + /* IOleInPlaceObject methods */ + STDMETHOD(GetWindow)(HWND *) override; + STDMETHOD(ContextSensitiveHelp)(BOOL) override; + STDMETHOD(InPlaceDeactivate)() override; + STDMETHOD(UIDeactivate)() override; + STDMETHOD(SetObjectRects)(LPCRECT, LPCRECT) override; + STDMETHOD(ReactivateAndUndo)() override; + + /* IPersistFile methods */ + STDMETHOD(Load) ( LPCOLESTR pszFileName, DWORD dwMode ) override; + STDMETHOD(Save) ( LPCOLESTR pszFileName, BOOL fRemember ) override; + STDMETHOD(SaveCompleted) ( LPCOLESTR pszFileName ) override; + STDMETHOD(GetCurFile) ( LPOLESTR *ppszFileName ) override; + + /* IDispatch methods */ + STDMETHOD(GetTypeInfoCount) ( unsigned int FAR* pctinfo ) override; + STDMETHOD(GetTypeInfo) ( unsigned int iTInfo, LCID lcid, ITypeInfo FAR* FAR* ppTInfo ) override; + STDMETHOD(GetIDsOfNames) ( REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgDispId ) override; + STDMETHOD(Invoke) ( DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR* pDispParams, VARIANT FAR* pVarResult, EXCEPINFO FAR* pExcepInfo, unsigned int FAR* puArgErr ) override; + + /* IExternalConnection methods */ + virtual DWORD STDMETHODCALLTYPE AddConnection( DWORD extconn, DWORD reserved) override; + virtual DWORD STDMETHODCALLTYPE ReleaseConnection( DWORD extconn, DWORD reserved, BOOL fLastReleaseCloses) override; + + // c++ - methods + + void notify( bool bDataChanged = true ); + HRESULT SaveObject(); + HRESULT ShowObject(); + GUID GetGUID() const { return m_guid; } + HRESULT OLENotifyClosing(); + + void Deactivate(); + HRESULT OLENotifyDeactivation(); + +protected: + oslInterlockedCount m_refCount; + + css::uno::Reference< css::lang::XMultiServiceFactory > m_xFactory; + + DocumentHolder* m_pDocHolder; + OUString m_aFileName; + + CComPtr< IStorage > m_pMasterStorage; + CComPtr< IStream > m_pOwnStream; + CComPtr< IStream > m_pExtStream; + GUID m_guid; + + bool m_bIsDirty; + + CComPtr< IOleClientSite > m_pClientSite; + CComPtr< IDataAdviseHolder > m_pDAdviseHolder; + + AdviseSinkHashMap m_aAdviseHashMap; + DWORD m_nAdviseNum; + + ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl > m_xOwnAccess; + + bool m_bIsInVerbHandling; +}; + +class BooleanGuard_Impl +{ + bool& m_bValue; + +public: + BooleanGuard_Impl( bool& bValue ) + : m_bValue( bValue ) + { + m_bValue = true; + } + + ~BooleanGuard_Impl() + { + m_bValue = false; + } +}; + +#endif // INCLUDED_EMBEDSERV_SOURCE_INC_EMBEDDOC_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/embeddocaccess.hxx b/embedserv/source/inc/embeddocaccess.hxx new file mode 100644 index 000000000..8b03900af --- /dev/null +++ b/embedserv/source/inc/embeddocaccess.hxx @@ -0,0 +1,80 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_EMBEDDOCACCESS_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_EMBEDDOCACCESS_HXX + +#define OLESERV_SAVEOBJECT 1 +#define OLESERV_CLOSE 2 +#define OLESERV_NOTIFY 3 +#define OLESERV_NOTIFYCLOSING 4 +#define OLESERV_SHOWOBJECT 5 +#define OLESERV_DEACTIVATE 6 + +#include <oleidl.h> +#if defined __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wall" +#pragma clang diagnostic ignored "-Wextra" +#pragma clang diagnostic ignored "-Wmicrosoft" +#pragma clang diagnostic ignored "-Wnon-virtual-dtor" +#endif +#include <atldbcli.h> +#if defined __clang__ +#pragma clang diagnostic pop +#endif +#include <cppuhelper/weak.hxx> + +class EmbedDocument_Impl; +struct LockedEmbedDocument_Impl +{ +private: + EmbedDocument_Impl* m_pEmbedDocument; + +public: + LockedEmbedDocument_Impl(); + LockedEmbedDocument_Impl( EmbedDocument_Impl* pEmbedDocument ); + LockedEmbedDocument_Impl( const LockedEmbedDocument_Impl& aDocLock ); + + ~LockedEmbedDocument_Impl(); + + LockedEmbedDocument_Impl& operator=( const LockedEmbedDocument_Impl& aDocLock ); + + EmbedDocument_Impl* GetEmbedDocument() { return m_pEmbedDocument; } + + void ExecuteMethod( sal_Int16 nId ); +}; + +class EmbeddedDocumentInstanceAccess_Impl : public ::cppu::OWeakObject +{ + ::osl::Mutex m_aMutex; + EmbedDocument_Impl* m_pEmbedDocument; + + public: + EmbeddedDocumentInstanceAccess_Impl( EmbedDocument_Impl* pDoc ) + : m_pEmbedDocument( pDoc ) + {} + + LockedEmbedDocument_Impl GetEmbedDocument(); + void ClearEmbedDocument(); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/embservconst.h b/embedserv/source/inc/embservconst.h new file mode 100644 index 000000000..aca7c8e49 --- /dev/null +++ b/embedserv/source/inc/embservconst.h @@ -0,0 +1,46 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_EMBSERVCONST_H +#define INCLUDED_EMBEDSERV_SOURCE_INC_EMBSERVCONST_H + +#include <guiddef.h> + +#include <comphelper/classids.hxx> + +#define SUPPORTED_FACTORIES_NUM 10 + +extern "C" const GUID DECLSPEC_SELECTANY OID_WriterTextServer = { SO3_SW_OLE_EMBED_CLASSID_60 }; +extern "C" const GUID DECLSPEC_SELECTANY OID_WriterOASISTextServer = { SO3_SW_OLE_EMBED_CLASSID_8 }; + +extern "C" const GUID DECLSPEC_SELECTANY OID_CalcServer = { SO3_SC_OLE_EMBED_CLASSID_60 }; +extern "C" const GUID DECLSPEC_SELECTANY OID_CalcOASISServer = { SO3_SC_OLE_EMBED_CLASSID_8 }; + +extern "C" const GUID DECLSPEC_SELECTANY OID_DrawingServer = { SO3_SDRAW_OLE_EMBED_CLASSID_60 }; +extern "C" const GUID DECLSPEC_SELECTANY OID_DrawingOASISServer = { SO3_SDRAW_OLE_EMBED_CLASSID_8 }; + +extern "C" const GUID DECLSPEC_SELECTANY OID_PresentationServer = { SO3_SIMPRESS_OLE_EMBED_CLASSID_60 }; +extern "C" const GUID DECLSPEC_SELECTANY OID_PresentationOASISServer = { SO3_SIMPRESS_OLE_EMBED_CLASSID_8 }; + +extern "C" const GUID DECLSPEC_SELECTANY OID_MathServer = { SO3_SM_OLE_EMBED_CLASSID_60 }; +extern "C" const GUID DECLSPEC_SELECTANY OID_MathOASISServer = { SO3_SM_OLE_EMBED_CLASSID_8 }; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/iipaobj.hxx b/embedserv/source/inc/iipaobj.hxx new file mode 100644 index 000000000..8bcc04688 --- /dev/null +++ b/embedserv/source/inc/iipaobj.hxx @@ -0,0 +1,64 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_IIPAOBJ_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_IIPAOBJ_HXX + +#include "stdafx.h" +#include <oleidl.h> + +#include <osl/interlck.h> +#include <rtl/ref.hxx> +class EmbedDocument_Impl; +class DocumentHolder; + +class CIIAObj + : public IOleInPlaceActiveObject +{ + +public: + + CIIAObj( DocumentHolder * ); + virtual ~CIIAObj(); + + /* IUnknown methods */ + STDMETHODIMP QueryInterface(REFIID, LPVOID FAR * ppvObj) override; + STDMETHODIMP_(ULONG) AddRef() override; + STDMETHODIMP_(ULONG) Release() override; + + /* IOleInPlaceActiveObject methods */ + STDMETHODIMP GetWindow(HWND *) override; + STDMETHODIMP ContextSensitiveHelp(BOOL) override; + STDMETHODIMP TranslateAccelerator(LPMSG); + STDMETHODIMP OnFrameWindowActivate(BOOL) override; + STDMETHODIMP OnDocWindowActivate(BOOL) override; + STDMETHODIMP ResizeBorder(LPCRECT, LPOLEINPLACEUIWINDOW + , BOOL) override; + STDMETHODIMP EnableModeless(BOOL) override; + + +private: + + oslInterlockedCount m_refCount; + ::rtl::Reference< DocumentHolder > m_rDocHolder; +}; + + +#endif +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/intercept.hxx b/embedserv/source/inc/intercept.hxx new file mode 100644 index 000000000..ab3fb63ca --- /dev/null +++ b/embedserv/source/inc/intercept.hxx @@ -0,0 +1,149 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_INTERCEPT_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_INTERCEPT_HXX + +#include <osl/mutex.hxx> +#include <cppuhelper/implbase.hxx> +#include <comphelper/interfacecontainer2.hxx> +#include <com/sun/star/frame/XDispatchProviderInterceptor.hpp> +#include <com/sun/star/frame/XInterceptorInfo.hpp> +#include <com/sun/star/frame/XDispatch.hpp> + +#include <rtl/ref.hxx> +#include "embeddocaccess.hxx" + + +class StatusChangeListenerContainer; +class EmbedDocument_Impl; +class DocumentHolder; + +class Interceptor + : public ::cppu::WeakImplHelper< + css::frame::XDispatchProviderInterceptor, + css::frame::XInterceptorInfo, + css::frame::XDispatch> +{ +public: + + Interceptor( + const ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl >& xOleAccess, + DocumentHolder* pDocH, + bool bLink ); + + ~Interceptor() override; + + void DisconnectDocHolder(); + + void generateFeatureStateEvent(); + + // overwritten to release the statuslistener. + + + // XComponent + /// @throws css::uno::RuntimeException + virtual void + addEventListener( + const css::uno::Reference< css::lang::XEventListener >& xListener ); + + /// @throws css::uno::RuntimeException + virtual void + removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener ); + + /// @throws css::uno::RuntimeException + void + dispose(); + + + //XDispatch + virtual void SAL_CALL + dispatch( + const css::util::URL& URL, + const css::uno::Sequence< css::beans::PropertyValue >& Arguments ) override; + + virtual void SAL_CALL + addStatusListener( + const css::uno::Reference< css::frame::XStatusListener >& Control, + const css::util::URL& URL ) override; + + virtual void SAL_CALL + removeStatusListener( + const css::uno::Reference< css::frame::XStatusListener >& Control, + const css::util::URL& URL ) override; + + //XInterceptorInfo + virtual css::uno::Sequence< OUString > + SAL_CALL getInterceptedURLs( ) override; + + + //XDispatchProvider ( inherited by XDispatchProviderInterceptor ) + virtual css::uno::Reference< + css::frame::XDispatch > SAL_CALL + queryDispatch( + const css::util::URL& URL, + const OUString& TargetFrameName, + sal_Int32 SearchFlags ) override; + + virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL + queryDispatches( + const css::uno::Sequence< + css::frame::DispatchDescriptor >& Requests ) override; + + + //XDispatchProviderInterceptor + virtual css::uno::Reference< css::frame::XDispatchProvider > SAL_CALL + getSlaveDispatchProvider( ) override; + + virtual void SAL_CALL + setSlaveDispatchProvider( + const css::uno::Reference< css::frame::XDispatchProvider >& NewDispatchProvider ) override; + + virtual css::uno::Reference< css::frame::XDispatchProvider > SAL_CALL + getMasterDispatchProvider( ) override; + + virtual void SAL_CALL + setMasterDispatchProvider( + const css::uno::Reference< css::frame::XDispatchProvider >& NewSupplier ) override; + + +private: + + osl::Mutex m_aMutex; + + ::rtl::Reference< EmbeddedDocumentInstanceAccess_Impl > m_xOleAccess; + + css::uno::WeakReference< css::uno::XInterface > m_xDocHLocker; + DocumentHolder* m_pDocH; + + css::uno::Reference< css::frame::XDispatchProvider > m_xSlaveDispatchProvider; + + css::uno::Reference< css::frame::XDispatchProvider > m_xMasterDispatchProvider; + + static css::uno::Sequence< OUString > m_aInterceptedURL; + + comphelper::OInterfaceContainerHelper2* m_pDisposeEventListeners; + StatusChangeListenerContainer* m_pStatCL; + + bool m_bLink; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/servprov.hxx b/embedserv/source/inc/servprov.hxx new file mode 100644 index 000000000..6d1d887da --- /dev/null +++ b/embedserv/source/inc/servprov.hxx @@ -0,0 +1,82 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_SERVPROV_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_SERVPROV_HXX + +#include "common.h" +#include <oleidl.h> +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/uno/Sequence.h> +#include <com/sun/star/uno/XInterface.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <cppuhelper/implbase.hxx> + + +class EmbedProviderFactory_Impl; + +class EmbedServer_Impl: public cppu::WeakImplHelper<css::lang::XServiceInfo> +{ +public: + EmbedServer_Impl( const css::uno::Reference< css::lang::XMultiServiceFactory > &xFactory ); + virtual ~EmbedServer_Impl() override; + + OUString SAL_CALL getImplementationName() override; + + sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override; + + css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override; + +protected: + + CComPtr< EmbedProviderFactory_Impl > m_pOLEFactories[ SUPPORTED_FACTORIES_NUM ]; + css::uno::Reference< css::lang::XMultiServiceFactory > m_xFactory; +}; + +class EmbedProviderFactory_Impl : public IClassFactory +{ +public: + + EmbedProviderFactory_Impl( const css::uno::Reference< css::lang::XMultiServiceFactory >& xFactory, const GUID* pGuid); + virtual ~EmbedProviderFactory_Impl(); + + bool registerClass(); + bool deregisterClass(); + + /* IUnknown methods */ + STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR * ppvObj) override; + STDMETHOD_(ULONG, AddRef)() override; + STDMETHOD_(ULONG, Release)() override; + + /* IClassFactory methods */ + STDMETHOD(CreateInstance)(IUnknown FAR* punkOuter, REFIID riid, void FAR* FAR* ppv) override; + STDMETHOD(LockServer)(int fLock) override; + +protected: + + oslInterlockedCount m_refCount; + GUID m_guid; + DWORD m_factoryHandle; + + css::uno::Reference< css::lang::XMultiServiceFactory > m_xFactory; +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/stdafx.h b/embedserv/source/inc/stdafx.h new file mode 100644 index 000000000..9ec4fffca --- /dev/null +++ b/embedserv/source/inc/stdafx.h @@ -0,0 +1,51 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +#if !defined(AFX_STDAFX_H_) +#define AFX_STDAFX_H_ + +#define STRICT +#define _ATL_APARTMENT_THREADED +// #define _ATL_STATIC_REGISTRY + +#ifdef _MSC_VER +#if defined __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wall" +#pragma clang diagnostic ignored "-Wattributes" +#pragma clang diagnostic ignored "-Wdelete-incomplete" +#pragma clang diagnostic ignored "-Wdynamic-class-memaccess" +#pragma clang diagnostic ignored "-Wextra" +#pragma clang diagnostic ignored "-Wint-to-pointer-cast" +#pragma clang diagnostic ignored "-Winvalid-noreturn" +#pragma clang diagnostic ignored "-Wmicrosoft" +#pragma clang diagnostic ignored "-Wnon-pod-varargs" +#pragma clang diagnostic ignored "-Wnon-virtual-dtor" +#pragma clang diagnostic ignored "-Wnonportable-include-path" +#pragma clang diagnostic ignored "-Wsequence-point" +#pragma clang diagnostic ignored "-Wtypename-missing" +#endif +#endif +#include <atlbase.h> +#if defined max +#undef max +#endif +#if defined min +#undef min +#endif +//You may derive a class from CComModule and use it if you want to override +//something, but do not change the name of _Module +extern CComModule _Module; +#include <atlcom.h> +#include <atlctl.h> + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#ifdef _MSC_VER +#if defined __clang__ +#pragma clang diagnostic pop +#endif +#endif + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inc/syswinwrapper.hxx b/embedserv/source/inc/syswinwrapper.hxx new file mode 100644 index 000000000..f255058bf --- /dev/null +++ b/embedserv/source/inc/syswinwrapper.hxx @@ -0,0 +1,176 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INC_SYSWINWRAPPER_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INC_SYSWINWRAPPER_HXX + +#if !defined WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include <windows.h> + +/** + ** CWindow: Our basic window class. + **/ + + +class DocumentHolder; + + +namespace winwrap { + + + void TransformRect(LPRECT rect,HWND pWnd,HWND pWndClipTo); + + + LRESULT APIENTRY HatchWndProc( + HWND hWnd, UINT iMsg + , WPARAM wParam, LPARAM lParam); + + + BOOL HatchWindowRegister(HINSTANCE hInst); + + class CWindow + { + protected: + HINSTANCE m_hInst; //Task instance + HWND m_hWnd; //Window handle of the window + + public: + //Standard Class Functions + CWindow(HINSTANCE); + ~CWindow(); + + //Just returns members. No need to modify + HWND Window(); + HINSTANCE Instance(); + }; + + + class Tracker { + public: + // Constructors + Tracker(); + Tracker(LPCRECT lpSrcRect, UINT nStyle); + + // Style Flags + enum StyleFlags + { + solidLine = 1, dottedLine = 2, hatchedBorder = 4, + resizeInside = 8, resizeOutside = 16, hatchInside = 32, + }; + + // Hit-Test codes + enum TrackerHit + { + hitNothing = -1, + hitTopLeft = 0, hitTopRight = 1, + hitBottomRight = 2, hitBottomLeft = 3, + hitTop = 4, hitRight = 5, hitBottom = 6, + hitLeft = 7, hitMiddle = 8 + }; + + // Attributes + UINT m_nStyle; // current state + RECT m_rect; // current position (always in pixels) + SIZE m_sizeMin; // minimum X and Y size during track operation + int m_nHandleSize; // size of resize handles (default from WIN.INI) + + // Operations + void Draw(HDC hDC) const; + void GetTrueRect(LPRECT lpTrueRect) const; + BOOL SetCursor(HWND hWnd,UINT nHitTest) const; + BOOL Track(HWND hWnd,POINT point,BOOL bAllowInvert = FALSE, + HWND hWndClipTo = nullptr); +// BOOL TrackRubberBand(HWND hWnd,POINT point,BOOL bAllowInvert = TRUE); + int HitTest(POINT point) const; + int NormalizeHit(int nHandle) const; + + // Overridables + virtual void DrawTrackerRect( + LPRECT lpRect, HWND hWndClipTo, + HDC hDC, HWND hWnd); + virtual void AdjustRect(int nHandle, LPRECT lpRect); + virtual void OnChangedRect(const RECT& rectOld); + virtual UINT GetHandleMask() const; + +// Implementation + public: + virtual ~Tracker(); + +protected: + BOOL m_bAllowInvert; // flag passed to Track or TrackRubberBand + RECT m_rectLast; + SIZE m_sizeLast; + BOOL m_bErase; // TRUE if DrawTrackerRect is called for erasing + BOOL m_bFinalErase; // TRUE if DragTrackerRect called for final erase + + // implementation helpers + int HitTestHandles(POINT point) const; + void GetHandleRect(int nHandle,RECT* pHandleRect) const; + void GetModifyPointers( + int nHandle,int**ppx, int**ppy, int* px, int*py); + virtual int GetHandleSize(LPRECT lpRect = nullptr) const; + BOOL TrackHandle(int nHandle,HWND hWnd,POINT point,HWND hWndClipTo); + void Construct(); + }; + + +//Width of the border +#define HATCHWIN_BORDERWIDTHDEFAULT 4 + + + class CHatchWin : public CWindow + { + friend LRESULT APIENTRY HatchWndProc(HWND, UINT, WPARAM, LPARAM); + + public: + + const DocumentHolder* m_pDocHolder; + Tracker m_aTracker; + + int m_dBorder; + int m_dBorderOrg; + WORD m_uID; + HWND m_hWndParent; + HWND m_hWndKid; + HWND m_hWndAssociate; + RECT m_rcPos; + RECT m_rcClip; + + public: + CHatchWin(HINSTANCE,const DocumentHolder*); + ~CHatchWin(); + + BOOL Init(HWND, WORD, HWND); + + HWND HwndAssociateSet(HWND); + HWND HwndAssociateGet(); + + void RectsSet(LPRECT, LPRECT); + void ChildSet(HWND); + void ShowHatch(BOOL); + void SetTrans(); + }; + +} + +#endif // INCLUDED_EMBEDSERV_SOURCE_INC_SYSWINWRAPPER_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/advisesink.cxx b/embedserv/source/inprocserv/advisesink.cxx new file mode 100644 index 000000000..faf37e20e --- /dev/null +++ b/embedserv/source/inprocserv/advisesink.cxx @@ -0,0 +1,168 @@ +/* -*- 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 "advisesink.hxx" + +namespace inprocserv +{ + +OleWrapperAdviseSink::OleWrapperAdviseSink() +: m_nRefCount( 0 ) +, m_nAspect( DVASPECT_CONTENT ) +, m_nRegID( 0 ) +, m_bObjectAdvise( TRUE ) +, m_nDataRegFlag( 0 ) +, m_nViewRegFlag( 0 ) +, m_bHandleClosed( TRUE ) +, m_bClosed( FALSE ) +{ +} + +OleWrapperAdviseSink::OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener ) +: m_nRefCount( 0 ) +, m_pListener( pListener ) +, m_nAspect( DVASPECT_CONTENT ) +, m_nRegID( 0 ) +, m_bObjectAdvise( TRUE ) +, m_nDataRegFlag( 0 ) +, m_nViewRegFlag( 0 ) +, m_bHandleClosed( FALSE ) +, m_bClosed( FALSE ) +{ +} + +OleWrapperAdviseSink::OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener, FORMATETC* pFormatEtc, DWORD nDataRegFlag ) +: m_nRefCount( 0 ) +, m_pListener( pListener ) +, m_nAspect( DVASPECT_CONTENT ) +, m_nRegID( 0 ) +, m_bObjectAdvise( FALSE ) +, m_nDataRegFlag( nDataRegFlag ) +, m_nViewRegFlag( 0 ) +, m_bHandleClosed( FALSE ) +, m_bClosed( FALSE ) +{ + if ( pFormatEtc ) + { + m_pFormatEtc = std::make_unique<FORMATETC>(); + m_pFormatEtc->cfFormat = pFormatEtc->cfFormat; + m_pFormatEtc->ptd = nullptr; + m_pFormatEtc->dwAspect = pFormatEtc->dwAspect; + m_pFormatEtc->lindex = pFormatEtc->lindex; + m_pFormatEtc->tymed = pFormatEtc->tymed; + } +} + +OleWrapperAdviseSink::OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener, DWORD nAspect, DWORD nViewRegFlag ) +: m_nRefCount( 0 ) +, m_pListener( pListener ) +, m_nAspect( nAspect ) +, m_nRegID( 0 ) +, m_bObjectAdvise( TRUE ) +, m_nDataRegFlag( 0 ) +, m_nViewRegFlag( nViewRegFlag ) +, m_bHandleClosed( FALSE ) +, m_bClosed( FALSE ) +{ +} + +OleWrapperAdviseSink::~OleWrapperAdviseSink() +{} + +STDMETHODIMP OleWrapperAdviseSink::QueryInterface( REFIID riid , void** ppv ) +{ + *ppv=nullptr; + + if ( riid == IID_IUnknown ) + *ppv = static_cast<IUnknown*>(this); + + if ( riid == IID_IAdviseSink ) + *ppv = static_cast<IAdviseSink*>(this); + + if ( *ppv != nullptr ) + { + static_cast<IUnknown*>(*ppv)->AddRef(); + return S_OK; + } + + return E_NOINTERFACE; +} + +STDMETHODIMP_(ULONG) OleWrapperAdviseSink::AddRef() +{ + return ++m_nRefCount; +} + +STDMETHODIMP_(ULONG) OleWrapperAdviseSink::Release() +{ + ULONG nReturn = --m_nRefCount; + if ( m_nRefCount == 0 ) + delete this; + + return nReturn; +} + +STDMETHODIMP_(void) OleWrapperAdviseSink::OnDataChange( FORMATETC * pFetc, STGMEDIUM * pMedium ) +{ + if ( m_pListener ) + { + m_pListener->OnDataChange( pFetc, pMedium ); + } +} + +STDMETHODIMP_(void) OleWrapperAdviseSink::OnViewChange( DWORD dwAspect, LONG lindex ) +{ + if ( m_pListener ) + { + m_pListener->OnViewChange( dwAspect, lindex ); + } +} + +STDMETHODIMP_(void) OleWrapperAdviseSink::OnRename( IMoniker * pMoniker ) +{ + if ( m_pListener ) + { + m_pListener->OnRename( pMoniker ); + } +} + +STDMETHODIMP_(void) OleWrapperAdviseSink::OnSave() +{ + if ( m_pListener ) + { + m_pListener->OnSave(); + } +} + +STDMETHODIMP_(void) OleWrapperAdviseSink::OnClose() +{ + if ( m_pListener ) + { + m_pListener->OnClose(); + } + + if ( m_bHandleClosed ) + m_bClosed = TRUE; +} + +} // namespace inprocserv + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/advisesink.hxx b/embedserv/source/inprocserv/advisesink.hxx new file mode 100644 index 000000000..e1bc55a4c --- /dev/null +++ b/embedserv/source/inprocserv/advisesink.hxx @@ -0,0 +1,101 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_ADVISESINK_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_ADVISESINK_HXX + +#include <sal/config.h> + +#include <memory> + +#if !defined WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include <windows.h> +#include <objidl.h> +#include "smartpointer.hxx" + +namespace inprocserv { + +class OleWrapperAdviseSink : public IAdviseSink +{ +protected: + ULONG m_nRefCount; + + ComSmart< IAdviseSink > m_pListener; + DWORD m_nListenerID; + + std::unique_ptr<FORMATETC> m_pFormatEtc; + DWORD m_nAspect; + + DWORD m_nRegID; + DWORD m_bObjectAdvise; + DWORD m_nDataRegFlag; + DWORD m_nViewRegFlag; + + BOOL m_bHandleClosed; + BOOL m_bClosed; + +public: + // an AdviseSink for own needs, should be created always + OleWrapperAdviseSink(); + + // an AdviseSink for IOleObject interface + explicit OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener ); + + // an AdviseSink for IDataObject interface + OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener, FORMATETC* pFormatEtc, DWORD nDataRegFlag ); + + // an AdviseSink for IViewObject interface + OleWrapperAdviseSink( const ComSmart< IAdviseSink >& pListener, DWORD nAspect, DWORD nViewRegFlag ); + + virtual ~OleWrapperAdviseSink(); + + void SetRegID( DWORD nRegID ) { m_nRegID = nRegID; } + DWORD GetRegID() { return m_nRegID; } + + bool IsOleAdvise() { return m_bObjectAdvise; } + DWORD GetDataAdviseFlag() { return m_nDataRegFlag; } + DWORD GetViewAdviseFlag() { return m_nViewRegFlag; } + + FORMATETC* GetFormatEtc() { return m_pFormatEtc.get(); } + DWORD GetAspect() { return m_nAspect; } + ComSmart< IAdviseSink >& GetOrigAdvise() { return m_pListener; } + void DisconnectOrigAdvise() { m_pListener = nullptr; } + + void SetClosed() { m_bClosed = TRUE; } + void UnsetClosed() { m_bClosed = FALSE; } + BOOL IsClosed() { return m_bClosed; } + + STDMETHODIMP QueryInterface(REFIID, void**) override; + STDMETHODIMP_(ULONG) AddRef() override; + STDMETHODIMP_(ULONG) Release() override; + + STDMETHODIMP_(void) OnDataChange(FORMATETC *, STGMEDIUM *) override; + STDMETHODIMP_(void) OnViewChange(DWORD, LONG) override; + STDMETHODIMP_(void) OnRename(IMoniker *) override; + STDMETHODIMP_(void) OnSave() override; + STDMETHODIMP_(void) OnClose() override; +}; + +}; // namespace advisesink + +#endif // INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_ADVISESINK_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/dllentry.cxx b/embedserv/source/inprocserv/dllentry.cxx new file mode 100644 index 000000000..78b7d18ed --- /dev/null +++ b/embedserv/source/inprocserv/dllentry.cxx @@ -0,0 +1,335 @@ +/* -*- 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/types.h> + +#include <stdio.h> +#include "inprocembobj.h" +#include <embservconst.h> + +#include <olectl.h> // declarations of DllRegisterServer/DllUnregisterServer + +static const GUID* guidList[ SUPPORTED_FACTORIES_NUM ] = { + &OID_WriterTextServer, + &OID_WriterOASISTextServer, + &OID_CalcServer, + &OID_CalcOASISServer, + &OID_DrawingServer, + &OID_DrawingOASISServer, + &OID_PresentationServer, + &OID_PresentationOASISServer, + &OID_MathServer, + &OID_MathOASISServer +}; + +static HINSTANCE g_hInstance = nullptr; +static ULONG g_nObj = 0; +static ULONG g_nLock = 0; + + +namespace { + void FillCharFromInt( int nValue, wchar_t* pBuf, int nLen ) + { + int nInd = 0; + while( nInd < nLen ) + { + char nSign = ( nValue / ( 1 << ( ( nLen - nInd - 1 ) * 4 ) ) ) % 16; + if ( nSign >= 0 && nSign <= 9 ) + pBuf[nInd] = nSign + L'0'; + else if (nSign >= 10) + pBuf[nInd] = nSign - 10 + L'a'; + + nInd++; + } + } + + int GetStringFromClassID( const GUID& guid, wchar_t* pBuf, int nLen ) + { + // is not allowed to insert + if ( nLen < 38 ) + return 0; + + pBuf[0] = L'{'; + FillCharFromInt( guid.Data1, &pBuf[1], 8 ); + pBuf[9] = L'-'; + FillCharFromInt( guid.Data2, &pBuf[10], 4 ); + pBuf[14] = L'-'; + FillCharFromInt( guid.Data3, &pBuf[15], 4 ); + pBuf[19] = L'-'; + + int nInd = 0; + for ( nInd = 0; nInd < 2 ; nInd++ ) + FillCharFromInt( guid.Data4[nInd], &pBuf[20 + 2*nInd], 2 ); + pBuf[24] = L'-'; + for ( nInd = 2; nInd < 8 ; nInd++ ) + FillCharFromInt( guid.Data4[nInd], &pBuf[20 + 1 + 2*nInd], 2 ); + pBuf[37] = L'}'; + + return 38; + } + + HRESULT WriteLibraryToRegistry( const wchar_t* pLibrary, DWORD nLen ) + { + HRESULT hRes = E_FAIL; + if ( pLibrary && nLen ) + { + HKEY hKey = nullptr; + + hRes = S_OK; + for ( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ ) + { + const wchar_t pSubKeyTemplate[] = L"Software\\Classes\\CLSID\\.....................................\\InprocHandler32"; + wchar_t pSubKey[SAL_N_ELEMENTS(pSubKeyTemplate)]; + wcsncpy(pSubKey, pSubKeyTemplate, SAL_N_ELEMENTS(pSubKeyTemplate)); + + int nGuidLen = GetStringFromClassID( *guidList[nInd], &pSubKey[23], 38 ); + + bool bLocalSuccess = false; + if ( nGuidLen == 38 ) + { + if ( ERROR_SUCCESS == RegOpenKeyW( HKEY_LOCAL_MACHINE, pSubKey, &hKey ) ) + { + if ( ERROR_SUCCESS == RegSetValueExW( hKey, L"", 0, REG_SZ, reinterpret_cast<const BYTE*>(pLibrary), nLen*sizeof(wchar_t) ) ) + bLocalSuccess = true; + } + + if ( hKey ) + { + RegCloseKey( hKey ); + hKey = nullptr; + } + } + + if ( !bLocalSuccess ) + hRes = E_FAIL; + } + } + + return hRes; + } +}; + + +// InprocEmbedProvider_Impl declaration + + +namespace inprocserv +{ + +namespace { + +class InprocEmbedProvider_Impl : public IClassFactory, public InprocCountedObject_Impl +{ +public: + + explicit InprocEmbedProvider_Impl( const GUID& guid ); + virtual ~InprocEmbedProvider_Impl(); + + /* IUnknown methods */ + STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObj) override; + STDMETHOD_(ULONG, AddRef)() override; + STDMETHOD_(ULONG, Release)() override; + + /* IClassFactory methods */ + STDMETHOD(CreateInstance)(IUnknown FAR* punkOuter, REFIID riid, void FAR* FAR* ppv) override; + STDMETHOD(LockServer)(BOOL fLock) override; + +protected: + + ULONG m_refCount; + GUID m_guid; +}; + +} + +}; // namespace inprocserv + + +// Entry points + + +extern "C" BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/ ) +{ + if (dwReason == DLL_PROCESS_ATTACH) + { + g_hInstance = hInstance; + } + + return TRUE; // ok +} + + +STDAPI DllGetClassObject( REFCLSID rclsid, REFIID riid, LPVOID* ppv ) +{ + for( int nInd = 0; nInd < SUPPORTED_FACTORIES_NUM; nInd++ ) + if ( *guidList[nInd] == rclsid ) + { + if ( !IsEqualIID( riid, IID_IUnknown ) && !IsEqualIID( riid, IID_IClassFactory ) ) + return E_NOINTERFACE; + + *ppv = new inprocserv::InprocEmbedProvider_Impl( rclsid ); + static_cast<LPUNKNOWN>(*ppv)->AddRef(); + return S_OK; + } + + return E_FAIL; +} + + +STDAPI DllCanUnloadNow() +{ + if ( !g_nObj && !g_nLock ) + return S_OK; + + return S_FALSE; +} + + +STDAPI DllRegisterServer() +{ + HMODULE aCurModule = GetModuleHandleW( L"inprocserv.dll" ); + if( aCurModule ) + { + wchar_t aLibPath[1024]; + DWORD nLen = GetModuleFileNameW( aCurModule, aLibPath, 1019 ); + if ( nLen && nLen < 1019 ) + { + aLibPath[nLen++] = 0; + return WriteLibraryToRegistry( aLibPath, nLen ); + } + } + + return E_FAIL; +} + + +STDAPI DllUnregisterServer() +{ + return WriteLibraryToRegistry( L"ole32.dll", 10 ); +} + + +// End of entry points + + +namespace inprocserv +{ + + +// InprocCountedObject_Impl implementation + + +InprocCountedObject_Impl::InprocCountedObject_Impl() +{ + g_nObj++; +} + + +InprocCountedObject_Impl::~InprocCountedObject_Impl() +{ + g_nObj--; +} + + +// InprocEmbedProvider_Impl implementation + + +InprocEmbedProvider_Impl::InprocEmbedProvider_Impl( const GUID& guid ) +: m_refCount( 0 ) +, m_guid( guid ) +{ +} + + +InprocEmbedProvider_Impl::~InprocEmbedProvider_Impl() +{ +} + +// IUnknown + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedProvider_Impl::QueryInterface( REFIID riid, void ** ppv ) +{ + if(IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppv = static_cast<IUnknown*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IClassFactory)) + { + AddRef(); + *ppv = static_cast<IClassFactory*>(this); + return S_OK; + } + + *ppv = nullptr; + return E_NOINTERFACE; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedProvider_Impl::AddRef() +{ + return ++m_refCount; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedProvider_Impl::Release() +{ + sal_Int32 nCount = --m_refCount; + if ( nCount == 0 ) + delete this; + return nCount; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedProvider_Impl::CreateInstance(IUnknown FAR* punkOuter, + REFIID riid, + void FAR* FAR* ppv) +{ + // TODO/LATER: should the aggregation be supported? + // if ( punkOuter != NULL && riid != IID_IUnknown ) + // return E_NOINTERFACE; + if ( punkOuter != nullptr ) + return CLASS_E_NOAGGREGATION; + + InprocEmbedDocument_Impl* pEmbedDocument = new InprocEmbedDocument_Impl( m_guid ); + pEmbedDocument->AddRef(); + HRESULT hr = pEmbedDocument->QueryInterface( riid, ppv ); + pEmbedDocument->Release(); + + if ( !SUCCEEDED( hr ) ) + *ppv = nullptr; + + return hr; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedProvider_Impl::LockServer( BOOL fLock ) +{ + if ( fLock ) + g_nLock++; + else + g_nLock--; + + return S_OK; +} + +}; // namespace inprocserv + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/inprocembobj.cxx b/embedserv/source/inprocserv/inprocembobj.cxx new file mode 100644 index 000000000..23a1df21a --- /dev/null +++ b/embedserv/source/inprocserv/inprocembobj.cxx @@ -0,0 +1,1777 @@ +/* -*- 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/types.h> + +#include <embservconst.h> +#include "inprocembobj.h" + +namespace inprocserv +{ + +namespace { + +void SetName( LPCOLESTR pszNameFromOutside, wchar_t*& pOwnName ) +{ + if ( !pszNameFromOutside ) + return; + + // copy the string + size_t nLen = 0; + while( pszNameFromOutside[nLen] != 0 ) + nLen++; + + if ( pOwnName ) + { + delete[] pOwnName; + pOwnName = nullptr; + } + + pOwnName = new wchar_t[nLen+1]; + for ( size_t nInd = 0; nInd < nLen; nInd++ ) + pOwnName[nInd] = pszNameFromOutside[nInd]; + pOwnName[nLen] = 0; +} + +DWORD InsertAdviseLinkToList( const ComSmart<OleWrapperAdviseSink>& pOwnAdvise, ComSmart< OleWrapperAdviseSink > pAdvises[] ) +{ + // the result should start from 1 in case of success, the element 0 can be used for own needs + DWORD nResult = 0; + + if ( pOwnAdvise ) + { + for ( DWORD nInd = 1; nInd < DEFAULT_ARRAY_LEN && nResult == 0; nInd++ ) + { + if ( pAdvises[nInd] == pOwnAdvise ) + { + nResult = nInd; + } + else if ( pAdvises[nInd] == nullptr ) + { + pAdvises[nInd] = pOwnAdvise; + nResult = nInd; + } + } + } + + return nResult; +} + +} + +BOOL InprocEmbedDocument_Impl::CheckDefHandler() +{ + // set the own listener + if ( m_pOleAdvises[0] == nullptr ) + { + m_pOleAdvises[0] = new OleWrapperAdviseSink(); + } + else + { + if ( m_pOleAdvises[0]->IsClosed() ) + { + if ( m_pDefHandler ) + { + // deregister all the listeners + + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + if ( SUCCEEDED( hr ) && pOleObject ) + { + for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ ) + if ( m_pOleAdvises[nInd] ) + { + DWORD nID = m_pOleAdvises[nInd]->GetRegID(); + pOleObject->Unadvise( nID ); + m_pOleAdvises[nInd]->SetRegID( 0 ); + } + + pOleObject->SetClientSite( nullptr ); + } + + ComSmart< IDataObject > pIDataObject; + hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + if ( SUCCEEDED( hr ) && pIDataObject ) + { + for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ ) + if ( m_pDataAdvises[nInd] ) + { + DWORD nID = m_pDataAdvises[nInd]->GetRegID(); + pIDataObject->DUnadvise( nID ); + m_pDataAdvises[nInd]->SetRegID( 0 ); + } + } + + ComSmart< IViewObject > pIViewObject; + hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + if ( SUCCEEDED( hr ) && pIViewObject ) + { + if ( m_pViewAdvise ) + pIViewObject->SetAdvise( m_pViewAdvise->GetAspect(), m_pViewAdvise->GetViewAdviseFlag(), nullptr ); + } + + ComSmart< IPersistStorage > pPersist; + hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + if ( SUCCEEDED( hr ) && pPersist ) + { + // disconnect the old wrapper from the storage + pPersist->HandsOffStorage(); + } + + m_pDefHandler = nullptr; + } + + m_pOleAdvises[0]->UnsetClosed(); + } + } + + if ( m_nCallsOnStack ) + return FALSE; + + if ( !m_pDefHandler ) + { + // create a new default inprocess handler + HRESULT hr = OleCreateDefaultHandler( m_guid, nullptr, IID_IUnknown, reinterpret_cast<void**>(&m_pDefHandler) ); + if ( SUCCEEDED( hr ) ) + { + if ( m_nInitMode == INIT_FROM_STORAGE ) + { + ComSmart< IPersistStorage > pPersist; + hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist && m_pStorage ) + hr = pPersist->InitNew( m_pStorage.get() ); + } + else if ( m_nInitMode == LOAD_FROM_STORAGE ) + { + ComSmart< IPersistStorage > pPersist; + hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist && m_pStorage ) + hr = pPersist->Load( m_pStorage.get() ); + } + else if ( m_nInitMode == LOAD_FROM_FILE ) + { + ComSmart< IPersistFile > pPersistFile; + hr = m_pDefHandler->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pPersistFile) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersistFile && m_pFileName ) + hr = pPersistFile->Load( m_pFileName, m_nFileOpenMode ); + } + } + + if ( !SUCCEEDED( hr ) || !m_pDefHandler ) + { + m_pDefHandler = nullptr; + return FALSE; + } + + // register all the listeners new + + ComSmart< IOleObject > pOleObject; + hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + if ( SUCCEEDED( hr ) && pOleObject ) + { + if ( m_pClientSite ) + pOleObject->SetClientSite( m_pClientSite.get() ); + + for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ ) + if ( m_pOleAdvises[nInd] ) + { + DWORD nRegID = 0; + if ( SUCCEEDED( pOleObject->Advise( m_pOleAdvises[nInd].get(), &nRegID ) ) && nRegID > 0 ) + m_pOleAdvises[nInd]->SetRegID( nRegID ); + } + } + + ComSmart< IDataObject > pIDataObject; + hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + if ( SUCCEEDED( hr ) && pIDataObject ) + { + for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ ) + if ( m_pDataAdvises[nInd] ) + { + DWORD nRegID = 0; + if ( SUCCEEDED( pIDataObject->DAdvise( m_pDataAdvises[nInd]->GetFormatEtc(), m_pDataAdvises[nInd]->GetDataAdviseFlag(), m_pDataAdvises[nInd].get(), &nRegID ) ) && nRegID > 0 ) + m_pDataAdvises[nInd]->SetRegID( nRegID ); + } + } + + ComSmart< IViewObject > pIViewObject; + hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + if ( SUCCEEDED( hr ) && pIViewObject ) + { + if ( m_pViewAdvise ) + pIViewObject->SetAdvise( m_pViewAdvise->GetAspect(), m_pViewAdvise->GetViewAdviseFlag(), m_pViewAdvise.get() ); + } + } + + + return TRUE; +} + +void InprocEmbedDocument_Impl::Clean() +{ + m_pDefHandler = nullptr; + + // no DisconnectOrigAdvise() call here, since it is no explicit disconnection + for ( DWORD nInd = 0; nInd < DEFAULT_ARRAY_LEN; nInd++ ) + { + if ( m_pOleAdvises[nInd] ) + { + ComSmart< OleWrapperAdviseSink > pAdvise = m_pOleAdvises[nInd]; + m_pOleAdvises[nInd] = nullptr; + } + + if ( m_pDataAdvises[nInd] ) + { + ComSmart< OleWrapperAdviseSink > pAdvise = m_pDataAdvises[nInd]; + m_pDataAdvises[nInd] = nullptr; + } + } + + m_pViewAdvise = nullptr; + + m_nInitMode = NOINIT; + m_pStorage = nullptr; + + if ( m_pOleContainer ) + { + m_pOleContainer->LockContainer( FALSE ); + m_pOleContainer = nullptr; + } + + m_pClientSite = nullptr; + + m_nFileOpenMode = 0; + if ( m_pFileName ) + { + delete m_pFileName; + m_pFileName = nullptr; + } +} + +// IUnknown + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::QueryInterface( REFIID riid, void FAR* FAR* ppv ) +{ + if(IsEqualIID(riid, IID_IUnknown)) + { + AddRef(); + *ppv = static_cast<IUnknown*>(static_cast<IPersistStorage*>(this)); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersist)) + { + AddRef(); + *ppv = static_cast<IPersist*>(static_cast<IPersistStorage*>(this)); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersistStorage)) + { + AddRef(); + *ppv = static_cast<IPersistStorage*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IDataObject)) + { + AddRef(); + *ppv = static_cast<IDataObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleObject)) + { + AddRef(); + *ppv = static_cast<IOleObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IPersistFile)) + { + AddRef(); + *ppv = static_cast<IPersistFile*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IRunnableObject)) + { + AddRef(); + *ppv = static_cast<IRunnableObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IViewObject)) + { + AddRef(); + *ppv = static_cast<IViewObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IViewObject2)) + { + AddRef(); + *ppv = static_cast<IViewObject2*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleCache)) + { + AddRef(); + *ppv = static_cast<IOleCache*>(&m_aInternalCache); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleCache2)) + { + AddRef(); + *ppv = static_cast<IOleCache2*>(&m_aInternalCache); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleWindow)) + { + AddRef(); + *ppv = static_cast<IOleWindow*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IOleInPlaceObject)) + { + AddRef(); + *ppv = static_cast<IOleInPlaceObject*>(this); + return S_OK; + } + else if (IsEqualIID(riid, IID_IDispatch)) + { + AddRef(); + *ppv = static_cast<IDispatch*>(this); + return S_OK; + } + + *ppv = nullptr; + return ResultFromScode(E_NOINTERFACE); +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::AddRef() +{ + return ++m_refCount; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::Release() +{ + // unfortunately there are reentrance problems in mfc that have to be workarounded + sal_Int32 nCount = m_refCount > 0 ? --m_refCount : 0; + if ( nCount == 0 && !m_bDeleted ) + { + // deleting of this object can trigger deleting of mfc objects that will try to delete this object one more time + m_bDeleted = TRUE; + + Clean(); + delete this; + } + return nCount; +} + +// IPersist + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetClassID( CLSID* pClassId ) +{ + *pClassId = m_guid; + return S_OK; +} + +// IPersistStorage + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::IsDirty() +{ + if ( m_pDefHandler == nullptr || m_pOleAdvises[0] == nullptr || m_pOleAdvises[0]->IsClosed() ) + return S_FALSE; + + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + return pPersist->IsDirty(); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InitNew( IStorage *pStg ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->InitNew( pStg ); + if ( SUCCEEDED( hr ) ) + { + m_nInitMode = INIT_FROM_STORAGE; + m_pStorage = pStg; + + m_nFileOpenMode = 0; + if ( m_pFileName ) + { + delete[] m_pFileName; + m_pFileName = nullptr; + } + } + + return hr; + } + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Load( IStorage *pStg ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->Load( pStg ); + if ( SUCCEEDED( hr ) ) + { + m_nInitMode = LOAD_FROM_STORAGE; + m_pStorage = pStg; + + m_nFileOpenMode = 0; + if ( m_pFileName ) + { + delete[] m_pFileName; + m_pFileName = nullptr; + } + } + + return hr; + } + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Save( IStorage *pStgSave, BOOL fSameAsLoad ) +{ + if ( fSameAsLoad && ( m_pDefHandler == nullptr || m_pOleAdvises[0] == nullptr || m_pOleAdvises[0]->IsClosed() ) ) + return S_OK; + + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + return pPersist->Save( pStgSave, fSameAsLoad ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SaveCompleted( IStorage *pStgNew ) +{ + if ( m_pDefHandler == nullptr || m_pOleAdvises[0] == nullptr || m_pOleAdvises[0]->IsClosed() ) + { + if ( pStgNew ) + m_pStorage = pStgNew; + + return S_OK; + } + + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->SaveCompleted( pStgNew ); + if ( SUCCEEDED( hr ) ) + { + m_nInitMode = LOAD_FROM_STORAGE; + if ( pStgNew ) + { + m_pStorage = pStgNew; + } + + m_nFileOpenMode = 0; + if ( m_pFileName ) + { + delete[] m_pFileName; + m_pFileName = nullptr; + } + } + + return hr; + } + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::HandsOffStorage() +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistStorage > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistStorage, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->HandsOffStorage(); + if ( SUCCEEDED( hr ) ) + { + m_pStorage = nullptr; + } + + return hr; + } + } + + return E_FAIL; +} + +// IPersistFile + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Load( LPCOLESTR pszFileName, DWORD dwMode ) +{ + if ( CheckDefHandler() && pszFileName ) + { + ComSmart< IPersistFile > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->Load( pszFileName, dwMode ); + if ( SUCCEEDED( hr ) ) + { + m_nInitMode = LOAD_FROM_FILE; + if ( m_pStorage ) + m_pStorage = nullptr; + + m_nFileOpenMode = dwMode; + // copy the string + SetName( pszFileName, m_pFileName ); + } + + return hr; + } + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Save( LPCOLESTR pszFileName, BOOL fRemember ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistFile > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + return pPersist->Save( pszFileName, fRemember ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SaveCompleted( LPCOLESTR pszFileName ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistFile > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + { + hr = pPersist->SaveCompleted( pszFileName ); + if ( SUCCEEDED( hr ) ) + { + m_nInitMode = LOAD_FROM_STORAGE; + if ( m_pStorage ) + m_pStorage = nullptr; + + m_nFileOpenMode = STGM_READWRITE; // was just written + // copy the string + SetName( pszFileName, m_pFileName ); + } + } + + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetCurFile( LPOLESTR *ppszFileName ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IPersistFile > pPersist; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IPersistFile, reinterpret_cast<void**>(&pPersist) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pPersist ) + return pPersist->GetCurFile( ppszFileName ); + } + + return E_FAIL; +} + +// IOleObject + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetClientSite( IOleClientSite* pSite ) +{ + if ( pSite == m_pClientSite.get() ) + return S_OK; + + if ( !pSite ) + { + m_pClientSite = nullptr; + if ( m_pOleContainer ) + { + m_pOleContainer->LockContainer( FALSE ); + m_pOleContainer = nullptr; + } + } + + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + HRESULT hr2 = pOleObject->SetClientSite( pSite ); + if ( SUCCEEDED( hr2 ) ) + { + m_pClientSite = pSite; + + if ( m_pOleContainer ) + { + m_pOleContainer->LockContainer( FALSE ); + m_pOleContainer = nullptr; + } + + m_pClientSite->GetContainer( &m_pOleContainer ); + if ( m_pOleContainer ) + m_pOleContainer->LockContainer( TRUE ); + } + + return hr2; + } + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetClientSite( IOleClientSite** pSite ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetClientSite( pSite ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetHostNames( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj ) +{ + + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + hr = pOleObject->SetHostNames( szContainerApp, szContainerObj ); + } + } + + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Close( DWORD dwSaveOption ) +{ + HRESULT ret = S_OK; + if ( m_pDefHandler && CheckDefHandler() ) + { + // no need to close if there is no default handler. + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + hr = pOleObject->Close( dwSaveOption ); + if (!SUCCEEDED(hr)) + ret = hr; + hr = CoDisconnectObject( static_cast<IUnknown*>(static_cast<IPersistStorage*>(this)), 0 ); + if (!SUCCEEDED(hr) && SUCCEEDED(ret)) + ret = hr; + } + } + + // if the object is closed from outside that means that it should go to uninitialized state + Clean(); + + return ret; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetMoniker( DWORD dwWhichMoniker, IMoniker * pmk ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->SetMoniker( dwWhichMoniker, pmk ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetMoniker( DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetMoniker( dwAssign, dwWhichMoniker, ppmk ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InitFromData( IDataObject * pDataObject, BOOL fCreation, DWORD dwReserved ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->InitFromData( pDataObject, fCreation, dwReserved ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetClipboardData( DWORD dwReserved, IDataObject ** ppDataObject ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetClipboardData( dwReserved, ppDataObject ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::DoVerb( + LONG iVerb, + LPMSG pMsg, + IOleClientSite *pActiveSite, + LONG nLong, + HWND hWin, + LPCRECT pRect ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + hr = pOleObject->DoVerb( iVerb, pMsg, pActiveSite, nLong, hWin, pRect ); + return hr; + } + + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::EnumVerbs( IEnumOLEVERB ** ppEnumOleVerb ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->EnumVerbs( ppEnumOleVerb ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Update() +{ + + if ( m_pDefHandler && CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->Update(); + } + + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::IsUpToDate() +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->IsUpToDate(); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetUserClassID( CLSID *pClsid ) +{ + if ( pClsid ) + *pClsid = m_guid; + + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetUserType( DWORD dwFormOfType, LPOLESTR * pszUserType ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetUserType( dwFormOfType, pszUserType ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetExtent( DWORD dwDrawAspect, SIZEL *psizel ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->SetExtent( dwDrawAspect, psizel ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetExtent( DWORD dwDrawAspect, SIZEL * psizel ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetExtent( dwDrawAspect, psizel ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Advise( IAdviseSink *pAdvSink, DWORD *pdwConnection ) +{ + + if ( !pdwConnection ) + return E_FAIL; + + // CheckDefHandler will set the listener, avoid reusing of old listener + if ( DEFAULT_ARRAY_LEN > *pdwConnection && *pdwConnection > 0 && m_pOleAdvises[*pdwConnection] ) + { + m_pOleAdvises[*pdwConnection]->DisconnectOrigAdvise(); + m_pOleAdvises[*pdwConnection] = nullptr; + } + + if ( pAdvSink && CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + ComSmart<IAdviseSink> aListener(pAdvSink); + ComSmart<OleWrapperAdviseSink> pOwnAdvise(new OleWrapperAdviseSink(aListener)); + DWORD nRegID = 0; + + if ( SUCCEEDED( pOleObject->Advise( pOwnAdvise.get(), &nRegID ) ) && nRegID > 0 ) + { + pOwnAdvise->SetRegID( nRegID ); + *pdwConnection = InsertAdviseLinkToList( pOwnAdvise, m_pOleAdvises ); + if ( *pdwConnection ) + return S_OK; + else + pOleObject->Unadvise( nRegID ); + } + } + } + + // return success always for now + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Unadvise( DWORD dwConnection ) +{ + if ( DEFAULT_ARRAY_LEN > dwConnection && dwConnection > 0 && m_pOleAdvises[dwConnection] ) + { + if ( m_pDefHandler ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + { + DWORD nID = m_pOleAdvises[dwConnection]->GetRegID(); + pOleObject->Unadvise( nID ); + } + } + + m_pOleAdvises[dwConnection]->DisconnectOrigAdvise(); + m_pOleAdvises[dwConnection] = nullptr; + + return S_OK; + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::EnumAdvise( IEnumSTATDATA ** /*ppenumAdvise*/ ) +{ + return E_NOTIMPL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetMiscStatus( DWORD dwAspect, DWORD * pdwStatus ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->GetMiscStatus( dwAspect, pdwStatus ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetColorScheme( LOGPALETTE * pLogpal ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleObject > pOleObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleObject, reinterpret_cast<void**>(&pOleObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pOleObject ) + return pOleObject->SetColorScheme( pLogpal ); + } + + return E_FAIL; +} + +//IDataObject + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetData( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->GetData( pFormatetc, pMedium ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetDataHere( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->GetDataHere( pFormatetc, pMedium ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::QueryGetData( FORMATETC * pFormatetc ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->QueryGetData( pFormatetc ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetCanonicalFormatEtc( FORMATETC * pFormatetcIn, FORMATETC * pFormatetcOut ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->GetCanonicalFormatEtc( pFormatetcIn, pFormatetcOut ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetData( FORMATETC * pFormatetc, STGMEDIUM * pMedium, BOOL fRelease ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->SetData( pFormatetc, pMedium, fRelease ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::EnumFormatEtc( DWORD dwDirection, IEnumFORMATETC ** ppFormatetc ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->EnumFormatEtc( dwDirection, ppFormatetc ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::DAdvise( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection ) +{ + + if ( !pdwConnection ) + return E_FAIL; + + // avoid reusing of the old listener + if ( m_pDefHandler && DEFAULT_ARRAY_LEN > *pdwConnection && *pdwConnection > 0 && m_pDataAdvises[*pdwConnection] ) + { + m_pDataAdvises[*pdwConnection]->DisconnectOrigAdvise(); + m_pDataAdvises[*pdwConnection] = nullptr; + } + + if ( pAdvSink && CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + { + ComSmart< OleWrapperAdviseSink > pOwnAdvise( new OleWrapperAdviseSink( ComSmart<IAdviseSink>( pAdvSink ), pFormatetc, advf ) ); + DWORD nRegID = 0; + + if ( SUCCEEDED( pIDataObject->DAdvise( pFormatetc, advf, pOwnAdvise.get(), &nRegID ) ) && nRegID > 0 ) + { + pOwnAdvise->SetRegID( nRegID ); + *pdwConnection = InsertAdviseLinkToList( pOwnAdvise, m_pDataAdvises ); + if ( *pdwConnection ) + return S_OK; + else + pIDataObject->DUnadvise( nRegID ); + } + } + } + + // return success always for now + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::DUnadvise( DWORD dwConnection ) +{ + if ( m_pDefHandler && DEFAULT_ARRAY_LEN > dwConnection && dwConnection > 0 && m_pDataAdvises[dwConnection] ) + { + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + { + DWORD nID = m_pDataAdvises[dwConnection]->GetRegID(); + pIDataObject->DUnadvise( nID ); + } + } + + m_pDataAdvises[dwConnection]->DisconnectOrigAdvise(); + m_pDataAdvises[dwConnection] = nullptr; + + return S_OK; + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::EnumDAdvise( IEnumSTATDATA ** ppenumAdvise ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDataObject > pIDataObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDataObject, reinterpret_cast<void**>(&pIDataObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDataObject ) + return pIDataObject->EnumDAdvise( ppenumAdvise ); + } + + return E_FAIL; +} + +// IRunnableObject + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetRunningClass( LPCLSID lpClsid ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IRunnableObject > pIRunObj; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, reinterpret_cast<void**>(&pIRunObj) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIRunObj ) + return pIRunObj->GetRunningClass( lpClsid ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Run( LPBINDCTX pbc ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IRunnableObject > pIRunObj; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, reinterpret_cast<void**>(&pIRunObj) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIRunObj ) + return pIRunObj->Run( pbc ); + } + + return E_FAIL; +} + +BOOL STDMETHODCALLTYPE InprocEmbedDocument_Impl::IsRunning() +{ + if (CheckDefHandler()) + { + ComSmart< IRunnableObject > pIRunObj; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, reinterpret_cast<void**>(&pIRunObj) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIRunObj ) + return pIRunObj->IsRunning(); + } + + return FALSE; +} + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::LockRunning( BOOL fLock, BOOL fLastUnlockCloses ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IRunnableObject > pIRunObj; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, reinterpret_cast<void**>(&pIRunObj) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIRunObj ) + return pIRunObj->LockRunning( fLock, fLastUnlockCloses ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetContainedObject( BOOL fContained) +{ + if ( CheckDefHandler() ) + { + ComSmart< IRunnableObject > pIRunObj; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IRunnableObject, reinterpret_cast<void**>(&pIRunObj) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIRunObj ) + return pIRunObj->SetContainedObject( fContained ); + } + + return E_FAIL; +} + + +// IViewObject methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Draw( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL ( STDMETHODCALLTYPE *pfnContinue )( ULONG_PTR dwContinue ), ULONG_PTR dwContinue ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IViewObject > pIViewObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject ) + return pIViewObject->Draw( dwDrawAspect, lindex, pvAspect, ptd, hdcTargetDev, hdcDraw, lprcBounds, lprcWBounds, pfnContinue, dwContinue ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetColorSet( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IViewObject > pIViewObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject ) + return pIViewObject->GetColorSet( dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, ppColorSet ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Freeze( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IViewObject > pIViewObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject ) + return pIViewObject->Freeze( dwDrawAspect, lindex, pvAspect, pdwFreeze ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Unfreeze( DWORD dwFreeze ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IViewObject > pIViewObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject ) + return pIViewObject->Unfreeze( dwFreeze ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetAdvise( DWORD aspects, DWORD advf, IAdviseSink *pAdvSink ) +{ + + // CheckDefHandler will set the listener, avoid reusing of old listener + if ( m_pViewAdvise ) + { + m_pViewAdvise->DisconnectOrigAdvise(); + m_pViewAdvise = nullptr; + } + + if ( pAdvSink && CheckDefHandler() ) + { + ComSmart< IViewObject > pIViewObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject, reinterpret_cast<void**>(&pIViewObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject ) + { + ComSmart<IAdviseSink> aListener(pAdvSink); + ComSmart<OleWrapperAdviseSink> pOwnAdvise(new OleWrapperAdviseSink(aListener, aspects, advf)); + + if ( SUCCEEDED( pIViewObject->SetAdvise( aspects, advf, pOwnAdvise.get() ) ) ) + { + m_pViewAdvise = pOwnAdvise; + return S_OK; + } + } + } + + return S_OK; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetAdvise( DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink ) +{ + if ( !ppAdvSink ) + return E_INVALIDARG; + + if ( m_pViewAdvise ) + { + if ( pAspects ) + *pAspects = m_pViewAdvise->GetAspect(); + + if ( pAdvf ) + *pAdvf = m_pViewAdvise->GetViewAdviseFlag(); + + *ppAdvSink = m_pViewAdvise->GetOrigAdvise().get(); + if ( *ppAdvSink ) + (*ppAdvSink)->AddRef(); + } + else + *ppAdvSink = nullptr; + + return S_OK; +} + +// IViewObject2 methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetExtent( DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IViewObject2 > pIViewObject2; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IViewObject2, reinterpret_cast<void**>(&pIViewObject2) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIViewObject2 ) + return pIViewObject2->GetExtent( dwDrawAspect, lindex, ptd, lpsizel ); + } + + return E_FAIL; +} + + +// IOleWindow methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetWindow( HWND *phwnd ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleWindow > pIOleWindow; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleWindow, reinterpret_cast<void**>(&pIOleWindow) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleWindow ) + return pIOleWindow->GetWindow( phwnd ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::ContextSensitiveHelp( BOOL fEnterMode ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleWindow > pIOleWindow; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleWindow, reinterpret_cast<void**>(&pIOleWindow) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleWindow ) + return pIOleWindow->ContextSensitiveHelp( fEnterMode ); + } + + return E_FAIL; +} + + +// IOleInPlaceObject methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InPlaceDeactivate() +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleInPlaceObject > pIOleInPlaceObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, reinterpret_cast<void**>(&pIOleInPlaceObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleInPlaceObject ) + return pIOleInPlaceObject->InPlaceDeactivate(); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::UIDeactivate() +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleInPlaceObject > pIOleInPlaceObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, reinterpret_cast<void**>(&pIOleInPlaceObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleInPlaceObject ) + return pIOleInPlaceObject->UIDeactivate(); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::SetObjectRects( LPCRECT lprcPosRect, LPCRECT lprcClipRect ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleInPlaceObject > pIOleInPlaceObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, reinterpret_cast<void**>(&pIOleInPlaceObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleInPlaceObject ) + return pIOleInPlaceObject->SetObjectRects( lprcPosRect, lprcClipRect ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::ReactivateAndUndo() +{ + if ( CheckDefHandler() ) + { + ComSmart< IOleInPlaceObject > pIOleInPlaceObject; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IOleInPlaceObject, reinterpret_cast<void**>(&pIOleInPlaceObject) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleInPlaceObject ) + return pIOleInPlaceObject->ReactivateAndUndo(); + } + + return E_FAIL; +} + + +// IDispatch methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetTypeInfoCount( UINT *pctinfo ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDispatch > pIDispatch; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, reinterpret_cast<void**>(&pIDispatch) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDispatch ) + return pIDispatch->GetTypeInfoCount( pctinfo ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetTypeInfo( UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDispatch > pIDispatch; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, reinterpret_cast<void**>(&pIDispatch) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDispatch ) + return pIDispatch->GetTypeInfo( iTInfo, lcid, ppTInfo ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::GetIDsOfNames( REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDispatch > pIDispatch; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, reinterpret_cast<void**>(&pIDispatch) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDispatch ) + return pIDispatch->GetIDsOfNames( riid, rgszNames, cNames, lcid, rgDispId ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::Invoke( DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr ) +{ + if ( CheckDefHandler() ) + { + ComSmart< IDispatch > pIDispatch; + HRESULT hr = m_pDefHandler->QueryInterface( IID_IDispatch, reinterpret_cast<void**>(&pIDispatch) ); + + ULONGGuard aGuard( &m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIDispatch ) + return pIDispatch->Invoke( dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr ); + } + + return E_FAIL; +} + + +// InternalCacheWrapper + + +// IUnknown + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::QueryInterface( REFIID riid, void FAR* FAR* ppv ) +{ + return m_rOwnDocument.QueryInterface( riid, ppv ); +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::InternalCacheWrapper::AddRef() +{ + return m_rOwnDocument.AddRef(); +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP_(ULONG) InprocEmbedDocument_Impl::InternalCacheWrapper::Release() +{ + return m_rOwnDocument.Release(); +} + +// IOleCache methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::Cache( FORMATETC *pformatetc, DWORD advf, DWORD *pdwConnection ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache > pIOleCache; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache ) + return pIOleCache->Cache( pformatetc, advf, pdwConnection ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::Uncache( DWORD dwConnection ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache > pIOleCache; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache ) + return pIOleCache->Uncache( dwConnection ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::EnumCache( IEnumSTATDATA **ppenumSTATDATA ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache > pIOleCache; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache ) + return pIOleCache->EnumCache( ppenumSTATDATA ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::InitCache( IDataObject *pDataObject ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache > pIOleCache; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache ) + return pIOleCache->InitCache( pDataObject ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::SetData( FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache > pIOleCache; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache, reinterpret_cast<void**>(&pIOleCache) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache ) + return pIOleCache->SetData( pformatetc, pmedium, fRelease ); + } + + return E_FAIL; +} + +// IOleCache2 methods + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::UpdateCache( LPDATAOBJECT pDataObject, DWORD grfUpdf, LPVOID pReserved ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache2 > pIOleCache2; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache2, reinterpret_cast<void**>(&pIOleCache2) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache2 ) + return pIOleCache2->UpdateCache( pDataObject, grfUpdf, pReserved ); + } + + return E_FAIL; +} + + +COM_DECLSPEC_NOTHROW STDMETHODIMP InprocEmbedDocument_Impl::InternalCacheWrapper::DiscardCache( DWORD dwDiscardOptions ) +{ + if ( m_rOwnDocument.CheckDefHandler() ) + { + ComSmart< IOleCache2 > pIOleCache2; + HRESULT hr = m_rOwnDocument.GetDefHandler()->QueryInterface( IID_IOleCache2, reinterpret_cast<void**>(&pIOleCache2) ); + + ULONGGuard aGuard( &m_rOwnDocument.m_nCallsOnStack ); // avoid reentrance problem + if ( SUCCEEDED( hr ) && pIOleCache2 ) + return pIOleCache2->DiscardCache( dwDiscardOptions ); + } + + return E_FAIL; +} + +}; // namespace inprocserv + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/inprocembobj.h b/embedserv/source/inprocserv/inprocembobj.h new file mode 100644 index 000000000..8b0b8bd89 --- /dev/null +++ b/embedserv/source/inprocserv/inprocembobj.h @@ -0,0 +1,233 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_INPROCEMBOBJ_H +#define INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_INPROCEMBOBJ_H + +#if !defined WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include <windows.h> +#include <oleidl.h> + +#include "smartpointer.hxx" +#include "advisesink.hxx" + +#define DEFAULT_ARRAY_LEN 256 + +namespace inprocserv { + +enum InitModes { + NOINIT, + INIT_FROM_STORAGE, + LOAD_FROM_STORAGE, + LOAD_FROM_FILE +}; + + +// this is a common baseclass that is used to count the objects + +class InprocCountedObject_Impl +{ +public: + InprocCountedObject_Impl(); + ~InprocCountedObject_Impl(); +}; + + +// this is the inprocess embedded object implementation class + +class InprocEmbedDocument_Impl : public InprocCountedObject_Impl + , public IOleObject + , public IDataObject + , public IPersistStorage + , public IPersistFile + , public IRunnableObject + , public IViewObject2 + // , public IExternalConnection + , public IOleInPlaceObject + , public IDispatch +{ + ULONG m_refCount; + BOOLEAN m_bDeleted; + + GUID m_guid; + + ComSmart< IUnknown > m_pDefHandler; + InitModes m_nInitMode; + + DWORD m_nFileOpenMode; + wchar_t* m_pFileName; + + ComSmart< IStorage > m_pStorage; + + ComSmart< IOleClientSite > m_pClientSite; + ComSmart< IOleContainer > m_pOleContainer; + + ULONG m_nCallsOnStack; + + // the listeners have wrappers that are directly connected to the object and call the listeners, + // the wrappers will be reconnected correctly to the new default inprocess holder object + ComSmart< OleWrapperAdviseSink > m_pOleAdvises[DEFAULT_ARRAY_LEN]; + ComSmart< OleWrapperAdviseSink > m_pDataAdvises[DEFAULT_ARRAY_LEN]; + ComSmart< OleWrapperAdviseSink > m_pViewAdvise; + + class InternalCacheWrapper final: public IOleCache2 + { + InprocEmbedDocument_Impl& m_rOwnDocument; + + public: + explicit InternalCacheWrapper( InprocEmbedDocument_Impl& rOwnDocument ) + : m_rOwnDocument( rOwnDocument ) + {} + + virtual ~InternalCacheWrapper() {} + + /* IUnknown methods */ + STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObj) override; + STDMETHOD_(ULONG, AddRef)() override; + STDMETHOD_(ULONG, Release)() override; + + /* IOleCache2 methods */ + STDMETHOD(Cache)( FORMATETC *pformatetc, DWORD advf, DWORD *pdwConnection) override; + STDMETHOD(Uncache)( DWORD dwConnection) override; + STDMETHOD(EnumCache)( IEnumSTATDATA **ppenumSTATDATA) override; + STDMETHOD(InitCache)( IDataObject *pDataObject) override; + STDMETHOD(SetData)( FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease) override; + STDMETHOD(UpdateCache)( LPDATAOBJECT pDataObject, DWORD grfUpdf, LPVOID pReserved) override; + STDMETHOD(DiscardCache)( DWORD dwDiscardOptions) override; + } m_aInternalCache; + + void Clean(); + + +public: + + explicit InprocEmbedDocument_Impl( const GUID& guid ) + : m_refCount( 0 ) + , m_bDeleted( FALSE ) + , m_guid( guid ) + , m_nInitMode( NOINIT ) + , m_nFileOpenMode( 0 ) + , m_pFileName( nullptr ) + , m_nCallsOnStack( 0 ) + , m_aInternalCache( *this ) + {} + + virtual ~InprocEmbedDocument_Impl() + {} + + BOOL CheckDefHandler(); + ComSmart< IUnknown >& GetDefHandler() { return m_pDefHandler; } + + /* IUnknown methods */ + STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObj) override; + STDMETHOD_(ULONG, AddRef)() override; + STDMETHOD_(ULONG, Release)() override; + + /* IOleObject methods */ + STDMETHOD(SetClientSite) ( IOleClientSite* pSite ) override; + STDMETHOD(GetClientSite) ( IOleClientSite** pSite ) override; + STDMETHOD(SetHostNames) ( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj ) override; + STDMETHOD(Close) ( DWORD dwSaveOption) override; + STDMETHOD(SetMoniker) ( DWORD dwWhichMoniker, IMoniker *pmk ) override; + STDMETHOD(GetMoniker) ( DWORD dwAssign, DWORD dwWhichMoniker, IMoniker **ppmk ) override; + STDMETHOD(InitFromData) ( IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved ) override; + STDMETHOD(GetClipboardData) ( DWORD dwReserved, IDataObject **ppDataObject ) override; + STDMETHOD(DoVerb) ( LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect ) override; + STDMETHOD(EnumVerbs) ( IEnumOLEVERB **ppEnumOleVerb ) override; + STDMETHOD(Update) () override; + STDMETHOD(IsUpToDate) () override; + STDMETHOD(GetUserClassID) ( CLSID *pClsid ) override; + STDMETHOD(GetUserType) ( DWORD dwFormOfType, LPOLESTR *pszUserType ) override; + STDMETHOD(SetExtent) ( DWORD dwDrawAspect, SIZEL *psizel ) override; + STDMETHOD(GetExtent) ( DWORD dwDrawAspect, SIZEL *psizel ) override; + STDMETHOD(Advise) ( IAdviseSink *pAdvSink, DWORD *pdwConnection ) override; + STDMETHOD(Unadvise) ( DWORD dwConnection ) override; + STDMETHOD(EnumAdvise) ( IEnumSTATDATA **ppenumAdvise ) override; + STDMETHOD(GetMiscStatus) ( DWORD dwAspect, DWORD *pdwStatus ) override; + STDMETHOD(SetColorScheme) ( LOGPALETTE *pLogpal ) override; + + /* IDataObject methods */ + STDMETHOD(GetData) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) override; + STDMETHOD(GetDataHere) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium ) override; + STDMETHOD(QueryGetData) ( FORMATETC * pFormatetc ) override; + STDMETHOD(GetCanonicalFormatEtc) ( FORMATETC * pFormatetcIn, FORMATETC * pFormatetcOut ) override; + STDMETHOD(SetData) ( FORMATETC * pFormatetc, STGMEDIUM * pMedium, BOOL fRelease ) override; + STDMETHOD(EnumFormatEtc) ( DWORD dwDirection, IEnumFORMATETC ** ppFormatetc ) override; + STDMETHOD(DAdvise) ( FORMATETC * pFormatetc, DWORD advf, IAdviseSink * pAdvSink, DWORD * pdwConnection ) override; + STDMETHOD(DUnadvise) ( DWORD dwConnection ) override; + STDMETHOD(EnumDAdvise) ( IEnumSTATDATA ** ppenumAdvise ) override; + + /* IPersistMethod */ + STDMETHOD(GetClassID)(CLSID *pClassID) override; + + /* IPersistStorage methods */ + STDMETHOD(IsDirty) () override; + STDMETHOD(InitNew) ( IStorage *pStg ) override; + STDMETHOD(Load) ( IStorage* pStr ) override; + STDMETHOD(Save) ( IStorage *pStgSave, BOOL fSameAsLoad ) override; + STDMETHOD(SaveCompleted) ( IStorage *pStgNew ) override; + STDMETHOD(HandsOffStorage) (void) override; + + /* IPersistFile methods */ + STDMETHOD(Load) ( LPCOLESTR pszFileName, DWORD dwMode ) override; + STDMETHOD(Save) ( LPCOLESTR pszFileName, BOOL fRemember ) override; + STDMETHOD(SaveCompleted) ( LPCOLESTR pszFileName ) override; + STDMETHOD(GetCurFile) ( LPOLESTR *ppszFileName ) override; + + /* IRunnableObject methods */ + STDMETHOD(GetRunningClass) ( LPCLSID lpClsid) override; + STDMETHOD(Run) ( LPBINDCTX pbc) override; + virtual BOOL STDMETHODCALLTYPE IsRunning( void) override; + STDMETHOD(LockRunning) ( BOOL fLock, BOOL fLastUnlockCloses ) override; + STDMETHOD(SetContainedObject) ( BOOL fContained) override; + + /* IViewObject2 methods */ + STDMETHOD(Draw)( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL ( STDMETHODCALLTYPE *pfnContinue )( ULONG_PTR dwContinue ), ULONG_PTR dwContinue) override; + STDMETHOD(GetColorSet)( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, LOGPALETTE **ppColorSet) override; + STDMETHOD(Freeze)( DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze) override; + STDMETHOD(Unfreeze)( DWORD dwFreeze) override; + STDMETHOD(SetAdvise)( DWORD aspects, DWORD advf, IAdviseSink *pAdvSink) override; + STDMETHOD(GetAdvise)( DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink) override; + STDMETHOD(GetExtent)( DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel) override; + + /* IOleWindow methods */ + STDMETHOD(GetWindow)( HWND *phwnd) override; + STDMETHOD(ContextSensitiveHelp)( BOOL fEnterMode) override; + + /* IOleInPlaceObject methods */ + STDMETHOD(InPlaceDeactivate)( void) override; + STDMETHOD(UIDeactivate)( void) override; + STDMETHOD(SetObjectRects)( LPCRECT lprcPosRect, LPCRECT lprcClipRect) override; + STDMETHOD(ReactivateAndUndo)( void) override; + + /*IDispatch methods*/ + STDMETHOD(GetTypeInfoCount)( UINT *pctinfo) override; + STDMETHOD(GetTypeInfo)( UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) override; + STDMETHOD(GetIDsOfNames)( REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) override; + STDMETHOD(Invoke)( DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) override; + +}; + +} // namespace inprocserv + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/embedserv/source/inprocserv/inprocserv.def b/embedserv/source/inprocserv/inprocserv.def new file mode 100644 index 000000000..d731a151f --- /dev/null +++ b/embedserv/source/inprocserv/inprocserv.def @@ -0,0 +1,5 @@ +EXPORTS
+ DllCanUnloadNow PRIVATE
+ DllGetClassObject PRIVATE
+ DllRegisterServer PRIVATE
+ DllUnregisterServer PRIVATE
diff --git a/embedserv/source/inprocserv/smartpointer.hxx b/embedserv/source/inprocserv/smartpointer.hxx new file mode 100644 index 000000000..5e1606cad --- /dev/null +++ b/embedserv/source/inprocserv/smartpointer.hxx @@ -0,0 +1,184 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_SMARTPOINTER_HXX +#define INCLUDED_EMBEDSERV_SOURCE_INPROCSERV_SMARTPOINTER_HXX + +namespace inprocserv{ + +void WriteDebugInfo( DWORD pThis, char* pString, DWORD nToWrite ); + +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 != nullptr ) + m_pInterface->AddRef(); + } + + explicit ComSmart( T* pInterface ) + : m_pInterface( pInterface ) + { + if ( m_pInterface != nullptr ) + 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 != nullptr ) + m_pInterface->AddRef(); + + return *this; + } + + ComSmart<T>& operator=( T* pInterface ) + { + OwnRelease(); + + m_pInterface = pInterface; + + if ( m_pInterface != nullptr ) + m_pInterface->AddRef(); + + return *this; + } + + explicit operator bool() const + { + return m_pInterface != nullptr; + } + + T* get() 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 CSGuard +{ + CRITICAL_SECTION* m_pCriticalSection; + +public: + explicit CSGuard( CRITICAL_SECTION* pCS ) + : m_pCriticalSection( pCS ) + { + if ( m_pCriticalSection ) + EnterCriticalSection( m_pCriticalSection ); + } + + ~CSGuard() + { + if ( m_pCriticalSection ) + LeaveCriticalSection( m_pCriticalSection ); + } +}; + +class ULONGGuard +{ + ULONG* m_pValue; + +public: + explicit ULONGGuard( ULONG* pValue ) + : m_pValue( pValue ) + { + if ( m_pValue ) + (*m_pValue)++; + } + + ~ULONGGuard() + { + if ( m_pValue ) + (*m_pValue)--; + } +}; + +} // namespace inprocserv + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |