学步园

CATLActiveX -->  CComControl

CComControl --> CWindowImpl --> CWindowImplBaseT --> CWindowImplRoot --> CWindow
                       --> CComControlBase                                                                    --> CMessageMap

class ATL_NO_VTABLE CATLActiveX :
public CComObjectRootEx<CComSingleThreadModel>,
public CStockPropImpl<CATLActiveX, IATLCanvasWindow>,
public IPersistStreamInitImpl<CATLActiveX>,
public IOleControlImpl<CATLActiveX>,
public IOleObjectImpl<CATLActiveX>,
public IOleInPlaceActiveObjectImpl<CATLActiveX>,
public IViewObjectExImpl<CATLActiveX>,
public IOleInPlaceObjectWindowlessImpl<CATLActiveX>,
public ISupportErrorInfo,
public IConnectionPointContainerImpl<CATLActiveX>,
public CProxy_IATLCanvasWindowEvents<CATLActiveX>,
public IPersistStorageImpl<CATLActiveX>,
public ISpecifyPropertyPagesImpl<CATLActiveX>,
public IQuickActivateImpl<CATLActiveX>,
#ifndef _WIN32_WCE
public IDataObjectImpl<CATLActiveX>,
#endif
public IProvideClassInfo2Impl<&CLSID_ATLCanvasWindow, &__uuidof(_IATLCanvasWindowEvents), &LIBID_COMCanvasLib>,
#ifdef _WIN32_WCE // IObjectSafety is required on Windows CE for the control to be loaded correctly
public IObjectSafetyImpl<CATLActiveX, INTERFACESAFE_FOR_UNTRUSTED_CALLER>,
#endif
public CComCoClass<CATLActiveX, &CLSID_ATLCanvasWindow>,
public
CComControl<CATLActiveX>

