cOleClientSite.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cOleClientSite_H
#define _INC_cOleClientSite_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOleControl.h"
 
#if defined(_WIN32) && defined(_MSC_VER)
 
// #undef TranslateAccelerator
 
namespace GrayLib
{
        class GRAYLIB_LINK cOleClientSite : public cRefBase
                , public IOleClientSite
                , public IOleInPlaceSite
                , public IDocHostUIHandler
                , public IOleInPlaceFrame
        {
 
        public:
                cOleControl* m_pOleControl;             // my parent control.  cOleWebBrowser
                bool m_bShowWindow;
                BORDERWIDTHS m_BorderWidths;
 
        public:
                cOleClientSite(cOleControl* pOleControl)
                        : m_pOleControl(pOleControl)
                        , m_bShowWindow(true)
                {
                        cMem::Zero(&m_BorderWidths, sizeof(m_BorderWidths));
                        AddRef();       // extra ref for some reason. We die on IOleObject Close(OLECLOSE_NOSAVE)->destruct if we don't have this! TODO FIXME ???
                }
                virtual ~cOleClientSite()
                {
                }
 
                IUNKNOWN_DISAMBIG_R(cRefBase);
 
                void DisposeThis()
                {
                        // my parent went away. but i must live on because i have references.
                        m_pOleControl = nullptr;
                }
 
                HRESULT OnNotImpl()
                {
                        // This shouldn't get called in the stub version.
 
                        // So, for these "dummy functions" that we don't expect the browser to call, we'll just stick in some
                        // assembly code that causes a debugger breakpoint and tells the browser object that we don't support
                        // the functionality. That way, if you try to do more things with the browser object, and it starts
                        // calling these "dummy functions", you'll know which ones you should add more meaningful code to.
                        ASSERT(0);
                        if (m_pOleControl == nullptr)
                                return E_NOTIMPL;
                        return m_pOleControl->ReturnError(E_NOTIMPL);
                }
 
                STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject) override
                {
                        // We give the browser object a pointer to our IOleClientSite object when we call OleCreate() or DoVerb().
 
                        // The browser object calls this when it wants a pointer to one of our
                        //  IOleClientSite, IDocHostUIHandler, or IOleInPlaceSite structures.They
                        //  are all accessible via the cOleClientSite struct we allocated in
                        //  EmbedBrowserObject() and passed to DoVerb() and OleCreate().
 
                        // It just so happens that the first arg passed to us is our cOleClientSite struct we allocated
                        // and passed to DoVerb() and OleCreate(). Nevermind that 'this' is declared is an IOleClientSite *.
                        // Remember that in EmbedBrowserObject(), we allocated our own cOleClientSite struct, and lied
                        // to OleCreate() and DoVerb() -- passing our cOleClientSite struct and saying it was an
                        // IOleClientSite struct. It's ok. An cOleClientSite starts with an embedded IOleClientSite, so
                        // the browser didn't mind. So that's what the browser object is passing us now. The browser doesn't
                        // know that it's really an cOleClientSite struct. But we do. So we can recast it and use it as
                        // so here.
 
                        cOleClientSite* pThis = this;
 
                        if (riid == __uuidof(IUnknown)
                                || riid == __uuidof(IOleClientSite))
                        {
                                *ppvObject = static_cast<IOleClientSite*>(pThis);
                        }
 
                        else if (riid == __uuidof(IOleInPlaceSite))
                        {
                                *ppvObject = static_cast<IOleInPlaceSite*>(pThis);
                        }
 
                        else if (riid == __uuidof(IDocHostUIHandler))
                        {
                                *ppvObject = static_cast<IDocHostUIHandler*>(pThis);
                        }
 
                        else if (riid == __uuidof(IOleInPlaceFrame))
                        {
                                *ppvObject = static_cast<IOleInPlaceFrame*>(pThis);
                        }
 
                        else
                        {
                                // NOT __uuidof(IServiceProvider)
                                return cRefBase::QueryInterface(riid, ppvObject);
                        }
 
                        AddRef();
                        return S_OK;
                }
 
