927 lines
27 KiB
C++
927 lines
27 KiB
C++
/*--------------------------------------------------------------------------*
|
|
*
|
|
* Microsoft Windows
|
|
* Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
*
|
|
* File: ocxview.cpp
|
|
*
|
|
* Contents: Implementation file for COCXHostView
|
|
*
|
|
* History: 12-Dec-97 JeffRo Created
|
|
*
|
|
* This class is required to host OCX controls to fix focus problems.
|
|
* The MDI child frame window keeps track of its currently active view.
|
|
* When we're hosting OCX controls without this view and the OCX get the
|
|
* focus, the MDI child frame thinks the previously active view, usually
|
|
* the scope tree, is still the active view. So if the user Alt-Tabs
|
|
* away from MMC and back, for instance, the scope tree will get the focus
|
|
* even though the OCX had the focus before.
|
|
*
|
|
* We need this view to represent the OCX, which isn't a view, to the MDI
|
|
* child frame.
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
#include "stdafx.h"
|
|
#include "amc.h"
|
|
#include "ocxview.h"
|
|
#include "amcview.h"
|
|
|
|
|
|
#ifdef DBG
|
|
CTraceTag tagOCXActivation (_T("OCX"), _T("Activation"));
|
|
CTraceTag tagOCXTranslateAccel (_T("OCX"), _T("TranslateAccelerator"));
|
|
#endif
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* class COCXCtrlWrapper
|
|
*
|
|
*
|
|
* PURPOSE: Maintains a pointer to a CMMCAxWindow as well as to the OCX in
|
|
* the window.
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
class COCXCtrlWrapper : public CComObjectRoot, public IUnknown
|
|
{
|
|
typedef COCXCtrlWrapper ThisClass;
|
|
public:
|
|
COCXCtrlWrapper() : m_pOCXWindow(NULL)
|
|
{
|
|
}
|
|
|
|
~COCXCtrlWrapper()
|
|
{
|
|
if(m_pOCXWindow && m_pOCXWindow->IsWindow())
|
|
m_pOCXWindow->DestroyWindow();
|
|
|
|
delete m_pOCXWindow;
|
|
}
|
|
|
|
BEGIN_COM_MAP(ThisClass)
|
|
COM_INTERFACE_ENTRY(IUnknown)
|
|
END_COM_MAP()
|
|
|
|
DECLARE_NOT_AGGREGATABLE(ThisClass);
|
|
|
|
SC ScInitialize(CMMCAxWindow *pWindowOCX, IUnknown *pUnkCtrl) // initialize with the window that hosts the control
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXCtrlWrapper::ScInitialize"));
|
|
sc = ScCheckPointers(pWindowOCX, pUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
m_pOCXWindow = pWindowOCX;
|
|
m_spUnkCtrl = pUnkCtrl;
|
|
return sc;
|
|
}
|
|
|
|
SC ScGetControl(IUnknown **ppUnkCtrl)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXCtrlWrapper::ScGetData"));
|
|
sc = ScCheckPointers(ppUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
*ppUnkCtrl = m_spUnkCtrl;
|
|
if(*ppUnkCtrl)
|
|
(*ppUnkCtrl)->AddRef();
|
|
return sc;
|
|
}
|
|
|
|
CMMCAxWindow * GetAxWindow() {return m_pOCXWindow;}
|
|
|
|
private:
|
|
CMMCAxWindow * m_pOCXWindow; // handle to the window.
|
|
CComPtr<IUnknown> m_spUnkCtrl; // the IUnknown of the control
|
|
};
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COCXHostView
|
|
|
|
IMPLEMENT_DYNCREATE(COCXHostView, CView)
|
|
|
|
COCXHostView::COCXHostView() : m_pAMCView(NULL)
|
|
{
|
|
}
|
|
|
|
COCXHostView::~COCXHostView()
|
|
{
|
|
m_pAMCView = NULL;
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::PreCreateWindow
|
|
*
|
|
* PURPOSE: Adds the WS_CLIPCHILDREN bit. This prevents the host window
|
|
* from overwriting the OCX.
|
|
*
|
|
* PARAMETERS:
|
|
* CREATESTRUCT& cs :
|
|
*
|
|
* RETURNS:
|
|
* BOOL
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
BOOL
|
|
COCXHostView::PreCreateWindow(CREATESTRUCT& cs)
|
|
{
|
|
cs.style |= WS_CLIPCHILDREN;
|
|
// give base class a chance to do own job
|
|
BOOL bOK = (CView::PreCreateWindow(cs));
|
|
|
|
// register view class
|
|
LPCTSTR pszViewClassName = g_szOCXViewWndClassName;
|
|
|
|
// try to register window class which does not cause the repaint
|
|
// on resizing (do it only once)
|
|
static bool bClassRegistered = false;
|
|
if ( !bClassRegistered )
|
|
{
|
|
WNDCLASS wc;
|
|
if (::GetClassInfo(AfxGetInstanceHandle(), cs.lpszClass, &wc))
|
|
{
|
|
// Clear the H and V REDRAW flags
|
|
wc.style &= ~(CS_HREDRAW | CS_VREDRAW);
|
|
wc.lpszClassName = pszViewClassName;
|
|
// Register this new class;
|
|
bClassRegistered = AfxRegisterClass(&wc);
|
|
}
|
|
}
|
|
|
|
// change window class to one which does not cause the repaint
|
|
// on resizing if we successfully registered such
|
|
if ( bClassRegistered )
|
|
cs.lpszClass = pszViewClassName;
|
|
|
|
return bOK;
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::GetAxWindow
|
|
*
|
|
* PURPOSE: Returns a pointer to the current AxWindow.
|
|
*
|
|
* RETURNS:
|
|
* CMMCAxWindow *
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
CMMCAxWindow *
|
|
COCXHostView::GetAxWindow()
|
|
{
|
|
COCXCtrlWrapper *pOCXCtrlWrapper = dynamic_cast<COCXCtrlWrapper *>(m_spUnkCtrlWrapper.GetInterfacePtr());
|
|
if(!pOCXCtrlWrapper)
|
|
return (NULL);
|
|
|
|
return pOCXCtrlWrapper->GetAxWindow();
|
|
}
|
|
|
|
CAMCView *
|
|
COCXHostView::GetAMCView()
|
|
{
|
|
return m_pAMCView;
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(COCXHostView, CView)
|
|
//{{AFX_MSG_MAP(COCXHostView)
|
|
ON_WM_SIZE()
|
|
ON_WM_SETFOCUS()
|
|
ON_WM_MOUSEACTIVATE()
|
|
ON_WM_SETTINGCHANGE()
|
|
ON_WM_CREATE()
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COCXHostView drawing
|
|
|
|
void COCXHostView::OnDraw(CDC* pDC)
|
|
{
|
|
// this view should always be totally obscured by the OCX it is hosting
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COCXHostView diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void COCXHostView::AssertValid() const
|
|
{
|
|
CView::AssertValid();
|
|
}
|
|
|
|
void COCXHostView::Dump(CDumpContext& dc) const
|
|
{
|
|
CView::Dump(dc);
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COCXHostView message handlers
|
|
void COCXHostView::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
ASSERT_VALID (this);
|
|
CView::OnSize(nType, cx, cy);
|
|
|
|
if (nType != SIZE_MINIMIZED)
|
|
{
|
|
if(GetAxWindow() != NULL)
|
|
GetAxWindow()->MoveWindow (0, 0, cx, cy, FALSE /*bRepaint*/);
|
|
}
|
|
|
|
}
|
|
|
|
void COCXHostView::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
|
|
{
|
|
SetAmbientFont (NULL);
|
|
|
|
CView::OnSettingChange(uFlags, lpszSection);
|
|
|
|
if(GetAxWindow() != NULL)
|
|
GetAxWindow()->SendMessage (WM_SETTINGCHANGE, uFlags, (LPARAM) lpszSection);
|
|
}
|
|
|
|
|
|
void COCXHostView::OnSetFocus(CWnd* pOldWnd)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::OnSetFocus"));
|
|
|
|
ASSERT_VALID (this);
|
|
|
|
// delegate the focus to the control we're hosting, if we have one
|
|
if(GetAxWindow() != NULL)
|
|
GetAxWindow()->SetFocus();
|
|
|
|
// check if someone cared to take the focus.
|
|
// default handling else.
|
|
if (this == GetFocus())
|
|
{
|
|
CView::OnSetFocus (pOldWnd);
|
|
}
|
|
}
|
|
|
|
int COCXHostView::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message)
|
|
{
|
|
/*---------------------------------------------------------*/
|
|
/* this code came from CView::OnMouseActivate; we do it */
|
|
/* here to bypass sending WM_MOUSEACTIVATE on the the */
|
|
/* parent window, avoiding focus churn in the parent frame */
|
|
/*---------------------------------------------------------*/
|
|
|
|
CFrameWnd* pParentFrame = GetParentFrame();
|
|
if (pParentFrame != NULL)
|
|
{
|
|
// eat it if this will cause activation
|
|
ASSERT(pParentFrame == pDesktopWnd || pDesktopWnd->IsChild(pParentFrame));
|
|
|
|
// either re-activate the current view, or set this view to be active
|
|
CView* pView = pParentFrame->GetActiveView();
|
|
HWND hWndFocus = ::GetFocus();
|
|
if (pView == this &&
|
|
m_hWnd != hWndFocus && !::IsChild(m_hWnd, hWndFocus))
|
|
{
|
|
// re-activate this view
|
|
OnActivateView(TRUE, this, this);
|
|
}
|
|
else
|
|
{
|
|
// activate this view
|
|
pParentFrame->SetActiveView(this);
|
|
}
|
|
}
|
|
return (MA_ACTIVATE);
|
|
}
|
|
|
|
|
|
|
|
BOOL COCXHostView::OnCmdMsg( UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo )
|
|
{
|
|
// Do normal command routing
|
|
if (CView::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))
|
|
return TRUE;
|
|
|
|
// if view didn't handle it, give parent view a chance
|
|
CWnd* pParentView = GetParent ();
|
|
|
|
if ((pParentView != NULL) &&
|
|
pParentView->IsKindOf (RUNTIME_CLASS (CAMCView)) &&
|
|
pParentView->OnCmdMsg (nID, nCode, pExtra, pHandlerInfo))
|
|
return (TRUE);
|
|
|
|
// not handled
|
|
return FALSE;
|
|
}
|
|
|
|
void COCXHostView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::OnActivateView"));
|
|
|
|
CView::OnActivateView(bActivate,pActivateView,pDeactiveView);
|
|
|
|
// If pActivateView and pDeactiveView are same then this app has lost
|
|
// or gained focus without changing the active view within the app.
|
|
// So do nothing.
|
|
if (pActivateView == pDeactiveView)
|
|
return;
|
|
|
|
if (bActivate)
|
|
{
|
|
sc = ScFireEvent(COCXHostActivationObserver::ScOnOCXHostActivated);
|
|
if (sc)
|
|
sc.TraceAndClear();
|
|
}
|
|
else
|
|
/*
|
|
* If this view's no longer active, then the in-place object should
|
|
* no longer be UI active. This is important for the WebBrowser control
|
|
* because if you move from one "Link to Web Address" node to another, or
|
|
* from one taskpad to another, it won't allow tabbing to links on the
|
|
* new hosted page if it's not deactivated and reactivated in the
|
|
* appropriate sequence.
|
|
*/
|
|
{
|
|
IOleInPlaceObjectPtr spOleIPObj = GetIUnknown();
|
|
|
|
/*
|
|
* app hack for SQL snapin. Do not UIDeactivate the DaVinci control.
|
|
* See bugs 175586, 175756, 193673 & 258109.
|
|
*/
|
|
CAMCView *pAMCView = GetAMCView();
|
|
sc = ScCheckPointers(pAMCView, E_UNEXPECTED);
|
|
if (sc)
|
|
return;
|
|
|
|
SViewData *pViewData = pAMCView->GetViewData();
|
|
sc = ScCheckPointers(pViewData, E_UNEXPECTED);
|
|
if (sc)
|
|
return;
|
|
|
|
// If DaVinci control do not UIDeactivate.
|
|
LPCOLESTR lpszOCXClsid = pViewData->GetOCX();
|
|
if ( (_wcsicmp(lpszOCXClsid, L"{464EE255-FDC7-11D2-9743-00105A994F8D}") == 0) ||
|
|
(_wcsicmp(lpszOCXClsid, L"{97240642-F896-11D0-B255-006097C68E81}") == 0) )
|
|
return;
|
|
/*
|
|
* app hack for SQL snapin ends here.
|
|
*/
|
|
|
|
if (spOleIPObj != NULL)
|
|
{
|
|
Trace (tagOCXActivation, _T("Deactivating in-place object"));
|
|
spOleIPObj->UIDeactivate();
|
|
}
|
|
else
|
|
Trace (tagOCXActivation, _T("No in-place object to deactivate"));
|
|
}
|
|
}
|
|
|
|
int COCXHostView::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
if (CView::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
// initialize the AxWin class just once.
|
|
static bool bIsAxWinInitialized = false;
|
|
if(!bIsAxWinInitialized)
|
|
{
|
|
AtlAxWinInit();
|
|
bIsAxWinInitialized = true;
|
|
}
|
|
|
|
// get a pointer to the AMCView.
|
|
m_pAMCView = dynamic_cast<CAMCView*>(GetParent());
|
|
|
|
return 0;
|
|
}
|
|
|
|
LPUNKNOWN COCXHostView::GetIUnknown(void)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::GetIUnknown"));
|
|
|
|
COCXCtrlWrapper *pOCXCtrlWrapper = dynamic_cast<COCXCtrlWrapper *>((IUnknown *)m_spUnkCtrlWrapper);
|
|
if(!pOCXCtrlWrapper)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return NULL;
|
|
}
|
|
|
|
IUnknownPtr spUnkCtrl;
|
|
sc = pOCXCtrlWrapper->ScGetControl(&spUnkCtrl);
|
|
if(sc)
|
|
return NULL;
|
|
|
|
return (LPUNKNOWN)spUnkCtrl;
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::ScSetControl
|
|
*
|
|
* PURPOSE: Hosts the specified control in the OCX view. Delegates to one of
|
|
* the two other overloaded versions of this function.
|
|
*
|
|
* PARAMETERS:
|
|
* HNODE hNode : The node that owns the view.
|
|
* CResultViewType& rvt: The result view information
|
|
* INodeCallback * pNodeCallback :
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC
|
|
COCXHostView::ScSetControl(HNODE hNode, CResultViewType& rvt, INodeCallback *pNodeCallback)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::ScSetControl"));
|
|
USES_CONVERSION;
|
|
|
|
// make sure that we're trying to set up the right type of view.
|
|
if(rvt.GetType() != MMC_VIEW_TYPE_OCX)
|
|
return E_UNEXPECTED;
|
|
|
|
// either BOTH rvt.IsPersistableViewDescriptionValid() and rvt.GetOCXUnknown() should be valid (the GetResultViewType2 case)
|
|
// or BOTH should be invalid and just GetOCX() should be valid.
|
|
|
|
if(rvt.IsPersistableViewDescriptionValid() && (rvt.GetOCXUnknown() != NULL) )
|
|
{
|
|
// the GetResultViewType2 case
|
|
sc = ScSetControl1(hNode, rvt.GetOCXUnknown(), rvt.GetOCXOptions(), pNodeCallback);
|
|
if(sc)
|
|
return sc;
|
|
}
|
|
else if(rvt.GetOCX() != NULL)
|
|
{
|
|
sc = ScSetControl2(hNode, rvt.GetOCX(), rvt.GetOCXOptions(), pNodeCallback);
|
|
if(sc)
|
|
return sc;
|
|
}
|
|
else
|
|
{
|
|
// should never happen.
|
|
return (sc = E_UNEXPECTED);
|
|
}
|
|
|
|
|
|
// must have a legal Ax Window at this point.
|
|
sc = ScCheckPointers(GetAxWindow());
|
|
if(sc)
|
|
return sc;
|
|
|
|
|
|
// the OCX should fill the entirety of the OCX host view
|
|
CRect rectHost;
|
|
GetClientRect (rectHost);
|
|
GetAxWindow()->SetWindowPos(HWND_TOP, rectHost.left, rectHost.top, rectHost.Width(), rectHost.Height(), SWP_NOACTIVATE | SWP_SHOWWINDOW);
|
|
|
|
return sc;
|
|
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::ScSetControl1
|
|
*
|
|
* PURPOSE: Hosts the control specified by pUnkCtrl in the OCX view. Takes
|
|
* care of caching the control
|
|
*
|
|
* PARAMETERS:
|
|
* HNODE hNode :
|
|
* LPUNKNOWN pUnkCtrl :
|
|
* DWORD dwOCXOptions :
|
|
* INodeCallback * pNodeCallback :
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC
|
|
COCXHostView::ScSetControl1(HNODE hNode, LPUNKNOWN pUnkCtrl, DWORD dwOCXOptions, INodeCallback *pNodeCallback)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::ScSetControl1"));
|
|
|
|
// validate parameters.
|
|
sc = ScCheckPointers((void *)hNode, pUnkCtrl, pNodeCallback);
|
|
if(sc)
|
|
return sc;
|
|
|
|
CComPtr<IUnknown> spUnkCtrl;
|
|
|
|
// 1. Hide existing window, if any.
|
|
sc = ScHideWindow();
|
|
if(sc)
|
|
return sc;
|
|
|
|
// 2. Get a cached window if one exists - NOTE that in this overload we do not look at RVTI_OCX_OPTIONS_CACHE_OCX at this point.
|
|
sc = pNodeCallback->GetControl(hNode, pUnkCtrl, &m_spUnkCtrlWrapper); // the overloaded form of GetControl
|
|
if (sc)
|
|
return sc;
|
|
|
|
// 3. if no cached window, create one.
|
|
if(m_spUnkCtrlWrapper == NULL) /*no cached window, create one*/
|
|
{
|
|
CMMCAxWindow * pWndAx = NULL;
|
|
|
|
sc = ScCreateAxWindow(pWndAx);
|
|
if(sc)
|
|
return sc;
|
|
|
|
CComPtr<IUnknown> spUnkContainer;
|
|
|
|
// attach the container to the AxWindow
|
|
sc = pWndAx->AttachControl(pUnkCtrl, &spUnkContainer);
|
|
if(sc)
|
|
return sc;
|
|
|
|
|
|
// create a wrapper for the control
|
|
CComObject<COCXCtrlWrapper> *pOCXCtrlWrapper = NULL;
|
|
sc = CComObject<COCXCtrlWrapper>::CreateInstance(&pOCXCtrlWrapper);
|
|
if(sc)
|
|
return sc;
|
|
|
|
spUnkCtrl = pUnkCtrl;
|
|
|
|
// initialize the wrapper.
|
|
// The pointer to the control and the CMMCAxWindow is now owned by the wrapper.
|
|
sc = pOCXCtrlWrapper->ScInitialize(pWndAx, spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
m_spUnkCtrlWrapper = pOCXCtrlWrapper; // does the addref.
|
|
|
|
|
|
// cache only if the snapin asked us to. NOTE that this logic is different from the other version of SetControl
|
|
if(dwOCXOptions & RVTI_OCX_OPTIONS_CACHE_OCX)
|
|
{
|
|
// This is cached by the static node and used for all nodes of the snapin.
|
|
sc = pNodeCallback->SetControl(hNode, pUnkCtrl, m_spUnkCtrlWrapper); // this call passes the wrapper
|
|
if(sc)
|
|
return sc;
|
|
}
|
|
|
|
// Do not send MMCN_INITOCX, the snapin created this control it should have initialized it.
|
|
}
|
|
else
|
|
{
|
|
// The next call sets m_spUnkCtrlWrapper, which is used to get a pointer to the Ax window.
|
|
COCXCtrlWrapper *pOCXCtrlWrapper = dynamic_cast<COCXCtrlWrapper *>((IUnknown *)m_spUnkCtrlWrapper);
|
|
if(!pOCXCtrlWrapper)
|
|
return (sc = E_UNEXPECTED); // this should never happen.
|
|
|
|
sc = pOCXCtrlWrapper->ScGetControl(&spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
sc = ScCheckPointers(GetAxWindow(), (LPUNKNOWN)spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
// un-hide the window.
|
|
GetAxWindow()->ShowWindow(SW_SHOWNORMAL);
|
|
|
|
}
|
|
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::ScSetControl2
|
|
*
|
|
* PURPOSE: Hosts the specified control in the OCX view. This is the
|
|
* OCX returned by GetResultViewType. Also takes care of
|
|
* caching the control if needed and sending the MMCN_INITOCX
|
|
* notification to snap-ins. The caching is done by hiding the
|
|
* OCX window and passing nodemgr a COM object that holds a pointer
|
|
* to the window as well as the control. The nodemgr side determines
|
|
* whether or not to cache the control. If the control is not
|
|
* cached, nodemgr merely releases the object passed to it.
|
|
*
|
|
* PARAMETERS:
|
|
* HNODE hNode :
|
|
* LPCWSTR szOCXClsid :
|
|
* DWORD dwOCXOptions :
|
|
* INodeCallback * pNodeCallback :
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC
|
|
COCXHostView::ScSetControl2(HNODE hNode, LPCWSTR szOCXClsid, DWORD dwOCXOptions, INodeCallback *pNodeCallback)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::ScSetControl2"));
|
|
|
|
// validate parameters.
|
|
sc = ScCheckPointers((void *)hNode, szOCXClsid, pNodeCallback);
|
|
if(sc)
|
|
return sc;
|
|
|
|
// create the OCX if needed
|
|
CLSID clsid;
|
|
sc = CLSIDFromString (const_cast<LPWSTR>(szOCXClsid), &clsid);
|
|
if(sc)
|
|
return sc;
|
|
|
|
CComPtr<IUnknown> spUnkCtrl;
|
|
|
|
sc = ScHideWindow();
|
|
if(sc)
|
|
return sc;
|
|
|
|
// check whether there is a cached control for this node.
|
|
if (dwOCXOptions & RVTI_OCX_OPTIONS_CACHE_OCX)
|
|
{
|
|
sc = pNodeCallback->GetControl(hNode, clsid, &m_spUnkCtrlWrapper);
|
|
if (sc)
|
|
return sc;
|
|
}
|
|
|
|
// nope, create a control and set this control for the node.
|
|
if (m_spUnkCtrlWrapper == NULL)
|
|
{
|
|
CMMCAxWindow * pWndAx = NULL;
|
|
|
|
sc = ScCreateAxWindow(pWndAx);
|
|
if(sc)
|
|
return sc;
|
|
|
|
sc = pWndAx->CreateControlEx(szOCXClsid, NULL /*pStream*/,
|
|
NULL /*ppUnkContainer*/, &spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
|
|
// spUnkCtrl should be valid at this point.
|
|
sc = ScCheckPointers(spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
CComObject<COCXCtrlWrapper> *pOCXCtrlWrapper = NULL;
|
|
sc = CComObject<COCXCtrlWrapper>::CreateInstance(&pOCXCtrlWrapper);
|
|
if(sc)
|
|
return sc;
|
|
|
|
sc = ScCheckPointers(pOCXCtrlWrapper);
|
|
if(sc)
|
|
return sc;
|
|
|
|
// initialize the wrapper.
|
|
// The pointer to the control and the CMMCAxWindow is now owned by the wrapper.
|
|
sc = pOCXCtrlWrapper->ScInitialize(pWndAx, spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
m_spUnkCtrlWrapper = pOCXCtrlWrapper; // does the addref.
|
|
|
|
// This is cached by the static node and used for all nodes of the snapin.
|
|
if (dwOCXOptions & RVTI_OCX_OPTIONS_CACHE_OCX)
|
|
{
|
|
sc = pNodeCallback->SetControl(hNode, clsid, m_spUnkCtrlWrapper); // this call passes the wrapper
|
|
if(sc)
|
|
return sc;
|
|
}
|
|
|
|
// send the MMCN_INITOCX notification.
|
|
sc = pNodeCallback->InitOCX(hNode, spUnkCtrl); // this passes the actual IUnknown of the control.
|
|
if(sc)
|
|
return sc;
|
|
}
|
|
else
|
|
{
|
|
// The next call sets m_spUnkCtrlWrapper, which is used to get a pointer to the Ax window.
|
|
COCXCtrlWrapper *pOCXCtrlWrapper = dynamic_cast<COCXCtrlWrapper *>((IUnknown *)m_spUnkCtrlWrapper);
|
|
if(!pOCXCtrlWrapper)
|
|
return (sc = E_UNEXPECTED); // this should never happen.
|
|
|
|
sc = pOCXCtrlWrapper->ScGetControl(&spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
sc = ScCheckPointers(GetAxWindow(), (LPUNKNOWN)spUnkCtrl);
|
|
if(sc)
|
|
return sc;
|
|
|
|
// un-hide the window.
|
|
GetAxWindow()->ShowWindow(SW_SHOWNORMAL);
|
|
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::ScHideWindow
|
|
*
|
|
* PURPOSE: Hides the existing window, if any.
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC
|
|
COCXHostView::ScHideWindow()
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXCtrlWrapper::ScHideWindow"));
|
|
|
|
// if there is an existing window, hide it.
|
|
if(GetAxWindow())
|
|
{
|
|
GetAxWindow()->ShowWindow(SW_HIDE);
|
|
m_spUnkCtrlWrapper.Release(); // this deletes the unneeded window if the reference count is zero.
|
|
}
|
|
|
|
|
|
return sc;
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::ScCreateAxWindow
|
|
*
|
|
* PURPOSE: Creates a new Ax window
|
|
*
|
|
* PARAMETERS:
|
|
* PMMCAXWINDOW pWndAx :
|
|
*
|
|
* RETURNS:
|
|
* SC
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
SC
|
|
COCXHostView::ScCreateAxWindow(PMMCAXWINDOW &pWndAx)
|
|
{
|
|
DECLARE_SC(sc, TEXT("COCXHostView::ScCreateAxWindow"));
|
|
|
|
// create a new window
|
|
pWndAx = new CMMCAxWindow;
|
|
if(!pWndAx)
|
|
return (sc = E_OUTOFMEMORY);
|
|
|
|
|
|
// create the OCX host window
|
|
RECT rcClient;
|
|
GetClientRect(&rcClient);
|
|
HWND hwndAx = pWndAx->Create(m_hWnd, rcClient, _T(""), (WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS) );
|
|
|
|
if (hwndAx == NULL)
|
|
{
|
|
sc.FromLastError();
|
|
return (sc);
|
|
}
|
|
|
|
/*
|
|
* Bug 451981: By default, the ATL OCX host window supports hosting
|
|
* windowless controls. This differs from the MMC 1.2 implementation
|
|
* of the OCX host window (which used MFC), which did not. Some controls
|
|
* (e.g. Disk Defragmenter OCX) claim to support windowless instantiation
|
|
* but do not.
|
|
*
|
|
* For compatibility, we must only instantiate result pane OCX's as
|
|
* windowed controls.
|
|
*/
|
|
CComPtr<IAxWinAmbientDispatch> spHostDispatch;
|
|
sc = pWndAx->QueryHost(IID_IAxWinAmbientDispatch, (void**)&spHostDispatch);
|
|
if (sc)
|
|
sc.Clear(); // ignore this failure
|
|
else
|
|
{
|
|
spHostDispatch->put_AllowWindowlessActivation (VARIANT_FALSE); // disallow windowless activation
|
|
SetAmbientFont (spHostDispatch);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
void COCXHostView::OnDestroy()
|
|
{
|
|
CView::OnDestroy();
|
|
|
|
if(GetAxWindow())
|
|
GetAxWindow()->DestroyWindow();
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* COCXHostView::SetAmbientFont
|
|
*
|
|
* This function sets the font that any OCX that uses the DISPID_AMBIENT_FONT
|
|
* ambient property will inherit.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void COCXHostView::SetAmbientFont (IAxWinAmbientDispatch* pHostDispatch)
|
|
{
|
|
DECLARE_SC (sc, _T("COCXHostView::SetAmbientFont"));
|
|
CComPtr<IAxWinAmbientDispatch> spHostDispatch;
|
|
|
|
/*
|
|
* no host dispatch interface supplied? get it from the AxWindow
|
|
*/
|
|
if (pHostDispatch == NULL)
|
|
{
|
|
CMMCAxWindow* pWndAx = GetAxWindow();
|
|
if (pWndAx == NULL)
|
|
return;
|
|
|
|
sc = pWndAx->QueryHost(IID_IAxWinAmbientDispatch, (void**)&spHostDispatch);
|
|
if (sc)
|
|
return;
|
|
|
|
pHostDispatch = spHostDispatch;
|
|
sc = ScCheckPointers (pHostDispatch, E_UNEXPECTED);
|
|
if (sc)
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* get the icon title font
|
|
*/
|
|
LOGFONT lf;
|
|
SystemParametersInfo (SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, false);
|
|
|
|
/*
|
|
* get the desktop resolution
|
|
*/
|
|
CWindowDC dcDesktop (CWnd::GetDesktopWindow());
|
|
int ppi = dcDesktop.GetDeviceCaps (LOGPIXELSY);
|
|
long lfHeight = (lf.lfHeight >= 0) ? lf.lfHeight : -lf.lfHeight;
|
|
|
|
/*
|
|
* create an IFontDisp interface around the icon title font
|
|
*/
|
|
USES_CONVERSION;
|
|
FONTDESC fd;
|
|
fd.cbSizeofstruct = sizeof (fd);
|
|
fd.lpstrName = T2OLE (lf.lfFaceName);
|
|
fd.sWeight = (short) lf.lfWeight;
|
|
fd.sCharset = lf.lfCharSet;
|
|
fd.fItalic = lf.lfItalic;
|
|
fd.fUnderline = lf.lfUnderline;
|
|
fd.fStrikethrough = lf.lfStrikeOut;
|
|
fd.cySize.Lo = lfHeight * 720000 / ppi;
|
|
fd.cySize.Hi = 0;
|
|
|
|
CComPtr<IFontDisp> spFontDisp;
|
|
sc = OleCreateFontIndirect (&fd, IID_IFontDisp, (void**) &spFontDisp);
|
|
if (sc)
|
|
return;
|
|
|
|
/*
|
|
* set the Font property on the AxHostWindow
|
|
*/
|
|
pHostDispatch->put_Font (spFontDisp);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* COCXHostView::PreTranslateMessage
|
|
*
|
|
* PURPOSE: Sends accelerator messages to the OCX.
|
|
*
|
|
* PARAMETERS:
|
|
* MSG* pMsg :
|
|
*
|
|
* RETURNS:
|
|
* BOOL
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
BOOL
|
|
COCXHostView::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
if (pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
|
|
{
|
|
IOleInPlaceActiveObjectPtr spOleIPAObj = GetIUnknown();
|
|
|
|
#ifdef DBG
|
|
TCHAR szTracePrefix[32];
|
|
wsprintf (szTracePrefix, _T("msg=0x%04x, vkey=0x%04x:"), pMsg->message, pMsg->wParam);
|
|
#endif
|
|
|
|
if (spOleIPAObj != NULL)
|
|
{
|
|
bool fHandled = (spOleIPAObj->TranslateAccelerator(pMsg) == S_OK);
|
|
Trace (tagOCXTranslateAccel, _T("%s %s handled"), szTracePrefix, fHandled ? _T(" ") : _T("not"));
|
|
|
|
if (fHandled)
|
|
return TRUE;
|
|
}
|
|
else
|
|
Trace (tagOCXTranslateAccel, _T("%s not handled (no IOleInPlaceActiveObject*)"), szTracePrefix);
|
|
}
|
|
|
|
return BC::PreTranslateMessage(pMsg);
|
|
}
|