{

================================================================================================================

template <class T, class WinBase =  CWindowImpl< T > >

class ATL_NO_VTABLE CComControl: publicCComControlBase, public WinBase
{
public:
CComControl() : CComControlBase(m_hWnd) {}

virtual HWND CreateControlWindow(HWND hWndParent, RECT& rcPos)
{
T* pT = static_cast<T*>(this);
return pT->Create(hWndParent, rcPos);
}

HRESULT FireOnRequestEdit(DISPID dispID)
{
T* pT = static_cast<T*>(this);
return T::__ATL_PROP_NOTIFY_EVENT_CLASS::FireOnRequestEdit(pT->GetUnknown(), dispID);
}
HRESULT FireOnChanged(DISPID dispID)
{
T* pT = static_cast<T*>(this);
return T::__ATL_PROP_NOTIFY_EVENT_CLASS::FireOnChanged(pT->GetUnknown(), dispID);
}

virtual HRESULT ControlQueryInterface(const IID& iid, void** ppv)
{
T* pT = static_cast<T*>(this);
return pT->GetUnknown()->QueryInterface(iid, ppv);
}

int MessageBox(LPCTSTR lpszText, LPCTSTR lpszCaption = _T(""), UINT nType = MB_OK)
{
if (::IsWindow(m_hWndCD))
return ::MessageBox(m_hWndCD, lpszText, lpszCaption, nType);
HWND hwndParent;
if (m_spInPlaceSite && m_spInPlaceSite->GetWindow(&hwndParent) == S_OK)
return ::MessageBox(hwndParent, lpszText, lpszCaption, nType);
return ::MessageBox(NULL, lpszText, lpszCaption, nType);
}

typedef CComControl< T, WinBase >thisClass;
typedef WinBasebaseWinClass;
BEGIN_MSG_MAP(thisClass)
__if_not_exists(WinBase::m_wndReflector)
{
MESSAGE_HANDLER(WM_PAINT, CComControlBase::OnPaint)
}
MESSAGE_HANDLER(WM_SETFOCUS, CComControlBase::OnSetFocus)
MESSAGE_HANDLER(WM_KILLFOCUS, CComControlBase::OnKillFocus)
MESSAGE_HANDLER(WM_MOUSEACTIVATE, CComControlBase::OnMouseActivate)
__if_exists(WinBase::m_wndReflector)
{
CHAIN_MSG_MAP(baseWinClass)
}
END_MSG_MAP()
};

================================================================================================================

================================================================================================================

template <class TBase = CWindow, class TWinTraits = CControlWinTraits>

class ATL_NO_VTABLE CWindowImplBaseT: publicCWindowImplRoot< TBase >
{
public:
WNDPROC m_pfnSuperWindowProc;

CWindowImplBaseT() : m_pfnSuperWindowProc(::DefWindowProc)
{}

static DWORD GetWndStyle(DWORD dwStyle)
{
return TWinTraits::GetWndStyle(dwStyle);
}
static DWORD GetWndExStyle(DWORD dwExStyle)
{
return TWinTraits::GetWndExStyle(dwExStyle);
}

virtual WNDPROC GetWindowProc()
{
return WindowProc;
}
static LRESULT CALLBACK StartWindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HWND Create(HWND hWndParent, _U_RECT rect, LPCTSTR szWindowName,
DWORD dwStyle, DWORD dwExStyle, _U_MENUorID MenuOrID, ATOM atom, LPVOID lpCreateParam = NULL);
BOOL DestroyWindow()
{
ATLASSERT(::IsWindow(m_hWnd));
return ::DestroyWindow(m_hWnd);
}
BOOL SubclassWindow(HWND hWnd);
HWND UnsubclassWindow(BOOL bForce = FALSE);

LRESULT DefWindowProc()
{
const _ATL_MSG* pMsg = m_pCurrentMsg;
LRESULT lRes = 0;
if (pMsg != NULL)
lRes = DefWindowProc(pMsg->message, pMsg->wParam, pMsg->lParam);
return lRes;
}

LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
#ifdef STRICT
return ::CallWindowProc(m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
#else
return ::CallWindowProc((FARPROC)m_pfnSuperWindowProc, m_hWnd, uMsg, wParam, lParam);
#endif
}

virtual void OnFinalMessage(HWND /*hWnd*/)
{
// override to do something, if needed
}
};

================================================================================================================

template <class TBase /* = CWindow */>
class ATL_NO_VTABLE CWindowImplRoot: public TBase, publicCMessageMap
{
public:
CWndProcThunk m_thunk;
const _ATL_MSG* m_pCurrentMsg;
DWORD m_dwState;

enum { WINSTATE_DESTROYED = 0x00000001 };

// Constructor/destructor
CWindowImplRoot() : m_pCurrentMsg(NULL), m_dwState(0)
{ }

virtual ~CWindowImplRoot()
{
#ifdef _DEBUG
if(m_hWnd != NULL)// should be cleared in WindowProc
{
ATLTRACE(atlTraceWindowing, 0, _T("ERROR - Object deleted before window was destroyed\n"));
ATLASSERT(FALSE);
}
#endif //_DEBUG
}

// Current message
const _ATL_MSG* GetCurrentMessage() const
{
return m_pCurrentMsg;
}

// "handled" management for cracked handlers
BOOL IsMsgHandled() const
{
const _ATL_MSG* pMsg = GetCurrentMessage();
ATLASSERT(pMsg != NULL);
ATLASSERT(pMsg->cbSize >= sizeof(_ATL_MSG));
return pMsg->bHandled;
}
void SetMsgHandled(BOOL bHandled)
{
_ATL_MSG* pMsg = (_ATL_MSG*)GetCurrentMessage();// override const
ATLASSERT(pMsg != NULL);
ATLASSERT(pMsg->cbSize >= sizeof(_ATL_MSG));
pMsg->bHandled = bHandled;
}

// Message forwarding and reflection support
LRESULT ForwardNotifications(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
LRESULT ReflectNotifications(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
static BOOL DefaultReflectionHandler(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lResult);
};

================================================================================================================

/////////////////////////////////////////////////////////////////////////////
// CMessageMap - abstract class that provides an interface for message maps

class ATL_NO_VTABLE CMessageMap
{ 
public:
virtual BOOL ProcessWindowMessage(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
LRESULT& lResult, DWORD dwMsgMapID) = 0;
};

===============================================================================================================

//////////////////////////////////////////////////////////////////////////////
// CComControlBase

// Holds the essential data members for an ActiveX control and useful helper functions
class ATL_NO_VTABLE CComControlBase
{
public:
typedef short AppearanceType;  // Override in derived class if your 
// m_nAppearance stock property isn't of type 'short'
public:
CComControlBase(HWND& h) : m_hWndCD(h)
{
memset(this, 0, sizeof(CComControlBase));
m_phWndCD = &h;
m_sizeExtent.cx = 2*2540;
m_sizeExtent.cy = 2*2540;
m_sizeNatural = m_sizeExtent;
}
virtual ~CComControlBase()
{
if (m_hWndCD != NULL)
::DestroyWindow(m_hWndCD);
ATLTRACE(atlTraceControls,2,_T("Control Destroyed\n"));
}

// methods
public:
// Control helper functions can go here non-virtuals only please

// Mark the control 'dirty' so the container will save it
void SetDirty(BOOL bDirty)
{
m_bRequiresSave = bDirty;
}
// Obtain the dirty state for the control 
BOOL GetDirty()
{
return m_bRequiresSave;
}
// Get the zoom factor (numerator & denominator) which is factor of the natural extent
void GetZoomInfo(ATL_DRAWINFO& di);
// Sends a notification that the moniker for the control has changed
HRESULT SendOnRename(IMoniker *pmk)
{
HRESULT hRes = S_OK;
if (m_spOleAdviseHolder)
hRes = m_spOleAdviseHolder->SendOnRename(pmk);
return hRes;
}
// Sends a notification that the control has just saved its data
HRESULT SendOnSave()
{
HRESULT hRes = S_OK;
if (m_spOleAdviseHolder)
hRes = m_spOleAdviseHolder->SendOnSave();
return hRes;
}
// Sends a notification that the control has closed its advisory sinks
HRESULT SendOnClose()
{
HRESULT hRes = S_OK;
if (m_spOleAdviseHolder)
hRes = m_spOleAdviseHolder->SendOnClose();
return hRes;
}
// Sends a notification that the control's data has changed
HRESULT SendOnDataChange(DWORD advf = 0);
// Sends a notification that the control's representation has changed
HRESULT SendOnViewChange(DWORD dwAspect, LONG lindex = -1)
{
if (m_spAdviseSink)
m_spAdviseSink->OnViewChange(dwAspect, lindex);
return S_OK;
}
// Sends a notification to the container that the control has received focus
LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
if (m_bInPlaceActive)
{
CComPtr<IOleObject> pOleObject;
ControlQueryInterface(__uuidof(IOleObject), (void**)&pOleObject);
if (pOleObject != NULL)
pOleObject->DoVerb(OLEIVERB_UIACTIVATE, NULL, m_spClientSite, 0, m_hWndCD, &m_rcPos);
CComQIPtr<IOleControlSite, &__uuidof(IOleControlSite)> spSite(m_spClientSite);
if (m_bInPlaceActive && spSite != NULL)
spSite->OnFocus(TRUE);
}
bHandled = FALSE;
return 1;
}
LRESULT OnKillFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
CComQIPtr<IOleControlSite, &__uuidof(IOleControlSite)> spSite(m_spClientSite);
if (m_bInPlaceActive && spSite != NULL && !::IsChild(m_hWndCD, ::GetFocus()))
spSite->OnFocus(FALSE);
bHandled = FALSE;
return 1;
}
LRESULT OnMouseActivate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
{
BOOL bUserMode = TRUE;
HRESULT hRet = GetAmbientUserMode(bUserMode);
// UI activate if in user mode only
// allow activation if we can't determine mode
if (FAILED(hRet) || bUserMode)
{
CComPtr<IOleObject> pOleObject;
ControlQueryInterface(__uuidof(IOleObject), (void**)&pOleObject);
if (pOleObject != NULL)
pOleObject->DoVerb(OLEIVERB_UIACTIVATE, NULL, m_spClientSite, 0, m_hWndCD, &m_rcPos);
}
bHandled = FALSE;
return 1;
}
BOOL PreTranslateAccelerator(LPMSG /*pMsg*/, HRESULT& /*hRet*/)
{
return FALSE;
}

HRESULT GetAmbientProperty(DISPID dispid, VARIANT& var)
{
HRESULT hRes = E_FAIL;
if (m_spAmbientDispatch.p != NULL)
hRes = m_spAmbientDispatch.GetProperty(dispid, &var);
return hRes;
}
HRESULT GetAmbientAppearance(short& nAppearance)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_APPEARANCE, var);
ATLASSERT(var.vt == VT_I2 || var.vt == VT_UI2 || var.vt == VT_I4 || var.vt == VT_UI4 || FAILED(hRes));
if (SUCCEEDED(hRes))
{
if (var.vt == VT_EMPTY)
hRes = E_FAIL;
else
{
nAppearance = var.iVal;
}
}
return hRes;
}
HRESULT GetAmbientBackColor(OLE_COLOR& BackColor)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_BACKCOLOR, var);
ATLASSERT(var.vt == VT_I4 || var.vt == VT_UI4 || FAILED(hRes));
BackColor = var.lVal;
return hRes;
}
HRESULT GetAmbientDisplayName(BSTR& bstrDisplayName)
{
CComVariant var;
if (bstrDisplayName)
{
SysFreeString(bstrDisplayName);
bstrDisplayName = NULL;
}
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_DISPLAYNAME, var);
if (SUCCEEDED(hRes))
{
if (var.vt != VT_BSTR)
return E_FAIL;
bstrDisplayName = var.bstrVal;
var.vt = VT_EMPTY;
var.bstrVal = NULL;
}
return hRes;
}
HRESULT GetAmbientFont(IFont** ppFont)
{
// caller MUST Release the font!
if (ppFont == NULL)
return E_POINTER;
*ppFont = NULL;
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_FONT, var);
ATLASSERT((var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH) || FAILED(hRes));
if (SUCCEEDED(hRes) && var.pdispVal)
{
if (var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH)
hRes = var.pdispVal->QueryInterface(__uuidof(IFont), (void**)ppFont);
else
hRes = DISP_E_BADVARTYPE;
}
return hRes;
}
HRESULT GetAmbientFontDisp(IFontDisp** ppFont)
{
// caller MUST Release the font!
if (ppFont == NULL)
return E_POINTER;
*ppFont = NULL;
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_FONT, var);
ATLASSERT((var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH) || FAILED(hRes));
if (SUCCEEDED(hRes) && var.pdispVal)
{
if (var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH)
hRes = var.pdispVal->QueryInterface(__uuidof(IFontDisp), (void**)ppFont);
else
hRes = DISP_E_BADVARTYPE;
}
return hRes;
}
HRESULT GetAmbientForeColor(OLE_COLOR& ForeColor)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_FORECOLOR, var);
ATLASSERT(var.vt == VT_I4 || var.vt == VT_UI4 || FAILED(hRes));
ForeColor = var.lVal;
return hRes;
}
HRESULT GetAmbientLocaleID(LCID& lcid)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_LOCALEID, var);
ATLASSERT((var.vt == VT_UI4 || var.vt == VT_I4) || FAILED(hRes));
lcid = var.lVal;
return hRes;
}
HRESULT GetAmbientScaleUnits(BSTR& bstrScaleUnits)
{
CComVariant var;
if (bstrScaleUnits)
{
SysFreeString(bstrScaleUnits);
bstrScaleUnits = NULL;
}
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_SCALEUNITS, var);
ATLASSERT(var.vt == VT_BSTR || FAILED(hRes));
if (SUCCEEDED(hRes))
{
if (var.vt != VT_BSTR)
return E_FAIL;
bstrScaleUnits = var.bstrVal;
var.vt = VT_EMPTY;
var.bstrVal = NULL;
}
return hRes;
}
HRESULT GetAmbientTextAlign(short& nTextAlign)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_TEXTALIGN, var);
ATLASSERT(var.vt == VT_I2 || FAILED(hRes));
if (SUCCEEDED(hRes))
{
if (var.vt == VT_EMPTY)
hRes = E_FAIL;
else
nTextAlign = var.iVal;
}
return hRes;
}
HRESULT GetAmbientUserMode(BOOL& bUserMode)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_USERMODE, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bUserMode = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientUIDead(BOOL& bUIDead)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_UIDEAD, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bUIDead = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientShowGrabHandles(BOOL& bShowGrabHandles)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_SHOWGRABHANDLES, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bShowGrabHandles = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientShowHatching(BOOL& bShowHatching)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_SHOWHATCHING, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bShowHatching = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientMessageReflect(BOOL& bMessageReflect)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_MESSAGEREFLECT, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bMessageReflect = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientAutoClip(BOOL& bAutoClip)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_AUTOCLIP, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bAutoClip = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientDisplayAsDefault(BOOL& bDisplaysDefault)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_DISPLAYASDEFAULT, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bDisplaysDefault = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientSupportsMnemonics(BOOL& bSupportMnemonics)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_SUPPORTSMNEMONICS, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bSupportMnemonics = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}
HRESULT GetAmbientPalette(HPALETTE& hPalette)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_PALETTE, var);
#ifdef _WIN64
ATLASSERT(var.vt == VT_I8 || var.vt == VT_UI8 || FAILED(hRes));
hPalette = reinterpret_cast<HPALETTE>(static_cast<LONG_PTR>(var.llVal));
#else
ATLASSERT(var.vt == VT_I4 || var.vt == VT_UI4 || FAILED(hRes));
hPalette = reinterpret_cast<HPALETTE>(static_cast<LONG_PTR>(var.lVal));
#endif
return hRes;
}