        public:
                STDMETHOD(SaveObject)() override
                {
                        return OnNotImpl();
                }
                STDMETHOD(GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker ** ppmk) override
                {
                        UNREFERENCED_PARAMETER(dwAssign);
                        UNREFERENCED_PARAMETER(dwWhichMoniker);
                        UNREFERENCED_PARAMETER(ppmk);
                        return E_NOTIMPL;       // this is ok.
                }
                STDMETHOD(GetContainer)(LPOLECONTAINER FAR* ppContainer) override
                {
                        *ppContainer = nullptr;
                        return E_NOINTERFACE;
                }
                STDMETHOD(ShowObject)() override
                {
                        return S_OK;
                }
                STDMETHOD(OnShowWindow)(BOOL fShow) override
                {
                        m_bShowWindow = fShow;
                        return S_OK;
                }
                STDMETHOD(RequestNewObjectLayout)() override
                {
                        return OnNotImpl();
                }
 
        public:
                STDMETHOD(GetWindow)(HWND FAR* lphwnd) override
                {
 
                        if (m_pOleControl == nullptr)
                                *lphwnd = HANDLE_NULL;
                        else
                                *lphwnd = m_pOleControl->get_WndFrame();
                        return S_OK;
                }
 
                STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode) override
                {
                        UNREFERENCED_PARAMETER(fEnterMode);
                        return OnNotImpl();
                }
                STDMETHOD(CanInPlaceActivate)() override
                {
                        return S_OK;
                }
                STDMETHOD(OnInPlaceActivate)() override
                {
                        return S_OK;
                }
                STDMETHOD(OnUIActivate)() override
                {
                        return S_OK;
                }
                STDMETHOD(GetWindowContext)(LPOLEINPLACEFRAME FAR* lplpFrame, LPOLEINPLACEUIWINDOW FAR* lplpDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) override
                {
                        UNREFERENCED_PARAMETER(lprcClipRect);
                        UNREFERENCED_PARAMETER(lprcPosRect);
 
                        if (this->m_pOleControl == nullptr)     // disposed.
                                return E_POINTER;
                        *lplpFrame = static_cast<IOleInPlaceFrame*>(this);
 
                        // We have no OLEINPLACEUIWINDOW
                        *lplpDoc = nullptr;
 
                        // Fill in some other info for the browser
                        lpFrameInfo->fMDIApp = false;
                        lpFrameInfo->hwndFrame = m_pOleControl->get_WndFrame();
                        lpFrameInfo->haccel = 0;
                        lpFrameInfo->cAccelEntries = 0;
 
                        // Give the browser the dimensions of where it can draw. We give it our entire window to fill.
                        // We do this in COleInPlaceSite::OnPosRectChange() which is called right when a window is first
                        // created anyway, so no need to duplicate it here.
                        //      GetClientRect(lpFrameInfo->hwndFrame, lprcPosRect);
                        //      GetClientRect(lpFrameInfo->hwndFrame, lprcClipRect);
 
                        return S_OK;
                }
 
                STDMETHOD(Scroll)(SIZE scrollExtent) override
                {
                        UNREFERENCED_PARAMETER(scrollExtent);
                        return OnNotImpl();
                }
 
                STDMETHOD(OnUIDeactivate)(BOOL fUndoable) override
                {
                        UNREFERENCED_PARAMETER(fUndoable);
                        return S_OK;
                }
                STDMETHOD(OnInPlaceDeactivate)() override
                {
                        return S_OK;
                }
                STDMETHOD(DiscardUndoState)() override
                {
                        return OnNotImpl();
                }
                STDMETHOD(DeactivateAndUndo)() override
                {
                        return OnNotImpl();
                }
 
                STDMETHOD(OnPosRectChange)(LPCRECT lprcPosRect) override
                {
                        // Called when the position of the browser object is changed, such as when we call the IWebBrowser2's
                        // put_Width(), put_Height(), put_Left(), or put_Right().
 
                        if (m_pOleControl == nullptr || lprcPosRect == nullptr)
                        {
                                return E_POINTER;
                        }
 
                        // Don't use put_Rect() because it would feedback?
                        HRESULT hRes = m_pOleControl->SetRect(*lprcPosRect, 0);
                        UNREFERENCED_PARAMETER(hRes);
                        return S_OK;    // S_OK
                }
 
        public:
                STDMETHOD(ShowContextMenu)(DWORD dwID, POINT __RPC_FAR *ppt, IUnknown __RPC_FAR *pcmdtReserved, IDispatch __RPC_FAR *pdispReserved) override
                {
                        //
                        // typedef struct COleDocHostUIHandler {
                        //              IDocHostUIHandler       ui;             // The IDocHostUIHandler must be first!
                        //              HWND                            window;
                        // } IDocHostUIHandlerEx;
                        //
                        // Of course, we'd need a unique IDocHostUIHandlerEx object for each window, so
                        // EmbedBrowserObject() would have to allocate one of those too. And that's
                        // what we'd pass to our browser object (and it would in turn pass it to us
                        // here, instead of 'This' being a IDocHostUIHandler *).
 
                        // We will return S_OK to tell the browser not to display its default context menu,
                        // or return S_FALSE to let the browser show its default context menu. For this
                        // example, we wish to disable the browser's default context menu.
 
                        UNREFERENCED_PARAMETER(pdispReserved);
                        UNREFERENCED_PARAMETER(pcmdtReserved);
                        UNREFERENCED_PARAMETER(ppt);
                        UNREFERENCED_PARAMETER(dwID);
 
                        return S_OK;
                }
 
                STDMETHOD(GetHostInfo)(DOCHOSTUIINFO __RPC_FAR *pInfo) override
                {
 
                        pInfo->cbSize = sizeof(DOCHOSTUIINFO);
 
                        // Set some flags. We don't want any 3D border. You can do other things like hide
                        // the scroll bar (DOCHOSTUIFLAG_SCROLL_NO), display picture display (DOCHOSTUIFLAG_NOPICS),
                        // disable any script running when the page is loaded (DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE),
                        // open a site in a new browser window when the user clicks on some link (DOCHOSTUIFLAG_OPENNEWWIN),
                        // and lots of other things. See the MSDN docs on the DOCHOSTUIINFO struct passed to us.
                        pInfo->dwFlags = DOCHOSTUIFLAG_NO3DBORDER;
 
                        // Set what happens when the user double-clicks on the object. Here we use the default.
                        pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;
 
                        return S_OK;
                }
 
                STDMETHOD(ShowUI)(DWORD dwID, IOleInPlaceActiveObject __RPC_FAR *pActiveObject, IOleCommandTarget __RPC_FAR *pCommandTarget, IOleInPlaceFrame __RPC_FAR *pFrame, IOleInPlaceUIWindow __RPC_FAR *pDoc) override
                {
                        UNREFERENCED_PARAMETER(pFrame);
                        UNREFERENCED_PARAMETER(pCommandTarget);
                        UNREFERENCED_PARAMETER(pActiveObject);
                        UNREFERENCED_PARAMETER(pDoc);
                        UNREFERENCED_PARAMETER(dwID);
                        return S_OK;
                }
 
                STDMETHOD(HideUI)() override
                {
                        return S_OK;
                }
 
                STDMETHOD(UpdateUI)() override
                {
                        return S_OK;
                }
 
                STDMETHOD(EnableModeless)(BOOL fEnable) override
                {
                        UNREFERENCED_PARAMETER(fEnable);
                        return S_OK;
                }
                STDMETHOD(OnDocWindowActivate)(BOOL fActivate) override
                {
                        UNREFERENCED_PARAMETER(fActivate);
                        return S_OK;
                }
 
                STDMETHOD(OnFrameWindowActivate)(BOOL fActivate) override
                {
                        UNREFERENCED_PARAMETER(fActivate);
                        return S_OK;
                }
                STDMETHOD(ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow __RPC_FAR *pUIWindow, BOOL fRameWindow) override
                {
                        UNREFERENCED_PARAMETER(prcBorder);
                        UNREFERENCED_PARAMETER(pUIWindow);
                        UNREFERENCED_PARAMETER(fRameWindow);
                        return S_OK;
                }
                STDMETHOD(TranslateAccelerator)(LPMSG lpMsg, const GUID __RPC_FAR *pguidCmdGroup, DWORD nCmdID) override
                {
                        // Called from the browser object's TranslateAccelerator routines to translate key strokes to commands.
                        // We don't intercept any keystrokes, so we do nothing here. But for example, if we wanted to
                        // override the TAB key, perhaps do something with it ourselves, and then tell the browser
                        // not to do anything with this keystroke, we'd do:
                        //
                        //      if (pMsg && pMsg->message == WM_KEYDOWN && pMsg->wParam == VK_TAB)
                        //      {
                        //              // Here we do something as a result of a TAB key press.
                        //
                        //              // Tell the browser not to do anything with it.
                        //              return S_FALSE;
                        //      }
                        //
                        //      // Otherwise, let the browser do something with this message.
                        //      return S_OK;
 
                        // For our example, we want to make sure that the user can invoke some key to popup the context
                        // menu, so we'll tell it to ignore all messages.
 
                        UNREFERENCED_PARAMETER(lpMsg);
                        UNREFERENCED_PARAMETER(pguidCmdGroup);
                        UNREFERENCED_PARAMETER(nCmdID);
 
                        return S_FALSE;
                }
                STDMETHOD(GetOptionKeyPath)(LPOLESTR __RPC_FAR *pchKey, DWORD dw) override
                {
                        // Called by the browser object to find where the host wishes the browser to get its options in the registry.
                        // We can use this to prevent the browser from using its default settings in the registry, by telling it to use
                        // some other registry key we've setup with the options we want.
                        // Let the browser use its default registry settings.
                        UNREFERENCED_PARAMETER(pchKey);
                        UNREFERENCED_PARAMETER(dw);
                        return S_FALSE;
                }
                STDMETHOD(GetDropTarget)(IDropTarget __RPC_FAR *pDropTarget, IDropTarget __RPC_FAR *__RPC_FAR *ppDropTarget) override
                {
                        // Called by the browser object when it is used as a drop target. We can supply our own IDropTarget object,
                        // IDropTarget functions, and IDropTarget VTable if we want to determine what happens when someone drags and
                        // drops some object on our embedded browser object.
                        // Return our IDropTarget object associated with this IDocHostUIHandler object. I don't
                        // know why we don't do this via COleDocHostUIHandler::QueryInterface(), but we don't.
 
                        // NOTE: If we want/need an IDropTarget interface, then we would have had to setup our own
                        // IDropTarget functions, IDropTarget VTable, and create an IDropTarget object. We'd want to put
                        // a pointer to the IDropTarget object in our own custom IDocHostUIHandlerEx object (like how
                        // we may add an HWND field for the use of COleDocHostUIHandler::ShowContextMenu). So when we created our
                        // IDocHostUIHandlerEx object, maybe we'd add a 'idrop' field to the end of it, and
                        // store a pointer to our IDropTarget object there. Then we could return this pointer as so:
                        //
                        // *pDropTarget = ((IDocHostUIHandlerEx FAR *)this)->idrop;
                        // return S_OK;
 
                        // But for our purposes, we don't need an IDropTarget object, so we'll tell whomever is calling
                        // us that we don't have one.
 
                        UNREFERENCED_PARAMETER(pDropTarget);
                        UNREFERENCED_PARAMETER(ppDropTarget);
 
                        return S_FALSE;
                }
                STDMETHOD(GetExternal)(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch) override
                {
                        // Called by the browser when it wants a pointer to our IDispatch object. This object allows us to expose
                        // our own automation interface (ie, our own COM objects) to other entities that are running within the
                        // context of the browser so they can call our functions if they want. An example could be a javascript
                        // running in the URL we display could call our IDispatch functions. We'd write them so that any args passed
                        // to them would use the generic datatypes like a BSTR for utmost flexibility.
                        // Return our IDispatch object associated with this IDocHostUIHandler object. I don't
                        // know why we don't do this via COleDocHostUIHandler::QueryInterface(), but we don't.
 
                        // NOTE: If we want/need an IDispatch interface, then we would have had to setup our own
                        // IDispatch functions, IDispatch VTable, and create an IDispatch object. We'd want to put
                        // a pointer to the IDispatch object in our custom COleDocHostUIHandler object (like how
                        // we may add an HWND field for the use of COleDocHostUIHandler::ShowContextMenu). So when we defined our
                        // COleDocHostUIHandler object, maybe we'd add a 'idispatch' field to the end of it, and
                        // store a pointer to our IDispatch object there. Then we could return this pointer as so:
                        //
                        // *ppDispatch = ((COleDocHostUIHandler FAR *)this)->idispatch;
                        // return S_OK;
 
                        // But for our purposes, we don't need an IDispatch object, so we'll tell whomever is calling
                        // us that we don't have one. Note: We must set ppDispatch to 0 if we don't return our own
                        // IDispatch object.
                        *ppDispatch = nullptr;
                        return S_FALSE;
                }
                STDMETHOD(TranslateUrl)(DWORD dwTranslate, OLECHAR __RPC_FAR *pchURLIn, OLECHAR __RPC_FAR *__RPC_FAR *ppchURLOut) override
                {
                        // Called by the browser object to give us an opportunity to modify the URL to be loaded.
                        // We don't need to modify the URL. Note: We need to set ppchURLOut to 0 if we don't
                        // return an OLECHAR (buffer) containing a modified version of pchURLIn.
                        UNREFERENCED_PARAMETER(dwTranslate);
                        UNREFERENCED_PARAMETER(pchURLIn);
                        *ppchURLOut = '\0';
                        return S_FALSE;
                }
                STDMETHOD(FilterDataObject)(IDataObject __RPC_FAR *pDO, IDataObject __RPC_FAR *__RPC_FAR *ppDORet) override
                {
                        // Called by the browser when it does cut/paste to the clipboard. This allows us to block certain clipboard
                        // formats or support additional clipboard formats.
                        // Return our IDataObject object associated with this IDocHostUIHandler object. I don't
                        // know why we don't do this via COleDocHostUIHandler::QueryInterface(), but we don't.
 
                        // NOTE: If we want/need an IDataObject interface, then we would have had to setup our own
                        // IDataObject functions, IDataObject VTable, and create an IDataObject object. We'd want to put
                        // a pointer to the IDataObject object in our custom COleDocHostUIHandler object (like how
                        // we may add an HWND field for the use of COleDocHostUIHandler::ShowContextMenu). So when we defined our
                        // COleDocHostUIHandler object, maybe we'd add a 'idata' field to the end of it, and
                        // store a pointer to our IDataObject object there. Then we could return this pointer as so:
                        //
                        // *ppDORet = ((COleDocHostUIHandler FAR *)this)->idata;
                        // return S_OK;
 
                        // But for our purposes, we don't need an IDataObject object, so we'll tell whomever is calling
                        // us that we don't have one. Note: We must set ppDORet to 0 if we don't return our own
                        // IDataObject object.
 
                        UNREFERENCED_PARAMETER(pDO);
 
                        *ppDORet = nullptr;
                        return S_FALSE;
                }
 
        public:
                STDMETHOD(GetBorder)(LPRECT lprectBorder) override
                {
                        UNREFERENCED_PARAMETER(lprectBorder);
                        return OnNotImpl();
                }
                STDMETHOD(RequestBorderSpace)(LPCBORDERWIDTHS pborderwidths) override
                {
                        // override IOleInPlaceFrame
                        UNREFERENCED_PARAMETER(pborderwidths);
                        return OnNotImpl();
                }
                STDMETHOD(SetBorderSpace)(LPCBORDERWIDTHS pborderwidths) override
                {
                        // override IOleInPlaceFrame
                        if (pborderwidths != nullptr)
                        {
                                ::memcpy(&m_BorderWidths, pborderwidths, sizeof(m_BorderWidths));
                        }
                        return S_OK;
                }
                STDMETHOD(SetActiveObject)(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName) override
                {
                        // override IOleInPlaceFrame
                        UNREFERENCED_PARAMETER(pActiveObject);
                        UNREFERENCED_PARAMETER(pszObjName);
                        return S_OK;
                }
                STDMETHOD(InsertMenus)(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths) override
                {
                        // override IOleInPlaceFrame
                        UNREFERENCED_PARAMETER(hmenuShared);
                        UNREFERENCED_PARAMETER(lpMenuWidths);
                        return OnNotImpl();
                }
                STDMETHOD(SetMenu)(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject) override
                {
                        // override IOleInPlaceFrame
                        UNREFERENCED_PARAMETER(hmenuShared);
                        UNREFERENCED_PARAMETER(holemenu);
                        UNREFERENCED_PARAMETER(hwndActiveObject);
                        return S_OK;
                }
                STDMETHOD(RemoveMenus)(HMENU hmenuShared) override
                {
                        // override IOleInPlaceFrame
                        UNREFERENCED_PARAMETER(hmenuShared);
                        return OnNotImpl();
                }
                STDMETHOD(SetStatusText)(LPCOLESTR pszStatusText) override
                {
                        UNREFERENCED_PARAMETER(pszStatusText);
                        return S_OK;
                }
                STDMETHOD(TranslateAccelerator)(LPMSG lpmsg, WORD wID) override
                {
                        UNREFERENCED_PARAMETER(lpmsg);
                        UNREFERENCED_PARAMETER(wID);
                        return OnNotImpl();
                }
        };
}
 
#endif
#endif