CTLHOST.CPP

////////////////////////////////////////////////////////////////////////// 
// 
//  controlhost.cpp 
// 
//  This file contains the implementation of the CControlHost class. 
//  This class is used to host ActiveX Controls. 
// 
//  (C) Copyright 1997 by Microsoft Corporation. All rights reserved. 
// 
////////////////////////////////////////////////////////////////////////// 
 
#define INITGUID 
#include <exdispid.h> 
#include <olectl.h> 
#include "dactl.h" 
#include "ctlhost.h" 
#include <comdef.h> 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::CControlHost                      [CONSTRUCTOR] 
// 
CControlHost::CControlHost(IUnknown *pUnk) 
    :_hwnd(NULL), _punkOuter(NULL), 
    _cRef(0), _punk(NULL), _pvc(NULL), 
    _dwTBSink(0) 
{ 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::~CControlHost                     [DESTRUCTOR] 
// 
CControlHost::~CControlHost() 
{ 
    DeleteControl();    // insurance 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
// 
// 
// 
HRESULT CControlHost::SetHwnd(HWND hwnd) 
{ 
    _hwnd = hwnd; 
    if (!GetClientRect(_hwnd, &_rcPos)) 
        SetRectEmpty(&_rcPos); 
 
    return S_OK; 
} 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::QueryInterface                    [IUnknown] 
// 
HRESULT CControlHost::QueryInterface(REFIID riid, LPVOID * ppvObj) 
{ 
    if (ppvObj == NULL) 
        return E_INVALIDARG; 
 
    *ppvObj = NULL; 
 
    if (IsEqualIID(riid, IID_IOleInPlaceSite)) 
        *ppvObj = (IOleInPlaceSite *)this; 
    else if (IsEqualIID(riid, IID_IOleControlSite)) 
        *ppvObj = (IOleControlSite *)this; 
    else if (IsEqualIID(riid, IID_IOleInPlaceSiteWindowless)) 
        *ppvObj = (IOleInPlaceSiteWindowless *)this; 
    else if (IsEqualIID(riid, IID_IDispatch)) 
        *ppvObj = (IDispatch *)this; 
    else 
        return (E_NOINTERFACE); 
 
    if(*ppvObj) 
        AddRef(); 
 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::AddRef                            [IUnknown] 
// 
ULONG CControlHost::AddRef() 
{ 
    return (_cRef++); 
} 
 
ULONG CControlHost::Release() 
{ 
    _cRef--; 
 
    if (_cRef > 0) 
        return (_cRef); 
 
    _cRef = 0; 
    delete this; 
 
    return (0); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SaveObject                        [IOleClientSite] 
// 
HRESULT CControlHost::SaveObject() 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetMoniker                        [IOleClientSite] 
// 
HRESULT CControlHost::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER * ppMk) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetContainer                      [IOleClientSite] 
// 
HRESULT CControlHost::GetContainer(LPOLECONTAINER * ppContainer ) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::ShowObject                        [IOleClientSite] 
// 
HRESULT CControlHost::ShowObject() 
{ 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnShowWindow                      [IOleClientSite] 
// 
HRESULT CControlHost::OnShowWindow(BOOL fShow) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::RequestNewObjectLayout            [IOleClientSite] 
// 
HRESULT CControlHost::RequestNewObjectLayout() 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetWindow                         [IOleWindow] 
// 
HRESULT CControlHost::GetWindow(HWND * lphwnd) 
{ 
    if (_hwnd == NULL) 
        return (S_FALSE); 
 
    *lphwnd = _hwnd; 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::ContextSensitiveHelp              [IOleWindow] 
// 
HRESULT CControlHost::ContextSensitiveHelp(BOOL fEnterMode) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::CanInPlaceActivate                [IOleInPlaceSite] 
// 
HRESULT CControlHost::CanInPlaceActivate(void) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnInPlaceActivate                 [IOleInPlaceSite] 
// 
HRESULT CControlHost::OnInPlaceActivate(void) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnUIActivate                      [IOleInPlaceSite] 
// 
HRESULT CControlHost::OnUIActivate(void) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetWindowContext                  [IOleInPlaceSite] 
// 
HRESULT CControlHost::GetWindowContext (IOleInPlaceFrame ** ppFrame, IOleInPlaceUIWindow ** ppIIPUIWin, 
                                  LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo) 
{ 
    *ppFrame = this; 
    AddRef(); 
 
    *ppIIPUIWin = NULL; 
 
    CopyRect(lprcPosRect, &_rcPos); 
    CopyRect(lprcClipRect, &_rcPos); 
 
    lpFrameInfo->cb             = sizeof(OLEINPLACEFRAMEINFO); 
    lpFrameInfo->fMDIApp        = FALSE; 
    lpFrameInfo->hwndFrame      = _hwnd; 
    lpFrameInfo->haccel         = 0; 
    lpFrameInfo->cAccelEntries  = 0; 
 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::Scroll                            [IOleInPlaceSite] 
// 
HRESULT CControlHost::Scroll(SIZE scrollExtent) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnUIDeactivate                    [IOleInPlaceSite] 
// 
HRESULT CControlHost::OnUIDeactivate(BOOL fUndoable) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnInPlaceDeactivate               [IOleInPlaceSite] 
// 
HRESULT CControlHost::OnInPlaceDeactivate(void) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::DiscardUndoState                  [IOleInPlaceSite] 
// 
HRESULT CControlHost::DiscardUndoState(void) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::DeactivateAndUndo                 [IOleInPlaceSite] 
// 
HRESULT CControlHost::DeactivateAndUndo(void) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnPosRectChange                   [IOleInPlaceSite] 
// 
HRESULT CControlHost::OnPosRectChange(LPCRECT lprcPosRect) 
{ 
    RECT rcPos, rcClient; 
    HWND hwnd; 
    GetWindow(&hwnd); 
    GetClientRect(hwnd, &rcClient); 
    GetWindowRect(hwnd, &rcPos); 
 
    if(rcClient.bottom < lprcPosRect->bottom) 
        rcPos.bottom += lprcPosRect->bottom - rcClient.bottom; 
    else 
        rcPos.bottom -= rcClient.bottom - lprcPosRect->bottom; 
 
    if(rcClient.right < lprcPosRect->right) 
        rcPos.right += lprcPosRect->right - rcClient.right;  
    else 
        rcPos.right -= rcClient.right - lprcPosRect->right;  
 
    MoveWindow( hwnd,  
                rcPos.left,  
                rcPos.top,  
                rcPos.right - rcPos.left,  
                rcPos.bottom - rcPos.top, 
                TRUE); 
 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnInPlaceActivateEx               [IOleInPlaceSiteEx] 
// 
HRESULT CControlHost::OnInPlaceActivateEx(BOOL *pfNoRedraw, DWORD dwFlags) 
{ 
    OleLockRunning(_punk, TRUE, FALSE); 
    HRESULT hr = E_FAIL; 
 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnInPlaceDeactivateEx             [IOleInPlaceSiteEx] 
// 
HRESULT CControlHost::OnInPlaceDeactivateEx(BOOL fNoRedraw) 
{ 
    OleLockRunning(_punk, FALSE, FALSE); 
    return S_OK; 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::RequestUIActivate                 [IOleInPlaceSiteEx] 
// 
HRESULT CControlHost::RequestUIActivate(void) 
{ 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::CanWindowlessActivate             [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::CanWindowlessActivate(void) 
{ 
    return (TRUE); // m_bCanWindowlessActivate); 
} 
////////////////////////////////////////////////////////////////////////// 
//                                                  [IOleInPlaceSiteWindowless] 
//  CControlHost::GetCapture 
// 
HRESULT CControlHost::GetCapture(void) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetCapture                        [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::SetCapture(BOOL fCapture) 
{ 
 
    if (fCapture) 
    { 
        ::SetCapture(_hwnd); 
        _bCapture = TRUE; 
    } 
    else 
    { 
        ::ReleaseCapture(); 
        _bCapture = FALSE; 
    } 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetFocus                          [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::GetFocus(void) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetFocus                          [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::SetFocus(BOOL fFocus) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetDC                             [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::GetDC(LPCRECT pRect, DWORD grfFlags, HDC *phDC) 
{ 
    if (!phDC) 
        return E_POINTER; 
 
    *phDC = ::GetDC(_hwnd); 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::ReleaseDC                         [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::ReleaseDC(HDC hDC) 
{ 
    ::ReleaseDC(_hwnd, hDC); 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::InvalidateRect                    [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::InvalidateRect(LPCRECT pRect, BOOL fErase) 
{ 
    ::InvalidateRect(_hwnd, pRect, fErase); 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::InvalidateRgn                     [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::InvalidateRgn(HRGN hRGN, BOOL fErase) 
{ 
    ::InvalidateRgn(_hwnd, hRGN, fErase); 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::ScrollRect                        [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::ScrollRect(INT dx, INT dy, LPCRECT pRectScroll, LPCRECT pRectClip) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::AdjustRect                        [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::AdjustRect(LPRECT prc) 
{ 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnDefWindowMessage                [IOleInPlaceSiteWindowless] 
// 
HRESULT CControlHost::OnDefWindowMessage(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult) 
{ 
    *plResult = ::DefWindowProc(_hwnd, msg, wParam, lParam); 
    return S_OK; 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetBorder                         [IOleInPlaceUIWindow] 
// 
HRESULT CControlHost::GetBorder(LPRECT lprectBorder) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::RequestBorderSpace                [IOleInPlaceUIWindow] 
// 
HRESULT CControlHost::RequestBorderSpace(LPCBORDERWIDTHS lpborderwidths) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetBorderSpace                    [IOleInPlaceUIWindow] 
// 
HRESULT CControlHost::SetBorderSpace(LPCBORDERWIDTHS lpborderwidths) 
{ 
    if(_punkOuter) 
        return ((CControlHost*)_punkOuter)->SetBorderSpace(lpborderwidths); 
 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetActiveObject                   [IOleInPlaceUIWindow] 
// 
HRESULT CControlHost::SetActiveObject(IOleInPlaceActiveObject * pActiveObject, LPCOLESTR lpszObjName) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::InsertMenus                       [IOleInPlaceFrame] 
// 
HRESULT CControlHost::InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetMenu                           [IOleInPlaceFrame] 
// 
HRESULT CControlHost::SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::RemoveMenus                       [IOleInPlaceFrame] 
// 
HRESULT CControlHost::RemoveMenus(HMENU hmenuShared) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::SetStatusText                     [IOleInPlaceFrame] 
// 
HRESULT CControlHost::SetStatusText(LPCOLESTR pszStatusText) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::EnableModeless                    [IOleInPlaceFrame] 
// 
HRESULT CControlHost::EnableModeless(BOOL fEnable) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::TranslateAccelerator              [IOleInPlaceFrame] 
// 
HRESULT CControlHost::TranslateAccelerator(LPMSG lpmsg, WORD wID) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnControlInfoChanged              [IOleControlSite] 
// 
HRESULT CControlHost::OnControlInfoChanged() 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::LockInPlaceActive                 [IOleControlSite] 
// 
HRESULT CControlHost::LockInPlaceActive(BOOL fLock) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetExtendedControl                [IOleControlSite] 
// 
HRESULT CControlHost::GetExtendedControl(IDispatch **ppDisp) 
{ 
    if (ppDisp == NULL) 
        return (E_INVALIDARG); 
 
    *ppDisp = (IDispatch *)this; 
    AddRef(); 
 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::TransformCoords                   [IOleControlSite] 
// 
HRESULT CControlHost::TransformCoords(POINTL *pptlHimetric, POINTF *pptfContainer, DWORD dwFlags) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::TranslateAccelerator              [IOleControlSite] 
// 
HRESULT CControlHost::TranslateAccelerator(LPMSG pMsg, DWORD grfModifiers) 
{ 
    return (S_FALSE); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::OnFocus                           [IOleControlSite] 
// 
HRESULT CControlHost::OnFocus(BOOL fGotFocus) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::ShowPropertyFrame                 [IOleControlSite] 
// 
HRESULT CControlHost::ShowPropertyFrame(void) 
{ 
    return (E_NOTIMPL); 
} 
 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetIDsOfNames                     [IDispatch] 
// 
HRESULT CControlHost::GetIDsOfNames(REFIID riid, OLECHAR FAR* FAR* rgszNames, unsigned int cNames, LCID lcid, DISPID FAR* rgdispid) 
{ 
    HRESULT     hr;                     // standard ole return code 
    LPOLESTR    pName; 
    DISPID      *pdispid; 
 
    hr      = S_OK; 
    pName   = *rgszNames; 
    pdispid = rgdispid; 
 
    for (UINT i=0; i<cNames; i++) 
    { 
        if (pName != NULL) 
        { 
            if (_wcsicmp(pName, L"basehref") == 0) 
                *pdispid = DISPID_BASEHREF; 
            else if (_wcsicmp(pName, L"align") == 0) 
                *pdispid = DISPID_ALIGN; 
            else 
            { 
                *pdispid = DISPID_UNKNOWN; 
                hr       = DISP_E_UNKNOWNNAME; 
            } 
        } 
 
        pdispid++; 
        pName++; 
    } 
 
    return (hr); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetTypeInfo                       [IDispatch] 
// 
HRESULT CControlHost::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::GetTypeInfoCount                  [IDispatch] 
// 
HRESULT CControlHost::GetTypeInfoCount(unsigned int FAR * pctinfo) 
{ 
    return (E_NOTIMPL); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::Invoke                            [IDispatch] 
// 
HRESULT CControlHost::Invoke(DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS FAR *pdispparams, VARIANT FAR *pvarResult, EXCEPINFO FAR * pexecinfo, unsigned int FAR *puArgErr) 
{ 
    HRESULT     hr = S_OK;  // standard ole return code 
 
    // The following code are the DISPIDs for the ambient properties 
    // that we will support. 
    if ((pvarResult == NULL) && (wFlags == DISPATCH_PROPERTYGET)) 
        return (E_INVALIDARG); 
     
    switch (dispid) 
    { 
        case DISPID_NAVIGATECOMPLETE: 
            hr = S_OK; 
 
        case DISPID_AMBIENT_DISPLAYNAME: 
            if (!pvarResult->bstrVal) 
                pvarResult->bstrVal = ::SysAllocString(L""); 
 
            hr = S_OK; 
 
            // If we STILL don't have a bstrVal.  Clean up and return an empty variant. 
            if (!pvarResult->bstrVal)  
            { 
                VariantInit(pvarResult); 
                hr = E_FAIL; 
            } 
 
            break; 
 
        case DISPID_AMBIENT_USERMODE: 
        case DISPID_AMBIENT_MESSAGEREFLECT: 
            pvarResult->vt      = VT_BOOL; 
            pvarResult->boolVal = TRUE; 
            hr                  = S_OK; 
            break; 
 
        case DISPID_AMBIENT_SHOWHATCHING: 
        case DISPID_AMBIENT_SHOWGRABHANDLES: 
        case DISPID_AMBIENT_SUPPORTSMNEMONICS: 
            pvarResult->vt      = VT_BOOL; 
            pvarResult->boolVal = FALSE; 
            hr                  = S_OK; 
            break; 
 
        // Not yet implemented! 
        case DISPID_AMBIENT_BACKCOLOR: 
        case DISPID_AMBIENT_FORECOLOR: 
        case DISPID_AMBIENT_UIDEAD: 
        case DISPID_AMBIENT_AUTOCLIP: 
            hr = S_OK; 
            break; 
 
        // Extender Properties 
        case DISPID_BASEHREF: 
        case DISPID_ALIGN: 
            hr = DISP_E_MEMBERNOTFOUND; 
            break; 
 
        default: 
            hr = DISP_E_MEMBERNOTFOUND; 
    } 
 
    return (hr); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::CreateControl                     [HELPER] 
// 
HRESULT CControlHost::CreateControl() 
{ 
    HRESULT             hr;             // standard ole return code 
    IOleObject          *pIOleObject;   // IOleObject interface pointer 
    IPersistStreamInit  *pps;           // IPersistStreamInit interface pointer 
     
    // Create a DAViewerControl. 
    _pvc = new CDAViewerCtl(); 
 
    // Check if the creation succeeded. 
    if (!_pvc) 
        return E_OUTOFMEMORY; 
 
    hr = _pvc->GetIUnknown(&_punk); 
    if (FAILED(hr)) { 
        return (hr); 
    } 
 
    AddRef();  // addref the container 
 
    hr = _punk->QueryInterface(IID_IOleObject, (LPVOID *)&pIOleObject); 
 
    if (SUCCEEDED(hr)) 
    { 
        pIOleObject->SetClientSite(this); 
 
        // Controls like to know they have been initialized by getting 
        // called on their InitNew method. 
        hr = _punk->QueryInterface(IID_IPersistStreamInit, (LPVOID *)&pps); 
        if (SUCCEEDED(hr)) 
        { 
            pps->InitNew(); 
            pps->Release(); 
        } 
 
        // The control creation succeeded, lets create the model. 
        _pvc->CreateModel(); 
 
        // Tell the control to activate and show itself. 
        pIOleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, this, 0, _hwnd, &_rcPos); 
        pIOleObject->DoVerb(OLEIVERB_SHOW, NULL, this, 0, _hwnd, &_rcPos); 
        pIOleObject->Release(); 
 
        // cache some frequently needed interface pointers     
        // cache the control's window handle 
        _hwndControl = NULL; 
        IOleInPlaceActiveObject *pipao = NULL; 
        hr = _punk->QueryInterface(IID_IOleInPlaceActiveObject, (void**) &pipao); 
        if (SUCCEEDED(hr)) 
        { 
            pipao->GetWindow(&_hwndControl); 
            pipao->Release(); 
        } 
    } 
    return (hr); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::DeleteControl                     [HELPER] 
// 
HRESULT CControlHost::DeleteControl() 
{ 
    HRESULT     hr;                     // standard ole return code 
    IOleObject  *pIOleObject;           // IOleObject interface pointer 
             
    if (_pvc != NULL)  
    { 
        delete _pvc; 
        _pvc = NULL; 
    } 
 
    // Close the Control and release the cached pointers. 
    if (_punk != NULL) 
    { 
        hr = _punk->QueryInterface(IID_IOleObject, (LPVOID *)&pIOleObject); 
        if (SUCCEEDED(hr)) 
        { 
            pIOleObject->DoVerb(OLEIVERB_HIDE, NULL, this, 0, _hwnd, NULL); 
            pIOleObject->Close(OLECLOSE_NOSAVE); 
            pIOleObject->SetClientSite(NULL); 
            pIOleObject->Release(); 
           
            _punk->Release(); 
            _punk = NULL; 
        } 
 
        Release();  // Release our hold on the container 
    } 
 
    return (S_OK); 
} 
 
////////////////////////////////////////////////////////////////////////// 
// 
//  CControlHost::QueryObject                       [HELPER] 
// 
HRESULT CControlHost::QueryObject(REFIID riid, void **ppvObject) 
{ 
    HRESULT hr = E_POINTER; 
    if (ppvObject) 
    { 
        if (_punk) 
        { 
            hr = _punk->QueryInterface(riid, ppvObject); 
        } 
        else 
        { 
            *ppvObject = NULL; 
            hr = OLE_E_NOCONNECTION; 
        } 
    } 
    return hr; 
}