HRESULT GetAmbientCodePage(ULONG& ulCodePage)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_CODEPAGE, var);
ATLASSERT(var.vt == VT_UI4 || FAILED(hRes));
ulCodePage = var.ulVal;
return hRes;
}

HRESULT GetAmbientCharSet(BSTR& bstrCharSet)
{
CComVariant var;
if (bstrCharSet)
{
SysFreeString(bstrCharSet);
bstrCharSet = NULL;
}
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_CHARSET, var);
ATLASSERT(var.vt == VT_BSTR || FAILED(hRes));
if (SUCCEEDED(hRes))
{
if (var.vt != VT_BSTR)
return E_FAIL;
bstrCharSet = var.bstrVal;
var.vt = VT_EMPTY;
var.bstrVal = NULL;
}
return hRes;
}

HRESULT GetAmbientRightToLeft(BOOL& bRightToLeft)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_RIGHTTOLEFT, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bRightToLeft = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}

HRESULT GetAmbientTopToBottom(BOOL& bTopToBottom)
{
CComVariant var;
HRESULT hRes = GetAmbientProperty(DISPID_AMBIENT_TOPTOBOTTOM, var);
if(SUCCEEDED(hRes))
{
ATLASSERT(var.vt == VT_BOOL);
if(var.vt != VT_BOOL)
return DISP_E_TYPEMISMATCH;
bTopToBottom = (var.boolVal != ATL_VARIANT_FALSE) ? TRUE : FALSE;
}
return hRes;
}

