able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/enduser/stuff/hhctrl/ctrlobj.h

527 lines
22 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// Copyright 1995-1997 Microsoft Corporation. All Rights Reserved.
#if _MSC_VER > 1000
#pragma once
#endif
#ifndef _CTRLOBJ_H_
#define _CTRLOBJ_H_
// we need the automation object and ctlole.h
#include "AutoObj.H"
#include <olectl.h>
// forward declaration
class COleControl;
//=--------------------------------------------------------------------------=
// Misc Helper Functions
//=--------------------------------------------------------------------------=
//
// given an Unknown pointer, get the COleControl * for it. used typically
// in property page code.
COleControl *ControlFromUnknown(IUnknown *);
//=--------------------------------------------------------------------------=
// Misc Constants
//=--------------------------------------------------------------------------=
// maximum number of arguments that can be sent to FireEvent()
#define MAX_ARGS 32
// for the types of sinks that the COleControl class has. you shouldn't ever
// need to use these
#define SINK_TYPE_EVENT 0
#define SINK_TYPE_PROPNOTIFY 1
// superclass window support. you can pass this in to DoSuperClassPaint
#define DRAW_SENDERASEBACKGROUND 1
//=--------------------------------------------------------------------------=
// Various Hosts don't handle OLEIVERB_PROPERTIES correctly, so we can't use
// that as our Properties verb number. Instead, we're going to define
// CTLIVERB_PROPERTIES as 1, and return that one in IOleObject::EnumVerbs,
// but we'll still handle OLEIVERB_PROPERTIES correctly in DoVerb.
#define CTLIVERB_PROPERTIES 1
//=--------------------------------------------------------------------------=
// this structure is like the OLEVERB structure, except that it has a resource ID
// instead of a string for the verb's name. better support for localization.
typedef struct tagVERBINFO {
LONG lVerb; // verb id
ULONG idVerbName; // resource ID of verb name
DWORD fuFlags; // verb flags
DWORD grfAttribs; // Specifies some combination of the verb attributes in the OLEVERBATTRIB enumeration.
} VERBINFO;
// describes an event
typedef struct tagEVENTINFO {
DISPID dispid; // dispid of the event
int cParameters; // number of arguments to the event
VARTYPE *rgTypes; // type of each argument
} EVENTINFO;
//=--------------------------------------------------------------------------=
// CONTROLOBJECTINFO
//=--------------------------------------------------------------------------=
// for each control you wish to expose to the programmer/user, you need to
// declare and define one of the following structures. the first part should
// follow the rules of the AUTOMATIONOBJECTINFO structure. it's pretty hard,
// however, to imagine a scenario where the control isn't CoCreatable ...
// once this structre is declared/defined, an entry should be put in the
// global g_ObjectInfo table.
//
typedef struct {
AUTOMATIONOBJECTINFO AutomationInfo; // automation and creation information
const IID *piidEvents; // IID of primary event interface
DWORD dwOleMiscFlags; // control flags
DWORD dwActivationPolicy; // IPointerInactive support
VARIANT_BOOL fOpaque; // is your control 100% opaque?
VARIANT_BOOL fWindowless; // do we do windowless if we can?
WORD wToolboxId; // resource ID of Toolbox Bitmap
LPCSTR szWndClass; // name of window control class
VARIANT_BOOL fWindowClassRegistered; // has the window class been registered yet?
WORD cPropPages; // number of property pages
const GUID **rgPropPageGuids; // array of the property page GUIDs
WORD cCustomVerbs; // number of custom verbs
const VERBINFO *rgCustomVerbs; // description of custom verbs
WNDPROC pfnSubClass; // for subclassed controls.
} CONTROLOBJECTINFO;
#ifndef INITOBJECTS
#define DEFINE_CONTROLOBJECT(name, clsid, progid, fn, ver, riid, pszh, piide, dwcf, dwap, w, szwc, cpp, rgppg, ccv, rgcv) \
extern CONTROLOBJECTINFO name##Control \
#define DEFINE_WINDOWLESSCONTROLOBJECT(name, clsid, progid, fn, ver, riid, pszh, piide, dwcf, dwap, fo, w, szwc, cpp, rgppg, ccv, rgcv) \
extern CONTROLOBJECTINFO name##Control \
#else
#define DEFINE_CONTROLOBJECT(name, clsid, progid, fn, ver, riid, pszh, piide, dwcf, dwap, w, szwc, cpp, rgppg, ccv, rgcv) \
CONTROLOBJECTINFO name##Control = { { {clsid, progid, fn}, ver, riid, pszh, NULL, 0}, piide, dwcf, dwap, TRUE, FALSE, w, szwc, FALSE, cpp, rgppg, ccv, rgcv, NULL } \
#define DEFINE_WINDOWLESSCONTROLOBJECT(name, clsid, progid, fn, ver, riid, pszh, piide, dwcf, dwap, fo, w, szwc, cpp, rgppg, ccv, rgcv) \
CONTROLOBJECTINFO name##Control = { { {clsid, progid, fn}, ver, riid, pszh, NULL, 0}, piide, dwcf, dwap, fo, TRUE, w, szwc, FALSE, cpp, rgppg, ccv, rgcv, NULL } \
#endif // !INITOBJECTS
#define OLEMISCFLAGSOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->dwOleMiscFlags
#define FCONTROLISWINDOWLESS(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->fWindowless
#define FCONTROLISOPAQUE(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->fOpaque
#define ACTIVATIONPOLICYOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->dwActivationPolicy
#define EVENTIIDOFCONTROL(index) (*(((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->piidEvents))
#define WNDCLASSNAMEOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->szWndClass
#define CPROPPAGESOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->cPropPages
#define PPROPPAGESOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->rgPropPageGuids
#define CCUSTOMVERBSOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->cCustomVerbs
#define CUSTOMVERBSOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->rgCustomVerbs
#define BITMAPIDOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->wToolboxId
#define CTLWNDCLASSREGISTERED(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->fWindowClassRegistered
#define SUBCLASSWNDPROCOFCONTROL(index) ((CONTROLOBJECTINFO *)(g_ObjectInfo[index].pInfo))->pfnSubClass
// These need to match what is in COleControl::InternalQueryInterface
class COleControl : public CAutomationObject,
public IOleObject,
public IOleControl,
public IOleInPlaceObjectWindowless,
public IOleInPlaceActiveObject,
public IViewObjectEx,
public IPersistPropertyBag,
public IPersistStreamInit,
public IPersistStorage,
public IConnectionPointContainer,
public IProvideClassInfo,
public IPointerInactive,
public IQuickActivate
{
public:
// IUnknown methods -- there are required since we inherit from variuos
// people who themselves inherit from IUnknown. just delegate to controlling
// unknown
DECLARE_STANDARD_UNKNOWN();
//=--------------------------------------------------------------------------=
// IPersist methods. used by IPersistStream and IPersistStorage
STDMETHOD(GetClassID)(THIS_ LPCLSID lpClassID);
// IPersistStreamInit methods
STDMETHOD(IsDirty)(THIS);
STDMETHOD(Load)(LPSTREAM pStm);
STDMETHOD(Save)(LPSTREAM pStm, BOOL fClearDirty);
STDMETHOD(GetSizeMax)(ULARGE_INTEGER FAR* pcbSize);
STDMETHOD(InitNew)();
// IPersistStorage
STDMETHOD(InitNew)(IStorage *pStg);
STDMETHOD(Load)(IStorage *pStg);
STDMETHOD(Save)(IStorage *pStgSave, BOOL fSameAsLoad);
STDMETHOD(SaveCompleted)(IStorage *pStgNew);
STDMETHOD(HandsOffStorage)(void);
// IPersistPropertyBag
STDMETHOD(Load)(LPPROPERTYBAG pPropBag, LPERRORLOG pErrorLog);
STDMETHOD(Save)(LPPROPERTYBAG pPropBag, BOOL fClearDirty,
BOOL fSaveAllProperties);
// IOleControl methods
STDMETHOD(GetControlInfo)(LPCONTROLINFO pCI);
STDMETHOD(OnMnemonic)(LPMSG pMsg);
STDMETHOD(OnAmbientPropertyChange)(DISPID dispid);
STDMETHOD(FreezeEvents)(BOOL bFreeze);
// IOleObject methods
STDMETHOD(SetClientSite)(IOleClientSite *pClientSite);
STDMETHOD(GetClientSite)(IOleClientSite * *ppClientSite);
STDMETHOD(SetHostNames)(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj);
STDMETHOD(Close)(DWORD dwSaveOption);
STDMETHOD(SetMoniker)(DWORD dwWhichMoniker, IMoniker *pmk);
STDMETHOD(GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker * *ppmk);
STDMETHOD(InitFromData)(IDataObject *pDataObject, BOOL fCreation, DWORD dwReserved);
STDMETHOD(GetClipboardData)(DWORD dwReserved, IDataObject * *ppDataObject);
STDMETHOD(DoVerb)(LONG iVerb, LPMSG lpmsg, IOleClientSite *pActiveSite, LONG lindex,
HWND hwndParent, LPCRECT lprcPosRect);
STDMETHOD(EnumVerbs)(IEnumOLEVERB * *ppEnumOleVerb);
STDMETHOD(Update)(void);
STDMETHOD(IsUpToDate)(void);
STDMETHOD(GetUserClassID)(CLSID *pClsid);
STDMETHOD(GetUserType)(DWORD dwFormOfType, LPOLESTR *pszUserType);
STDMETHOD(SetExtent)(DWORD dwDrawAspect,SIZEL *psizel);
STDMETHOD(GetExtent)(DWORD dwDrawAspect, SIZEL *psizel);
STDMETHOD(Advise)(IAdviseSink *pAdvSink, DWORD *pdwConnection);
STDMETHOD(Unadvise)(DWORD dwConnection);
STDMETHOD(EnumAdvise)(IEnumSTATDATA * *ppenumAdvise);
STDMETHOD(GetMiscStatus)(DWORD dwAspect, DWORD *pdwStatus);
STDMETHOD(SetColorScheme)(LOGPALETTE *pLogpal);
// IOleWindow. required for IOleInPlaceObject and IOleInPlaceActiveObject
STDMETHOD(GetWindow)(HWND *phwnd);
STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);
// IOleInPlaceObject/IOleInPlaceObjectWindowless
STDMETHOD(InPlaceDeactivate)(void);
STDMETHOD(UIDeactivate)(void);
// STDMETHOD(SetObjectRects)(LPCRECT lprcPosRect,LPCRECT lprcClipRect) ;
STDMETHOD(ReactivateAndUndo)(void);
STDMETHOD(OnWindowMessage)(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult);
STDMETHOD(GetDropTarget)(IDropTarget **ppDropTarget);
// IOleInPlaceActiveObject
STDMETHOD(TranslateAccelerator)(LPMSG lpmsg);
STDMETHOD(OnFrameWindowActivate)(BOOL fActivate);
STDMETHOD(OnDocWindowActivate)(BOOL fActivate);
STDMETHOD(ResizeBorder)(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow,
BOOL fFrameWindow);
STDMETHOD(EnableModeless)(BOOL fEnable);
// IViewObject2/IViewObjectEx
STDMETHOD(Draw)(DWORD dwDrawAspect, LONG lindex, void *pvAspect,
DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw,
LPCRECTL lprcBounds, LPCRECTL lprcWBounds,
BOOL ( __stdcall *pfnContinue )(ULONG_PTR dwContinue),
ULONG_PTR dwContinue);
STDMETHOD(GetColorSet)(DWORD dwDrawAspect,LONG lindex, void *pvAspect,
DVTARGETDEVICE *ptd, HDC hicTargetDev,
LOGPALETTE * *ppColorSet);
STDMETHOD(Freeze)(DWORD dwDrawAspect, LONG lindex,
void *pvAspect,DWORD *pdwFreeze);
STDMETHOD(Unfreeze)(DWORD dwFreeze);
STDMETHOD(SetAdvise)(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink);
STDMETHOD(GetAdvise)(DWORD *pAspects, DWORD *pAdvf, IAdviseSink * *ppAdvSink);
STDMETHOD(GetExtent)(DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE __RPC_FAR *ptd, LPSIZEL lpsizel);
STDMETHOD(GetRect)(DWORD dwAspect, LPRECTL pRect);
STDMETHOD(GetViewStatus)(DWORD *pdwStatus);
STDMETHOD(QueryHitPoint)(DWORD dwAspect, LPCRECT pRectBounds, POINT ptlLoc, LONG lCloseHint, DWORD *pHitResult);
STDMETHOD(QueryHitRect)(DWORD dwAspect, LPCRECT pRectBounds, LPCRECT prcLoc, LONG lCloseHint, DWORD *pHitResult);
STDMETHOD(GetNaturalExtent)(DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd, HDC hicTargetDev, DVEXTENTINFO *pExtentInfo, LPSIZEL psizel);
// IConnectionPointContainer methods
STDMETHOD(EnumConnectionPoints)(LPENUMCONNECTIONPOINTS FAR* ppEnum);
STDMETHOD(FindConnectionPoint)(REFIID iid, LPCONNECTIONPOINT FAR* ppCP);
// ISpecifyPropertyPages
// STDMETHOD(GetPages)(CAUUID * pPages);
// IProvideClassInfo methods
STDMETHOD(GetClassInfo)(LPTYPEINFO * ppTI);
// IPointerInactive methods
STDMETHOD(GetActivationPolicy)(DWORD *pdwPolicy);
STDMETHOD(OnInactiveMouseMove)(LPCRECT pRectBounds, long x, long y, DWORD dwMouseMsg);
STDMETHOD(OnInactiveSetCursor)(LPCRECT pRectBounds, long x, long y, DWORD dwMouseMsg, BOOL fSetAlways);
// IQuickActivate methods
STDMETHOD(QuickActivate)(QACONTAINER *pqacontainer, QACONTROL *pqacontrol);
STDMETHOD(SetContentExtent)(LPSIZEL);
STDMETHOD(GetContentExtent)(LPSIZEL);
// constructor and destructor
COleControl(IUnknown *pUnkOuter, int iPrimaryDispatch, void *pMainInterface);
virtual ~COleControl();
//=--------------------------------------------------------------------------=
// callable by anybody
static LRESULT CALLBACK ControlWindowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp);
// static LRESULT CALLBACK ReflectWindowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp);
static COleControl * ControlFromHwnd(HWND hwnd) {
return (COleControl *) GetWindowLongPtr(hwnd, GWLP_USERDATA);
}
void __cdecl FireEvent(EVENTINFO * pEventInfo, ...);
/*
* ole controls that want to support both windowed and windowless
* operations should use these wrappers instead of the appropriate win32
* api routine. controls that don't care and just want to be windowed
* all the time can just go ahead and use the api routines.
*/
BOOL SetFocus(BOOL fGrab); // SetFocus API
BOOL OcxGetFocus(void); // GetFocus() == m_hwnd
BOOL OcxGetWindowRect(LPRECT); // gets your current window rect
LRESULT OcxDefWindowProc(UINT, WPARAM, LPARAM); // DefWindowProc
HDC OcxGetDC(void); // GetDC(m_hwnd);
void OcxReleaseDC(HDC hdc); // ReleaseDC(m_hwnd, hdc);
BOOL OcxSetCapture(BOOL fGrab); // SetCapture(fGrab ? m_hwnd : NULL);
BOOL OcxGetCapture(void); // GetCapture() == m_hwnd
BOOL OcxInvalidateRect(LPCRECT, BOOL); // InvalidateRect(m_hwnd, prc, f);
BOOL OcxScrollRect(LPCRECT, LPCRECT, int, int); // ScrollWindowEx(...);
protected:
//=--------------------------------------------------------------------------=
// member variables that derived controls can get at.
//
// derived controls Should NOT modify the following.
IOleClientSite *m_pClientSite; // client site
IOleControlSite *m_pControlSite; // IOleControlSite ptr on client site
IOleInPlaceSite *m_pInPlaceSite; // IOleInPlaceSite for managing activation
IOleInPlaceFrame *m_pInPlaceFrame; // IOleInPlaceFrame ptr on client site
IOleInPlaceUIWindow *m_pInPlaceUIWindow; // for negotiating border space with client
ISimpleFrameSite *m_pSimpleFrameSite; // simple frame site
IDispatch *m_pDispAmbient; // ambient dispatch pointer
SIZEL m_Size; // the size of this control
RECT m_rcLocation; // where we at
public:
HWND m_hwnd; // our window
HWND m_hwndParent; // our parent window
protected:
// Windowless OLE controls support
IOleInPlaceSiteWindowless *m_pInPlaceSiteWndless; // IOleInPlaceSiteWindowless pointer
// flags indicating internal state. do not modify.
unsigned m_fDirty:1; // does the control need to be resaved?
unsigned m_fInPlaceActive:1; // are we in place active or not?
unsigned m_fInPlaceVisible:1; // we are in place visible or not?
unsigned m_fUIActive:1; // are we UI active or not.
unsigned m_fCreatingWindow:1; // indicates if we're in CreateWindowEx or not
//=--------------------------------------------------------------------------=
// methods that derived controls can override, but may need to be called
// from their versions.
virtual void ViewChanged(void);
virtual HRESULT InternalQueryInterface(REFIID riid, void **ppvObjOut);
//=--------------------------------------------------------------------------=
// member functions that provide for derived controls, or that we use, but
// derived controls might still find useful.
HRESULT DoSuperClassPaint(HDC, LPCRECTL);
// HRESULT RecreateControlWindow(void);
BOOL DesignMode(void);
BOOL GetAmbientProperty(DISPID, VARTYPE, void *);
BOOL GetAmbientFont(IFont **ppFontOut);
public:
void ModalDialog(BOOL fShow) {
// notify the container of our intention to show a modal dialog...
if (m_pInPlaceFrame)
m_pInPlaceFrame->EnableModeless(!fShow);
}
HRESULT InPlaceActivate(LONG lVerb);
void InvalidateControl(LPCRECT prc);
protected:
BOOL SetControlSize(SIZEL *pSizel);
HWND CreateInPlaceWindow(int x, int y, BOOL fNoRedraw);
void SetInPlaceVisible(BOOL);
void SetInPlaceParent(HWND);
// IPropertyNotifySink stuff.
inline void PropertyChanged(DISPID dispid) {
m_cpPropNotify.DoOnChanged(dispid);
}
inline BOOL RequestPropertyEdit(DISPID dispid) {
return m_cpPropNotify.DoOnRequestEdit(dispid);
}
// subclassed windows controls support ...
// little routine for people to tell if they are windowless or not
//
inline BOOL Windowless(void) {
return !m_fInPlaceActive || m_pInPlaceSiteWndless;
}
// some people don't care if they're windowed or not -- they just need
// a site pointer. this makes it a little easier.
//
inline IOleInPlaceSite *GetInPlaceSite(void) {
return (IOleInPlaceSite *)(m_pInPlaceSiteWndless ? m_pInPlaceSiteWndless : m_pInPlaceSite);
}
protected:
//=--------------------------------------------------------------------------=
// the following are methods that ALL control writers must override and implement
STDMETHOD(LoadBinaryState)(IStream *pStream) PURE;
// STDMETHOD(SaveBinaryState)(IStream *pStream) PURE;
STDMETHOD(LoadTextState)(IPropertyBag *pPropertyBag, IErrorLog *pErrorLog) PURE;
STDMETHOD(SaveTextState)(IPropertyBag *pPropertyBag, BOOL fWriteDefault) PURE;
STDMETHOD(OnDraw)(DWORD dvAspect, HDC hdcDraw, LPCRECTL prcBounds, LPCRECTL prcWBounds, HDC hicTargetDev, BOOL fOptimize) PURE;
virtual LRESULT WindowProc(UINT msg, WPARAM wParam, LPARAM lParam) PURE;
virtual BOOL RegisterClassData(void) PURE;
//=--------------------------------------------------------------------------=
// OVERRIDABLES -- methods controls can implement for customized functionality
virtual void AmbientPropertyChanged(DISPID dispid) { };
virtual BOOL ShouldCreateWindow() { return TRUE; }
virtual BOOL BeforeCreateWindow(DWORD *, DWORD *, LPSTR) { return TRUE; }
virtual void BeforeDestroyWindow(void) { }
virtual HRESULT DoCustomVerb(LONG lVerb) { return OLEOBJ_S_INVALIDVERB; }
virtual BOOL OnSetExtent(const SIZE* pSize) { return TRUE; }
virtual BOOL OnSpecialKey(LPMSG) { return FALSE; }
virtual BOOL OnGetPalette(HDC, LOGPALETTE **);
virtual HRESULT OnQuickActivate(QACONTAINER *, DWORD *);
virtual BOOL InitializeNewState();
virtual BOOL AfterCreateWindow(void) { return TRUE; }
virtual BOOL OnGetRect(DWORD dvAspect, LPRECTL prcRect);
//=--------------------------------------------------------------------------=
// methods that various people internally will share. not needed, however, by
// any inherting classes.
HRESULT m_SaveToStream(IStream *pStream);
HRESULT LoadStandardState(IPropertyBag *pPropertyBag, IErrorLog *pErrorLog);
HRESULT LoadStandardState(IStream *pStream);
HRESULT SaveStandardState(IPropertyBag *pPropertyBag);
HRESULT SaveStandardState(IStream *pStream);
//=--------------------------------------------------------------------------=
// member variables we don't want anybody to get their hands on, including
// inheriting classes
IOleAdviseHolder *m_pOleAdviseHolder; // IOleObject::Advise holder object
IAdviseSink *m_pViewAdviseSink; // IViewAdvise sink for IViewObject2
unsigned short m_nFreezeEvents; // count of freezes versus thaws
// internal flags. various other flags are visible to the end control class.
unsigned m_fModeFlagValid:1; // we stash the mode as much as possible
unsigned m_fSaveSucceeded:1; // did an IStorage save work correctly?
unsigned m_fViewAdvisePrimeFirst: 1; // for IViewobject2::setadvise
unsigned m_fViewAdviseOnlyOnce: 1; // for iviewobject2::setadvise
unsigned m_fUsingWindowRgn:1; // for SetObjectRects and clipping
unsigned m_fRunMode:1; // are we in run mode or not?
class CConnectionPoint : public IConnectionPoint {
public:
#ifdef _WIN64
CONNECTDATA * m_rgSinks64;
#else
IUnknown **m_rgSinks;
#endif
// IUnknown methods
//
STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR* ppvObj) ;
STDMETHOD_(ULONG,AddRef)(THIS) ;
STDMETHOD_(ULONG,Release)(THIS) ;
// IConnectionPoint methods
//
STDMETHOD(GetConnectionInterface)(IID FAR* pIID);
STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer FAR* FAR* ppCPC);
STDMETHOD(Advise)(LPUNKNOWN pUnkSink, DWORD FAR* pdwCookie);
STDMETHOD(Unadvise)(DWORD dwCookie);
STDMETHOD(EnumConnections)(LPENUMCONNECTIONS FAR* ppEnum);
void DoInvoke(DISPID dispid, DISPPARAMS * pdispparam);
void DoOnChanged(DISPID dispid);
BOOL DoOnRequestEdit(DISPID dispid);
HRESULT AddSink(void *, DWORD *);
COleControl *m_pOleControl();
CConnectionPoint(BYTE b){
m_bType = b;
m_cSinks = 0;
#ifdef _WIN64
m_rgSinks64 = NULL;
m_dwNextCookie = 1;
#else
m_rgSinks = NULL;
#endif
}
~CConnectionPoint();
private:
BYTE m_bType;
short m_cSinks;
#ifdef _WIN64
DWORD m_dwNextCookie;
DWORD NextCookie();
IUnknown* CookieToSink( DWORD dwCookie );
#endif
} m_cpEvents, m_cpPropNotify;
// so they can get at some of our protected things, like AddRef, QI, etc.
friend CConnectionPoint;
};
#endif // _CTRLOBJ_H_
Reference in a new issue Copy permalink