/* ddeproxy.h
Used by ddeproxy.cpp ddeDO.cpp ddeOO.cpp
Author: Jason Fuller jasonful 24-July-1992
*/
#ifndef fDdeProxy_h
#define fDdeProxy_h
//
// One of the oleint.h routines redefines GlobalAlloc and friends
// to perform some memory tracking functions.
//
// This doesn't work in these files, since the tracking functions
// add tail checking, and size to the data structures. GlobalSize
// is a common function to use to determine how much data to
// serialize, plus it turns out that the other side of a DDE
// connection will often be the caller to free the memory.
//
// Therefore, OLE_DDE_NO_GLOBAL_TRACKING is used to disable this in the
// global header file ih\memapi.hxx. Check to insure this
// flag is set on the compile line
//
#if !defined(OLE_DDE_NO_GLOBAL_TRACKING)
error OLE_DDE_OLE_DDE_NO_GLOBAL_TRACKING must be defined to build this directory
#endif
#include <ole2int.h>
#include <callcont.hxx>
#include <ddeint.h>
#include <dde.h>
#include <olerem.h>
#include <ole1cls.h>
#include <limits.h>
// For fDdeCodeInOle2Dll flag
#include <ddeatoms.h>
#include <ddepack.h>
#include <ddedebug.h>
#ifdef OLE_DEBUG_EXT
#include <ntsdexts.h>
#endif OLE_DEBUG_EXT
#include "ddechc.hxx"
#define LPCALLINFO LPVOID
#include "ddeerr.h"
#include "cnct_tbl.h"
#define MAX_STR 256
// number of .01 mm per inch
#define HIMETRIC_PER_INCH 2540
//#define fDebugOutput
// callback notifications
#define ON_CHANGE 0
#define ON_SAVE 1
#define ON_CLOSE 2
#define ON_RENAME 3
// AwaitAck values
#define AA_NONE 0
#define AA_REQUEST 1
#define AA_ADVISE 2
#define AA_POKE 3
#define AA_EXECUTE 4
#define AA_UNADVISE 5
#define AA_INITIATE 6
#define AA_TERMINATE 7
// A DDE_REQUEST to see if a format is available, not to keep the data.
#define AA_REQUESTAVAILABLE 8
// Bits for Positive WM_DDE_ACK
//#define POSITIVE_ACK 0x8000
//#define NEGATIVE_ACK 0x0000
typedef DWORD CHK;
const DWORD chkDdeObj = 0xab01; // magic cookie
typedef struct tagDDE_CHANNEL : public CPrivAlloc {
ULONG AddReference()
{
return ++m_cRefs;
}
ULONG ReleaseReference()
{
if (--m_cRefs == 0)
{
delete this;
return(0);
}
return(m_cRefs);
}
ULONG m_cRefs;
HWND hwndCli;
HWND hwndSvr;
BOOL bTerminating;
int iExtraTerms;
WORD wTimer;
DWORD dwStartTickCount;
WORD msgFirst;
WORD msgLast;
HWND msghwnd; //
BOOL fRejected; // because fBusy flag set in DDE_ACK
WORD wMsg;
LONG lParam;
int iAwaitAck;
HRESULT hres;
HANDLE hopt; // Memory blocks I may have to free for DDE_ADVISE
HANDLE hDdePoke; // for DDE_POKE
HANDLE hCommands; // for DDE_EXECUTE
WORD wChannelDeleted;
PCALLDATA pCD;
PCALLCONTROL pCallCont;
CDdeChannelControl *pChanCont;
} DDE_CHANNEL;
#define Channel_InModalloop 1
#define Channel_DeleteNow 2
typedef DDE_CHANNEL * LPDDE_CHANNEL;
extern BOOL bWndClassesRegistered;
#define hinstSO g_hmodOLE2
extern HMODULE g_hmodOLE2;
extern INTERNAL_(BOOL) wRegisterClasses (void);
#ifndef _MAC
extern CLIPFORMAT g_cfNative;
extern CLIPFORMAT g_cfBinary;
#endif
#ifdef _CHICAGO_
//Note:POSTPPC
//
// DelayDelete is used to delay deleting the CDdeObject
// Guard will set it to DelayIt
// UnGuard will reset it to NoDelay or delete the object
// if state is ReadyToDelete
//
typedef enum
{
NoDelay = 0, // normal state
DelayIt = 1, // object is protected and deleting will be delayed
ReadyToDelete = 2 // object was is DelayIt state and can be deleted
} DelayDelete;
#endif // _CHICAGO_
/*
* Definition of CDdeObject
*
*/
class CMsgFilterInfo;
class CDdeObject;
class CDdeObject : public CPrivAlloc
{
public:
static INTERNAL_(LPUNKNOWN) Create (IUnknown * pUnkOuter,
REFCLSID clsidClass,
ULONG ulObjType = OT_EMBEDDED,
ATOM aTopic = NULL,
LPOLESTR szItem = NULL,
CDdeObject * * ppdde = NULL,
BOOL fAllowNullClsid = FALSE);
INTERNAL_(void) OnInitAck (LPDDE_CHANNEL pChannel, HWND hwndSvr);
INTERNAL_(BOOL) OnAck (LPDDE_CHANNEL pChannel, LONG lParam);
INTERNAL_(void) OnTimer (LPDDE_CHANNEL pChannel);
INTERNAL OnData (LPDDE_CHANNEL pChannel, HANDLE hData,ATOM aItem);
INTERNAL OnDataAvailable (LPDDE_CHANNEL pChannel, HANDLE hData,ATOM aItem);
INTERNAL OnTerminate (LPDDE_CHANNEL pChannel, HWND hwndPost);
INTERNAL_(LPDDE_CHANNEL) GetSysChannel(void)
{ return m_pSysChannel; }
INTERNAL_(LPDDE_CHANNEL) GetDocChannel(void)
{ return m_pDocChannel; }
INTERNAL_(BOOL) AllocDdeChannel(LPDDE_CHANNEL * lpChannel, LPSTR lpszWndClass);
INTERNAL_(BOOL) InitSysConv (void);
INTERNAL_(void) SetTopic (ATOM aTopic);
INTERNAL SendOnDataChange (int iAdvOpt);
INTERNAL OleCallBack (int iAdvOpt,LPDDE_CHANNEL pChannel);
#ifdef _CHICAGO_
//Note:POSTPPC
INTERNAL_(void) Guard()
{
intrDebugOut((DEB_IWARN ,"CDdeObject: %x DelayDelete is set to 'DelayIt'\n", this));
_DelayDelete = DelayIt;
}
INTERNAL_(BOOL) UnGuard()
{
if (_DelayDelete == ReadyToDelete)
{
intrDebugOut((DEB_IWARN ,"CDdeObject: %x DelayDelete it set 'ReadyToDelete'\n", this));
delete this;
intrDebugOut((DEB_IWARN ,"CDdeObject: %x was deleted\n", this));
return TRUE;
}
else
{
intrDebugOut((DEB_IWARN ,"CDdeObject: %x DelayDelete set to 'NoDelay'\n", this));
_DelayDelete = NoDelay;
}
return FALSE;
}
#endif // _CHICAGO_
BOOL m_fDoingSendOnDataChange;
ULONG m_cRefCount;
private:
CDdeObject (IUnknown * pUnkOuter);
~CDdeObject (void);
INTERNAL TermConv (LPDDE_CHANNEL pChannel, BOOL fWait=TRUE);
INTERNAL_(void) DeleteChannel (LPDDE_CHANNEL pChannel);
INTERNAL_(BOOL) LaunchApp (void);
INTERNAL MaybeUnlaunchApp (void);
INTERNAL UnlaunchApp (void);
INTERNAL Execute (LPDDE_CHANNEL pChannel,
HANDLE hdata,
BOOL fStdCloseDoc=FALSE,
BOOL fWait=TRUE,
BOOL fDetectTerminate = TRUE);
INTERNAL Advise(void);
INTERNAL AdviseOn (CLIPFORMAT cfFormat, int iAdvOn);
INTERNAL UnAdviseOn (CLIPFORMAT cfFormat, int iAdvOn);
INTERNAL Poke (ATOM aItem, HANDLE hDdePoke);
INTERNAL PostSysCommand (LPDDE_CHANNEL pChannel,
LPCSTR szCmd,
BOOL bStdNew=FALSE,
BOOL fWait=TRUE);
#ifdef _CHICAGO_
//POSTPPC
INTERNAL_(BOOL) CanMakeOutCall(LPDDE_CHANNEL pChannel);
#endif
INTERNAL WaitForReply (LPDDE_CHANNEL pChannel,
int iAwaitAck,
BOOL fStdCloseDoc = FALSE,
BOOL fDetectTerminate = TRUE);
INTERNAL KeepData (LPDDE_CHANNEL pChannel, HANDLE hDdeData);
INTERNAL ChangeTopic (LPSTR lpszTopic);
INTERNAL_(void) ChangeItem (LPSTR lpszItem);
INTERNAL IsFormatAvailable (LPFORMATETC);
INTERNAL_(BOOL) CanCallBack(LPINT);
INTERNAL RequestData (CLIPFORMAT);
INTERNAL SetTargetDevice (const DVTARGETDEVICE *);
INTERNAL DocumentLevelConnect (LPBINDCTX pbc);
INTERNAL SendOnClose (void);
INTERNAL UpdateAdviseCounts (CLIPFORMAT cf,
int iAdvOn,
signed int cDelta);
INTERNAL DeclareVisibility (BOOL fVisible,
BOOL fCallOnShowIfNec=TRUE);
INTERNAL Save (LPSTORAGE);
INTERNAL Update (BOOL fRequirePresentation);
implementations:
STDUNKDECL(CDdeObject,DdeObject)
STDDEBDECL(CDdeObject,DdeObject)
implement COleObjectImpl : IOleObject
{
public:
COleObjectImpl (CDdeObject * pDdeObject)
{ m_pDdeObject = pDdeObject; }
// *** IUnknown methods ***
STDMETHOD(QueryInterface) ( REFIID riid, LPVOID * ppvObj);
STDMETHOD_(ULONG,AddRef) ();
STDMETHOD_(ULONG,Release) ();
// *** IOleObject methods ***
STDMETHOD(SetClientSite) ( LPOLECLIENTSITE pClientSite);
STDMETHOD(GetClientSite) ( LPOLECLIENTSITE * ppClientSite);
STDMETHOD(SetHostNames) ( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj);
STDMETHOD(Close) ( DWORD reserved);
STDMETHOD(SetMoniker) ( DWORD dwWhichMoniker, LPMONIKER pmk);
STDMETHOD(GetMoniker) ( DWORD dwAssign, DWORD dwWhichMoniker,LPMONIKER * ppmk);
STDMETHOD(InitFromData) ( LPDATAOBJECT pDataObject,BOOL fCreation,DWORD dwReserved);
STDMETHOD(GetClipboardData) ( DWORD dwReserved,LPDATAOBJECT * ppDataObject);
STDMETHOD(DoVerb) ( LONG iVerb,
LPMSG lpmsg,
LPOLECLIENTSITE pActiveSite,
LONG lindex,
HWND hwndParent,
const RECT * lprcPosRect);
STDMETHOD(EnumVerbs) ( IEnumOLEVERB * * ppenumOleVerb);
STDMETHOD(Update) ();
STDMETHOD(IsUpToDate) ();
STDMETHOD(GetUserClassID) ( CLSID * pClsid);
STDMETHOD(GetUserType) ( DWORD dwFormOfType, LPOLESTR * pszUserType);
STDMETHOD(SetExtent) ( DWORD dwDrawAspect, LPSIZEL lpsizel);
STDMETHOD(GetExtent) ( DWORD dwDrawAspect, LPSIZEL lpsizel);
STDMETHOD(Advise)( IAdviseSink * pAdvSink, DWORD * pdwConnection) ;
STDMETHOD(Unadvise) ( DWORD dwConnection);
STDMETHOD(EnumAdvise) ( LPENUMSTATDATA * ppenumAdvise);
STDMETHOD(GetMiscStatus) ( DWORD dwAspect, DWORD * pdwStatus);
STDMETHOD(SetColorScheme) ( LPLOGPALETTE lpLogpal);
private:
CDdeObject * m_pDdeObject;
};
implement CDataObjectImpl : IDataObject
{
public:
CDataObjectImpl (CDdeObject * pDdeObject)
{ m_pDdeObject = pDdeObject; }
// *** IUnknown methods ***
STDMETHOD(QueryInterface) ( REFIID riid, LPVOID * ppvObj);
STDMETHOD_(ULONG,AddRef) () ;
STDMETHOD_(ULONG,Release) ();
STDMETHOD(GetData) ( LPFORMATETC pformatetcIn,LPSTGMEDIUM pmedium );
STDMETHOD(GetDataHere) ( LPFORMATETC pformatetc,LPSTGMEDIUM pmedium );
STDMETHOD(QueryGetData) ( LPFORMATETC pformatetc );
STDMETHOD(GetCanonicalFormatEtc) ( LPFORMATETC pformatetc,LPFORMATETC pformatetcOut);
STDMETHOD(SetData) ( LPFORMATETC pformatetc, STGMEDIUM * pmedium, BOOL fRelease);
STDMETHOD(EnumFormatEtc) ( DWORD dwDirection, LPENUMFORMATETC * ppenumFormatEtc);
STDMETHOD(DAdvise) ( FORMATETC * pFormatetc, DWORD advf, LPADVISESINK pAdvSink, DWORD * pdwConnection) ;
STDMETHOD(DUnadvise) ( DWORD dwConnection) ;
STDMETHOD(EnumDAdvise) ( LPENUMSTATDATA * ppenumAdvise) ;
private:
CDdeObject * m_pDdeObject;
};
implement CPersistStgImpl : IPersistStorage
{
public:
CPersistStgImpl (CDdeObject * pDdeObject)
{ m_pDdeObject = pDdeObject; }
STDMETHOD(QueryInterface) ( REFIID iid, LPVOID * ppvObj);
STDMETHOD_(ULONG,AddRef) ();
STDMETHOD_(ULONG,Release) ();
STDMETHOD(GetClassID) ( LPCLSID pClassID);
STDMETHOD(IsDirty) (void);
STDMETHOD(InitNew) ( LPSTORAGE pstg);
STDMETHOD(Load) ( LPSTORAGE pstg);
STDMETHOD(Save) ( LPSTORAGE pstgSave, BOOL fSameAsLoad);
STDMETHOD(SaveCompleted) ( LPSTORAGE pstgNew);
STDMETHOD(HandsOffStorage) (void);
private:
CDdeObject * m_pDdeObject;
};
implement CProxyManagerImpl : IProxyManager
{
public:
CProxyManagerImpl (CDdeObject * pDdeObject)
{ m_pDdeObject = pDdeObject; }
STDMETHOD(QueryInterface) ( REFIID iid, LPVOID * ppvObj);
STDMETHOD_(ULONG,AddRef) ();
STDMETHOD_(ULONG,Release) ();
STDMETHOD(CreateServer)(REFCLSID rclsid, DWORD clsctx, void *pv);
STDMETHOD_(BOOL, IsConnected)(void);
STDMETHOD(LockConnection)(BOOL fLock, BOOL fLastUnlockReleases);
STDMETHOD_(void, Disconnect)();
STDMETHOD(Connect)(OID oid, REFCLSID rclsid);
STDMETHOD(EstablishIID)(REFIID iid, LPVOID FAR* ppv);
STDMETHOD(CreateServerWithHandler)(REFCLSID rclsid, DWORD clsctx, void *pv,
REFCLSID rclsidHandler, IID iidSrv, void **ppv,
IID iidClnt, void *pClientSiteInterface);
private:
CDdeObject * m_pDdeObject;
};
implement COleItemContainerImpl : IOleItemContainer
{
public:
COleItemContainerImpl (CDdeObject * pDdeObject)
{ m_pDdeObject = pDdeObject; }
STDMETHOD(QueryInterface) ( REFIID iid, LPVOID * ppvObj);
STDMETHOD_(ULONG,AddRef) ();
STDMETHOD_(ULONG,Release) ();
// IParseDisplayName method
STDMETHOD(ParseDisplayName) ( LPBC pbc,
LPOLESTR lpszDisplayName,
ULONG * pchEaten,
LPMONIKER * ppmkOut) ;
// IOleContainer methods
STDMETHOD(EnumObjects) ( DWORD grfFlags,LPENUMUNKNOWN * ppenumUnk);
STDMETHOD(LockContainer) (BOOL fLock);
// IOleItemContainer methods
STDMETHOD(GetObject) ( LPOLESTR lpszItem,
DWORD dwSpeedNeeded,
LPBINDCTX pbc,
REFIID riid,
LPVOID * ppvObject) ;
STDMETHOD(GetObjectStorage) ( LPOLESTR lpszItem,
LPBINDCTX pbc,
REFIID riid,
LPVOID * ppvStorage) ;
STDMETHOD(IsRunning) ( LPOLESTR lpszItem) ;
private:
CDdeObject * m_pDdeObject;
};
DECLARE_NC(CDdeObject, COleObjectImpl)
DECLARE_NC(CDdeObject, CDataObjectImpl)
DECLARE_NC(CDdeObject, CPersistStgImpl)
DECLARE_NC(CDdeObject, CProxyManagerImpl)
DECLARE_NC(CDdeObject, COleItemContainerImpl)
COleObjectImpl m_Ole;
CDataObjectImpl m_Data;
CPersistStgImpl m_PersistStg;
CProxyManagerImpl m_ProxyMgr;
COleItemContainerImpl m_OleItemContainer;
shared_state:
ULONG m_refs;
#ifdef _CHICAGO_
//Note:POSTPPC
DelayDelete _DelayDelete;
#endif // _CHICAGO_
ULONG m_ulObjType;
CLSID m_clsid;
ATOM m_aClass;
ATOM m_aExeName;
ATOM m_aTopic;
ATOM m_aItem;
BOOL m_bRunning;
IUnknown * m_pUnkOuter;
IOleClientSite * m_pOleClientSite;
LPSTORAGE m_pstg;
BOOL m_bInitNew;
BOOL m_bOldSvr;
HANDLE m_hNative;
HANDLE m_hPict;
HANDLE m_hExtra;
CLIPFORMAT m_cfPict;
CLIPFORMAT m_cfExtra;
BOOL m_fDidSendOnClose;
BOOL m_fNoStdCloseDoc;
BOOL m_fDidStdCloseDoc;
BOOL m_fDidStdOpenDoc;
BOOL m_fDidGetObject;
BOOL m_fDidLaunchApp;
BOOL m_fUpdateOnSave;
BOOL m_fGotCloseData;
#ifdef OLE1INTEROP
BOOL m_fOle1interop;
#endif
// Invisible update stuff
ULONG m_cLocks; // PM::LockConnection lock count (init 1)
BOOL m_fVisible; // is server visible (as best we know)?
BOOL m_fWasEverVisible;
BOOL m_fCalledOnShow; // Did we call IOleClientSite::OnShow
CHK m_chk;
DVTARGETDEVICE * m_ptd;
// m_iAdvClose and m_iAdvSave are counts (1 or 2) of the number of formats
// that have advise connections of a given type (Save or Close)
int m_iAdvClose;
int m_iAdvSave;
int m_iAdvChange;
BOOL m_fDidAdvNative;
// Extent info
#ifdef OLD
long m_cxContentExtent;
long m_cyContentExtent;
#endif
// terminate info - only used to detect a premature WM_DDE_TERMINATE
WORD m_wTerminate;
IDataAdviseHolder * m_pDataAdvHolder;
IOleAdviseHolder * m_pOleAdvHolder;
CDdeConnectionTable m_ConnectionTable;
// DDE window related stuff
LPDDE_CHANNEL m_pSysChannel;
LPDDE_CHANNEL m_pDocChannel;
friend INTERNAL DdeBindToObject
(LPCOLESTR szFile,
REFCLSID clsid,
BOOL fPackageLink,
REFIID iid,
LPLPVOID ppv);
friend INTERNAL DdeIsRunning
(CLSID clsid,
LPCOLESTR szFile,
LPBC pbc,
LPMONIKER pmkToLeft,
LPMONIKER pmkNewlyRunning);
#ifdef OLE_DEBUG_EXT
#endif OLE_DEBUG_EXT
};
//
// Note: WM_DDE_TERMINATE
// A state machine is used to delay the executing of a premature WM_DDE_TERMINTE
// message, which is send by some apps instead of WM_DDE_ACK (or alike).
// The code is in WaitForReply() and in OnTerminate()
typedef enum {
Terminate_None = 0, // default state - terminate code is executed
Terminate_Detect = 1, // window proc will NOT execute terminate code
Terminate_Received = 2 // wait loop does not need to run, execute terminate code now
} TERMINATE_DOCUMENT;
INTERNAL_(BOOL) wPostMessageToServer(LPDDE_CHANNEL pChannel,
WORD wMsg,
LONG lParam,
BOOL fFreeOnError);
INTERNAL_(ATOM) wAtomFromCLSID(REFCLSID rclsid);
INTERNAL_(ATOM) wGetExeNameAtom (REFCLSID rclsid);
INTERNAL_(BOOL) wIsWindowValid (HWND hwnd);
INTERNAL_(void) wFreeData (HANDLE hData, CLIPFORMAT cfFormat,
BOOL fFreeNonGdiHandle=TRUE);
INTERNAL_(BOOL) wInitiate (LPDDE_CHANNEL pChannel, ATOM aLow, ATOM aHigh);
INTERNAL wScanItemOptions (ATOM aItem, int * lpoptions);
INTERNAL_(BOOL) wClearWaitState (LPDDE_CHANNEL pChannel);
INTERNAL_(HANDLE) wStdCloseDocumentHandle (void);
INTERNAL_(ATOM) wExtendAtom (ATOM aIitem, int iAdvOn);
INTERNAL_(int) wAtomLen (ATOM atom);
INTERNAL_(int) wAtomLenA (ATOM atom);
INTERNAL_(LPDDE_CHANNEL) wAllocDdeChannel(void);
INTERNAL_(HANDLE) wHandleFromDdeData(HANDLE hDdeData);
INTERNAL_(BOOL) wIsOldServer (ATOM aClass);
INTERNAL_(LPSTR) wAllocDdePokeBlock (DWORD dwSize, CLIPFORMAT cfFormat,LPHANDLE phDdePoke);
INTERNAL_(void) wFreePokeData (LPDDE_CHANNEL pChannel, BOOL fMSDrawBug);
INTERNAL_(HANDLE) wPreparePokeBlock (HANDLE hData, CLIPFORMAT cfFormat,
ATOM aClass, BOOL bOldSvr);
INTERNAL_(HANDLE) wNewHandle (LPSTR lpstr, DWORD cb);
INTERNAL wDupData (LPHANDLE ph, HANDLE h, CLIPFORMAT cf);
INTERNAL wHandleCopy (HANDLE hDst, HANDLE hSrc);
INTERNAL wGetRequestResponse (LPDDE_CHANNEL pChannel, CLIPFORMAT cf, ATOM aItem);
INTERNAL wGetItemFromClipboard (ATOM * paItem);
INTERNAL GetDefaultIcon (REFCLSID clsidIn, LPCOLESTR szFile, HANDLE * phmfp);
INTERNAL_(BOOL) wTerminateIsComing (LPDDE_CHANNEL);
INTERNAL wTimedGetMessage (LPMSG pmsg, HWND hwnd, WORD wFirst, WORD wLast);
INTERNAL_(ATOM) wGlobalAddAtom(LPCOLESTR sz);
INTERNAL_(ATOM) wGlobalAddAtomA(LPCSTR sz);
INTERNAL wVerifyFormatEtc (LPFORMATETC pformatetc);
INTERNAL wNormalize (LPFORMATETC pfetc, LPFORMATETC pfetcOut);
INTERNAL wTransferHandle (LPHANDLE phDst, LPHANDLE phSrc, CLIPFORMAT cf);
INTERNAL wClassesMatch (REFCLSID clsidIn, LPOLESTR szFile);
#if DBG == 1
INTERNAL_(BOOL) wIsValidHandle (HANDLE h, CLIPFORMAT cf);
INTERNAL_(BOOL) wIsValidAtom (ATOM a);
#endif
const char achStdCloseDocument[]="[StdCloseDocument]";
const char achStdOpenDocument[]="StdOpenDocument";
const char achStdExit[]="StdExit";
const char achStdNewDocument[]="StdNewDocument";
const char achStdEditDocument[]="StdEditDocument";
#endif // ddeproxy.h