HRESULT InternalGetSite(REFIID riid, void** ppUnkSite)
{
ATLASSERT(ppUnkSite != NULL);
if (ppUnkSite == NULL)
return E_POINTER;
if (m_spClientSite == NULL)
{
*ppUnkSite = NULL;
return E_FAIL;
}
return m_spClientSite->QueryInterface(riid, ppUnkSite);
}

BOOL DoesVerbUIActivate(LONG iVerb)
{
BOOL b = FALSE;
switch (iVerb)
{
case OLEIVERB_UIACTIVATE:
case OLEIVERB_PRIMARY:
b = TRUE;
break;
}
// if no ambient dispatch then in old style OLE container
if (DoesVerbActivate(iVerb) && m_spAmbientDispatch.p == NULL)
b = TRUE;
return b;
}

BOOL DoesVerbActivate(LONG iVerb)
{
BOOL b = FALSE;
switch (iVerb)
{
case OLEIVERB_UIACTIVATE:
case OLEIVERB_PRIMARY:
case OLEIVERB_SHOW:
case OLEIVERB_INPLACEACTIVATE:
b = TRUE;
break;
}
return b;
}

BOOL SetControlFocus(BOOL bGrab);
HRESULT IQuickActivate_QuickActivate(QACONTAINER *pQACont,
QACONTROL *pQACtrl);
HRESULT DoVerbProperties(LPCRECT /* prcPosRect */, HWND hwndParent);
HRESULT InPlaceActivate(LONG iVerb, const RECT* prcPosRect = NULL);

HRESULT IOleObject_SetClientSite(IOleClientSite *pClientSite);
HRESULT IOleObject_GetClientSite(IOleClientSite **ppClientSite);
HRESULT IOleObject_Advise(IAdviseSink *pAdvSink, DWORD *pdwConnection);
HRESULT IOleObject_Close(DWORD dwSaveOption);
HRESULT IOleObject_SetExtent(DWORD dwDrawAspect, SIZEL *psizel);
HRESULT IOleInPlaceObject_InPlaceDeactivate(void);
HRESULT IOleInPlaceObject_UIDeactivate(void);
HRESULT IOleInPlaceObject_SetObjectRects(LPCRECT prcPos,LPCRECT prcClip);
HRESULT IViewObject_Draw(DWORD dwDrawAspect, LONG lindex, void *pvAspect,
DVTARGETDEVICE *ptd, HDC hicTargetDev, HDC hdcDraw,
LPCRECTL prcBounds, LPCRECTL prcWBounds);
HRESULT IDataObject_GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);

HRESULT FireViewChange();
LRESULT OnPaint(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& lResult);

virtual HWND CreateControlWindow(HWND hWndParent, RECT& rcPos) = 0;
virtual HRESULT ControlQueryInterface(const IID& iid, void** ppv) = 0;
virtual HRESULT OnDrawAdvanced(ATL_DRAWINFO& di);
virtual HRESULT OnDraw(ATL_DRAWINFO& di)
{
::SetTextAlign(di.hdcDraw, TA_CENTER|TA_BASELINE);
LPCTSTR pszText = _T("ATL ") _T(_ATL_VER_RBLD);
::TextOut(di.hdcDraw, di.prcBounds->left + (di.prcBounds->right - di.prcBounds->left) / 2, di.prcBounds->top + (di.prcBounds->bottom - di.prcBounds->top) / 2, pszText, lstrlen(pszText));

return S_OK;
}

// Attributes
public:
CComPtr<IOleInPlaceSiteWindowless> m_spInPlaceSite;
CComPtr<IDataAdviseHolder> m_spDataAdviseHolder;
CComPtr<IOleAdviseHolder> m_spOleAdviseHolder;
CComPtr<IOleClientSite> m_spClientSite;
CComPtr<IAdviseSink> m_spAdviseSink;
CComDispatchDriver m_spAmbientDispatch;

SIZE m_sizeNatural; //unscaled size in himetric
SIZE m_sizeExtent;  //current extents in himetric
RECT m_rcPos; // position in pixels
#pragma warning(push)
#pragma warning(disable: 4510 4610) // unnamed union
union
{
HWND& m_hWndCD;
HWND* m_phWndCD;
};
#pragma warning(pop)

int m_nFreezeEvents; // count of freezes versus thaws
unsigned m_bNegotiatedWnd:1;
unsigned m_bWndLess:1;
unsigned m_bInPlaceActive:1;
unsigned m_bUIActive:1;
unsigned m_bUsingWindowRgn:1;
unsigned m_bInPlaceSiteEx:1;
unsigned m_bWindowOnly:1;
unsigned m_bRequiresSave:1;
unsigned m_bWasOnceWindowless:1;
unsigned m_bAutoSize:1; //SetExtent fails if size doesn't match existing
unsigned m_bRecomposeOnResize:1; //implies OLEMISC_RECOMPOSEONRESIZE
unsigned m_bResizeNatural:1;  //resize natural extent on SetExtent
unsigned m_bDrawFromNatural:1; //instead of m_sizeExtent
unsigned m_bDrawGetDataInHimetric:1; //instead of pixels

DECLARE_VIEW_STATUS(VIEWSTATUS_OPAQUE)
};