> 1 /***********************************************************************\ > 2 * ddeml.d * > 3 * * > 4 * Windows API header module * > 5 * * > 6 * Translated from MinGW Windows headers * > 7 * by Stewart Gordon * > 8 * * > 9 * Placed into public domain * > 10 \***********************************************************************/ 1 module win32.ddeml; 11 module win32.ddeml; > 12 pragma(lib, "user32.lib"); 2 | 13 3 // Translated from Microsoft Platform SDK August 2001 Edition < 4 // by Y.Tomino | 14 private import win32.basetsd, win32.windef, win32.winnt; 5 | 15 6 import win32.windef; | 16 enum : int { > 17 CP_WINANSI = 1004, > 18 CP_WINUNICODE = 1200 7 | 19 } 8 // #ifndef _INC_DDEMLH < > 20 > 21 enum : UINT { > 22 XTYPF_NOBLOCK = 2, > 23 XTYPF_NODATA = 4, > 24 XTYPF_ACKREQ = 8 > 25 } > 26 > 27 enum : UINT { > 28 XCLASS_MASK = 0xFC00, > 29 XCLASS_BOOL = 0x1000, > 30 XCLASS_DATA = 0x2000, > 31 XCLASS_FLAGS = 0x4000, > 32 XCLASS_NOTIFICATION = 0x8000 > 33 } > 34 > 35 enum : UINT { > 36 XST_NULL, > 37 XST_INCOMPLETE, > 38 XST_CONNECTED, > 39 XST_INIT1, > 40 XST_INIT2, > 41 XST_REQSENT, > 42 XST_DATARCVD, > 43 XST_POKESENT, > 44 XST_POKEACKRCVD, > 45 XST_EXECSENT, > 46 XST_EXECACKRCVD, > 47 XST_ADVSENT, > 48 XST_UNADVSENT, > 49 XST_ADVACKRCVD, > 50 XST_UNADVACKRCVD, > 51 XST_ADVDATASENT, > 52 XST_ADVDATAACKRCVD // = 16 > 53 } > 54 > 55 enum : UINT { > 56 XTYP_ERROR = XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 57 XTYP_ADVDATA = 0x0010 | XCLASS_FLAGS, > 58 XTYP_ADVREQ = 0x0020 | XCLASS_DATA | XTYPF_NOBLOCK, > 59 XTYP_ADVSTART = 0x0030 | XCLASS_BOOL, > 60 XTYP_ADVSTOP = 0x0040 | XCLASS_NOTIFICATION, > 61 XTYP_EXECUTE = 0x0050 | XCLASS_FLAGS, > 62 XTYP_CONNECT = 0x0060 | XCLASS_BOOL | XTYPF_NOBLOCK, > 63 XTYP_CONNECT_CONFIRM = 0x0070 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 64 XTYP_XACT_COMPLETE = 0x0080 | XCLASS_NOTIFICATION, > 65 XTYP_POKE = 0x0090 | XCLASS_FLAGS, > 66 XTYP_REGISTER = 0x00A0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 67 XTYP_REQUEST = 0x00B0 | XCLASS_DATA, > 68 XTYP_DISCONNECT = 0x00C0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 69 XTYP_UNREGISTER = 0x00D0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 70 XTYP_WILDCONNECT = 0x00E0 | XCLASS_DATA | XTYPF_NOBLOCK, > 71 XTYP_MONITOR = 0X00F0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK, > 72 XTYP_MASK = 0x00F0, > 73 XTYP_SHIFT = 4 > 74 } > 75 > 76 /+ > 77 #define TIMEOUT_ASYNC 0xFFFFFFFF > 78 #define QID_SYNC 0xFFFFFFFF > 79 +/ > 80 > 81 enum : UINT { > 82 ST_CONNECTED = 1, > 83 ST_ADVISE = 2, > 84 ST_ISLOCAL = 4, > 85 ST_BLOCKED = 8, > 86 ST_CLIENT = 16, > 87 ST_TERMINATED = 32, > 88 ST_INLIST = 64, > 89 ST_BLOCKNEXT = 128, > 90 ST_ISSELF = 256 > 91 } > 92 > 93 /+ > 94 #define CADV_LATEACK 0xFFFF > 95 +/ > 96 > 97 enum : UINT { > 98 DMLERR_NO_ERROR = 0, > 99 DMLERR_FIRST = 0x4000, > 100 DMLERR_ADVACKTIMEOUT = DMLERR_FIRST, > 101 DMLERR_BUSY, > 102 DMLERR_DATAACKTIMEOUT, > 103 DMLERR_DLL_NOT_INITIALIZED, > 104 DMLERR_DLL_USAGE, > 105 DMLERR_EXECACKTIMEOUT, > 106 DMLERR_INVALIDPARAMETER, > 107 DMLERR_LOW_MEMORY, > 108 DMLERR_MEMORY_ERROR, > 109 DMLERR_NOTPROCESSED, > 110 DMLERR_NO_CONV_ESTABLISHED, > 111 DMLERR_POKEACKTIMEOUT, > 112 DMLERR_POSTMSG_FAILED, > 113 DMLERR_REENTRANCY, > 114 DMLERR_SERVER_DIED, > 115 DMLERR_SYS_ERROR, > 116 DMLERR_UNADVACKTIMEOUT, > 117 DMLERR_UNFOUND_QUEUE_ID, // = 0x4011 > 118 DMLERR_LAST = DMLERR_UNFOUND_QUEUE_ID > 119 } > 120 > 121 /+ 9 // #define _INC_DDEMLH | 122 #define DDE_FACK 0x8000 > 123 #define DDE_FBUSY 0x4000 > 124 #define DDE_FDEFERUPD 0x4000 > 125 #define DDE_FACKREQ 0x8000 > 126 #define DDE_FRELEASE 0x2000 > 127 #define DDE_FREQUESTED 0x1000 > 128 #define DDE_FAPPSTATUS 0x00ff > 129 #define DDE_FNOTPROCESSED 0 > 130 #define DDE_FACKRESERVED (~(DDE_FACK|DDE_FBUSY|DDE_FAPPSTATUS)) > 131 #define DDE_FADVRESERVED (~(DDE_FACKREQ|DDE_FDEFERUPD)) > 132 #define DDE_FDATRESERVED (~(DDE_FACKREQ|DDE_FRELEASE|DDE_FREQUESTED)) > 133 #define DDE_FPOKRESERVED (~DDE_FRELEASE) > 134 #define MSGF_DDEMGR 0x8001 > 135 #define CBR_BLOCK ((HDDEDATA)0xffffffff) > 136 +/ 10 | 137 11 // #ifdef __cplusplus < 12 // extern "C" { < 13 // #endif /* __cplusplus */ < > 138 const DWORD > 139 APPCLASS_STANDARD = 0, > 140 APPCLASS_MONITOR = 0x00000001, > 141 APPCLASS_MASK = 0x0000000F, > 142 APPCMD_CLIENTONLY = 0x00000010, > 143 APPCMD_FILTERINITS = 0x00000020, > 144 APPCMD_MASK = 0x00000FF0, > 145 CBF_FAIL_SELFCONNECTIONS = 0x00001000, > 146 CBF_FAIL_CONNECTIONS = 0x00002000, > 147 CBF_FAIL_ADVISES = 0x00004000, > 148 CBF_FAIL_EXECUTES = 0x00008000, > 149 CBF_FAIL_POKES = 0x00010000, > 150 CBF_FAIL_REQUESTS = 0x00020000, > 151 CBF_FAIL_ALLSVRXACTIONS = 0x0003f000, > 152 CBF_SKIP_CONNECT_CONFIRMS = 0x00040000, > 153 CBF_SKIP_REGISTRATIONS = 0x00080000, > 154 CBF_SKIP_UNREGISTRATIONS = 0x00100000, > 155 CBF_SKIP_DISCONNECTS = 0x00200000, > 156 CBF_SKIP_ALLNOTIFICATIONS = 0x003c0000, > 157 MF_HSZ_INFO = 0x01000000, > 158 MF_SENDMSGS = 0x02000000, > 159 MF_POSTMSGS = 0x04000000, > 160 MF_CALLBACKS = 0x08000000, > 161 MF_ERRORS = 0x10000000, > 162 MF_LINKS = 0x20000000, > 163 MF_CONV = 0x40000000, > 164 MF_MASK = 0xFF000000; 14 | 165 15 alias void* HCONVLIST; < 16 alias void* HCONV; < 17 alias void* HSZ; < > 166 enum : UINT { > 167 EC_ENABLEALL = 0, > 168 EC_ENABLEONE = ST_BLOCKNEXT, > 169 EC_DISABLE = ST_BLOCKED, > 170 EC_QUERYWAITING = 2 > 171 } > 172 > 173 enum : UINT { > 174 DNS_REGISTER = 1, > 175 DNS_UNREGISTER = 2, > 176 DNS_FILTERON = 4, > 177 DNS_FILTEROFF = 8 > 178 } > 179 > 180 /+ > 181 #define HDATA_APPOWNED 1 > 182 #define MAX_MONITORS 4 > 183 +/ > 184 > 185 enum : int { > 186 MH_CREATE = 1, > 187 MH_KEEP = 2, > 188 MH_DELETE = 3, > 189 MH_CLEANUP = 4 > 190 } > 191 > 192 alias HANDLE HCONVLIST, HCONV, HSZ, HDDEDATA; > 193 18 alias void* HDDEDATA; | 194 extern (Windows) alias HDDEDATA 19 // #define EXPENTRY CALLBACK < > 195 function(UINT, UINT, HCONV, HSZ, HSZ, HDDEDATA, DWORD, DWORD) PFNCALLBACK; 20 | 196 21 struct tagHSZPAIR { | 197 struct HSZPAIR { 22 HSZ hszSvc; | 198 HSZ hszSvc; 23 HSZ hszTopic; | 199 HSZ hszTopic; 24 } | 200 } 25 alias tagHSZPAIR HSZPAIR; < 26 < 27 alias HSZPAIR* PHSZPAIR; 201 alias HSZPAIR* PHSZPAIR; 28 202 29 struct tagCONVCONTEXT { | 203 struct CONVCONTEXT { 30 UINT cb; | 204 UINT cb = CONVCONTEXT.sizeof; 31 UINT wFlags; | 205 UINT wFlags; 32 UINT wCountryID; | 206 UINT wCountryID; 33 int iCodePage; | 207 int iCodePage; 34 DWORD dwLangID; | 208 DWORD dwLangID; 35 DWORD dwSecurity; | 209 DWORD dwSecurity; 36 SECURITY_QUALITY_OF_SERVICE qos; | 210 SECURITY_QUALITY_OF_SERVICE qos; 37 } 211 } 38 alias tagCONVCONTEXT CONVCONTEXT; < 39 < 40 alias CONVCONTEXT* PCONVCONTEXT; 212 alias CONVCONTEXT* PCONVCONTEXT; 41 213 42 struct tagCONVINFO { | 214 struct CONVINFO { 43 DWORD cb; | 215 DWORD cb = CONVINFO.sizeof; 44 DWORD_PTR hUser; | 216 DWORD hUser; 45 HCONV hConvPartner; | 217 HCONV hConvPartner; 46 HSZ hszSvcPartner; | 218 HSZ hszSvcPartner; 47 HSZ hszServiceReq; | 219 HSZ hszServiceReq; 48 HSZ hszTopic; | 220 HSZ hszTopic; 49 HSZ hszItem; | 221 HSZ hszItem; 50 UINT wFmt; | 222 UINT wFmt; 51 UINT wType; | 223 UINT wType; 52 UINT wStatus; | 224 UINT wStatus; 53 UINT wConvst; | 225 UINT wConvst; 54 UINT wLastError; | 226 UINT wLastError; 55 HCONVLIST hConvList; | 227 HCONVLIST hConvList; 56 CONVCONTEXT ConvCtxt; | 228 CONVCONTEXT ConvCtxt; 57 HWND hwnd; | 229 HWND hwnd; 58 HWND hwndPartner; | 230 HWND hwndPartner; 59 } 231 } 60 alias tagCONVINFO CONVINFO; < 61 < 62 alias CONVINFO* PCONVINFO; 232 alias CONVINFO* PCONVINFO; 63 233 64 enum : uint { XST_NULL = 0 } | 234 struct DDEML_MSG_HOOK_DATA { 65 enum : uint { XST_INCOMPLETE = 1 } | 235 UINT uiLo; 66 enum : uint { XST_CONNECTED = 2 } | 236 UINT uiHi; 67 enum : uint { XST_INIT1 = 3 } | 237 DWORD cbData; 68 enum : uint { XST_INIT2 = 4 } | 238 DWORD[8] Data; 69 enum : uint { XST_REQSENT = 5 } < 70 enum : uint { XST_DATARCVD = 6 } < > 239 } > 240 71 enum : uint { XST_POKESENT = 7 } | 241 struct MONHSZSTRUCT { 72 enum : uint { XST_POKEACKRCVD = 8 } | 242 UINT cb = MONHSZSTRUCT.sizeof; 73 enum : uint { XST_EXECSENT = 9 } | 243 int fsAction; 74 enum : uint { XST_EXECACKRCVD = 10 } | 244 DWORD dwTime; 75 enum : uint { XST_ADVSENT = 11 } | 245 HSZ hsz; 76 enum : uint { XST_UNADVSENT = 12 } | 246 HANDLE hTask; 77 enum : uint { XST_ADVACKRCVD = 13 } | 247 TCHAR[1] _str; 78 enum : uint { XST_UNADVACKRCVD = 14 } < > 248 79 enum : uint { XST_ADVDATASENT = 15 } | 249 TCHAR* str() { return _str.ptr; } 80 enum : uint { XST_ADVDATAACKRCVD = 16 } < > 250 } > 251 alias MONHSZSTRUCT* PMONHSZSTRUCT; 81 252 82 enum : uint { CADV_LATEACK = 0xFFFF } | 253 struct MONLINKSTRUCT { > 254 UINT cb = MONLINKSTRUCT.sizeof; > 255 DWORD dwTime; > 256 HANDLE hTask; > 257 BOOL fEstablished; > 258 BOOL fNoData; > 259 HSZ hszSvc; > 260 HSZ hszTopic; > 261 HSZ hszItem; > 262 UINT wFmt; > 263 BOOL fServer; > 264 HCONV hConvServer; > 265 HCONV hConvClient; > 266 } > 267 alias MONLINKSTRUCT* PMONLINKSTRUCT; 83 268 84 enum : uint { ST_CONNECTED = 0x0001 } | 269 struct MONCONVSTRUCT { 85 enum : uint { ST_ADVISE = 0x0002 } | 270 UINT cb = MONCONVSTRUCT.sizeof; 86 enum : uint { ST_ISLOCAL = 0x0004 } | 271 BOOL fConnect; 87 enum : uint { ST_BLOCKED = 0x0008 } | 272 DWORD dwTime; 88 enum : uint { ST_CLIENT = 0x0010 } | 273 HANDLE hTask; 89 enum : uint { ST_TERMINATED = 0x0020 } | 274 HSZ hszSvc; 90 enum : uint { ST_INLIST = 0x0040 } | 275 HSZ hszTopic; 91 enum : uint { ST_BLOCKNEXT = 0x0080 } | 276 HCONV hConvClient; 92 enum : uint { ST_ISSELF = 0x0100 } | 277 HCONV hConvServer; 93 | 278 } 94 enum : uint { DDE_FACK = 0x8000 } | 279 alias MONCONVSTRUCT* PMONCONVSTRUCT; 95 enum : uint { DDE_FBUSY = 0x4000 } < 96 enum : uint { DDE_FDEFERUPD = 0x4000 } < 97 enum : uint { DDE_FACKREQ = 0x8000 } < 98 enum : uint { DDE_FRELEASE = 0x2000 } < 99 enum : uint { DDE_FREQUESTED = 0x1000 } < 100 enum : uint { DDE_FAPPSTATUS = 0x00ff } < 101 enum : uint { DDE_FNOTPROCESSED = 0x0000 } < 102 280 103 const uint DDE_FACKRESERVED = ~(DDE_FACK | DDE_FBUSY | DDE_FAPPSTATUS); | 281 struct MONCBSTRUCT { 104 const uint DDE_FADVRESERVED = ~(DDE_FACKREQ | DDE_FDEFERUPD); | 282 UINT cb = MONCBSTRUCT.sizeof; 105 const uint DDE_FDATRESERVED = ~(DDE_FACKREQ | DDE_FRELEASE | DDE_FREQUESTED); | 283 DWORD dwTime; 106 const uint DDE_FPOKRESERVED = ~(DDE_FRELEASE); | 284 HANDLE hTask; 107 < > 285 DWORD dwRet; 108 enum : uint { MSGF_DDEMGR = 0x8001 } | 286 UINT wType; 109 < > 287 UINT wFmt; 110 enum : uint { CP_WINANSI = 1004 } | 288 HCONV hConv; 111 enum : uint { CP_WINUNICODE = 1200 } | 289 HSZ hsz1; 112 // #ifdef UNICODE | 290 HSZ hsz2; 113 alias CP_WINUNICODE CP_WINNEUTRAL; | 291 HDDEDATA hData; 114 // #else // !UNICODE | 292 ULONG_PTR dwData1; 115 // #... | 293 ULONG_PTR dwData2; 116 // #endif // !UNICODE | 294 CONVCONTEXT cc; 117 < > 295 DWORD cbData; 118 enum : uint { XTYPF_NOBLOCK = 0x0002 } | 296 DWORD[8] Data; 119 enum : uint { XTYPF_NODATA = 0x0004 } < 120 enum : uint { XTYPF_ACKREQ = 0x0008 } < 121 | 297 } 122 enum : uint { XCLASS_MASK = 0xFC00 } < 123 enum : uint { XCLASS_BOOL = 0x1000 } < 124 enum : uint { XCLASS_DATA = 0x2000 } < 125 enum : uint { XCLASS_FLAGS = 0x4000 } < 126 enum : uint { XCLASS_NOTIFICATION = 0x8000 } < > 298 alias MONCBSTRUCT* PMONCBSTRUCT; 127 299 128 const uint XTYP_ERROR = 0x0000 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK ; | 300 struct MONERRSTRUCT { 129 const uint XTYP_ADVDATA = 0x0010 | XCLASS_FLAGS ; | 301 UINT cb = MONERRSTRUCT.sizeof; 130 const uint XTYP_ADVREQ = 0x0020 | XCLASS_DATA | XTYPF_NOBLOCK ; | 302 UINT wLastError; 131 const uint XTYP_ADVSTART = 0x0030 | XCLASS_BOOL ; | 303 DWORD dwTime; 132 const uint XTYP_ADVSTOP = 0x0040 | XCLASS_NOTIFICATION; | 304 HANDLE hTask; 133 const uint XTYP_EXECUTE = 0x0050 | XCLASS_FLAGS ; < 134 const uint XTYP_CONNECT = 0x0060 | XCLASS_BOOL | XTYPF_NOBLOCK; < 135 const uint XTYP_CONNECT_CONFIRM = 0x0070 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK; < 136 const uint XTYP_XACT_COMPLETE = 0x0080 | XCLASS_NOTIFICATION ; < 137 const uint XTYP_POKE = 0x0090 | XCLASS_FLAGS ; < 138 const uint XTYP_REGISTER = 0x00A0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK; < 139 const uint XTYP_REQUEST = 0x00B0 | XCLASS_DATA ; < 140 const uint XTYP_DISCONNECT = 0x00C0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK; < 141 const uint XTYP_UNREGISTER = 0x00D0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK; < 142 const uint XTYP_WILDCONNECT = 0x00E0 | XCLASS_DATA | XTYPF_NOBLOCK; < 143 | 305 } 144 enum : uint { XTYP_MASK = 0x00F0 } < 145 enum : uint { XTYP_SHIFT = 4 } < 146 < 147 enum : uint { TIMEOUT_ASYNC = 0xFFFFFFFF } < 148 < 149 enum : uint { QID_SYNC = 0xFFFFFFFF } < 150 < 151 // #ifdef UNICODE < 152 const wchar[] SZDDESYS_TOPIC = "System"; < 153 const wchar[] SZDDESYS_ITEM_TOPICS = "Topics"; < 154 const wchar[] SZDDESYS_ITEM_SYSITEMS = "SysItems"; < 155 const wchar[] SZDDESYS_ITEM_RTNMSG = "ReturnMessage"; < 156 const wchar[] SZDDESYS_ITEM_STATUS = "Status"; < 157 const wchar[] SZDDESYS_ITEM_FORMATS = "Formats"; < 158 const wchar[] SZDDESYS_ITEM_HELP = "Help"; < 159 const wchar[] SZDDE_ITEM_ITEMLIST = "TopicItemList"; < 160 // #else < 161 // #... < 162 // #... < 163 // #... < 164 // #... < 165 // #... < 166 // #... < 167 // #... < 168 // #... < 169 // #endif < 170 < 171 // typedef HDDEDATA CALLBACK FNCALLBACK(UINT wType, UINT wFmt, HCONV hConv, HSZ < 172 extern(Windows) alias HDDEDATA function(UINT wType, UINT wFmt, HCONV hConv, HSZ < 173 < 174 const HDDEDATA CBR_BLOCK = cast(HDDEDATA)-1; < 175 < 176 extern(Windows) export UINT DdeInitializeA( LPDWORD pidInst, PFNCALLBACK pfnC < 177 DWORD afCmd, DWORD ulRes); < 178 extern(Windows) export UINT DdeInitializeW( LPDWORD pidInst, PFNCALLBACK pfnC < 179 DWORD afCmd, DWORD ulRes); < 180 // #ifdef UNICODE < 181 alias DdeInitializeW DdeInitialize; < 182 // #else < 183 // #... < 184 // #endif // !UNICODE < 185 < 186 enum : uint { CBF_FAIL_SELFCONNECTIONS = 0x00001000 } < 187 enum : uint { CBF_FAIL_CONNECTIONS = 0x00002000 } < 188 enum : uint { CBF_FAIL_ADVISES = 0x00004000 } < 189 enum : uint { CBF_FAIL_EXECUTES = 0x00008000 } < 190 enum : uint { CBF_FAIL_POKES = 0x00010000 } < 191 enum : uint { CBF_FAIL_REQUESTS = 0x00020000 } < 192 enum : uint { CBF_FAIL_ALLSVRXACTIONS = 0x0003f000 } < 193 < 194 enum : uint { CBF_SKIP_CONNECT_CONFIRMS = 0x00040000 } < 195 enum : uint { CBF_SKIP_REGISTRATIONS = 0x00080000 } < 196 enum : uint { CBF_SKIP_UNREGISTRATIONS = 0x00100000 } < 197 enum : uint { CBF_SKIP_DISCONNECTS = 0x00200000 } < 198 enum : uint { CBF_SKIP_ALLNOTIFICATIONS = 0x003c0000 } < 199 < 200 enum : uint { APPCMD_CLIENTONLY = 0x00000010 } < 201 enum : uint { APPCMD_FILTERINITS = 0x00000020 } < 202 enum : uint { APPCMD_MASK = 0x00000FF0 } < 203 < 204 enum : uint { APPCLASS_STANDARD = 0x00000000 } < 205 enum : uint { APPCLASS_MASK = 0x0000000F } < > 306 alias MONERRSTRUCT* PMONERRSTRUCT; 206 307 207 extern(Windows) export BOOL DdeUninitialize( DWORD idInst); | 308 struct MONMSGSTRUCT { 208 < > 309 UINT cb = MONMSGSTRUCT.sizeof; 209 extern(Windows) export HCONVLIST DdeConnectList( DWORD idInst, HSZ hszService, | 310 HWND hwndTo; 210 HCONVLIST hConvList, PCONVCONTEXT pCC); | 311 DWORD dwTime; 211 extern(Windows) export HCONV DdeQueryNextServer( HCONVLIST hConvList, HCONV hC | 312 HANDLE hTask; 212 extern(Windows) export BOOL DdeDisconnectList( HCONVLIST hConvList); | 313 UINT wMsg; 213 < > 314 WPARAM wParam; 214 extern(Windows) export HCONV DdeConnect( DWORD idInst, HSZ hszService, HSZ hs | 315 LPARAM lParam; 215 PCONVCONTEXT pCC); | 316 DDEML_MSG_HOOK_DATA dmhd; 216 extern(Windows) export BOOL DdeDisconnect( HCONV hConv); < 217 extern(Windows) export HCONV DdeReconnect( HCONV hConv); < 218 extern(Windows) export UINT DdeQueryConvInfo( HCONV hConv, DWORD idTransaction < 219 extern(Windows) export BOOL DdeSetUserHandle( HCONV hConv, DWORD id, DWORD_PT < 220 extern(Windows) export BOOL DdeAbandonTransaction( DWORD idInst, HCONV hConv, < 221 | 317 } 222 extern(Windows) export BOOL DdePostAdvise( DWORD idInst, HSZ hszTopic, HSZ hs < 223 extern(Windows) export BOOL DdeEnableCallback( DWORD idInst, HCONV hConv, UIN < 224 extern(Windows) export BOOL DdeImpersonateClient( HCONV hConv); < 225 < 226 enum : uint { EC_ENABLEALL = 0 } < 227 alias ST_BLOCKNEXT EC_ENABLEONE; < 228 alias ST_BLOCKED EC_DISABLE; < 229 enum : uint { EC_QUERYWAITING = 2 } < 230 < 231 extern(Windows) export HDDEDATA DdeNameService( DWORD idInst, HSZ hsz1, HSZ h < 232 < 233 enum : uint { DNS_REGISTER = 0x0001 } < 234 enum : uint { DNS_UNREGISTER = 0x0002 } < 235 enum : uint { DNS_FILTERON = 0x0004 } < 236 enum : uint { DNS_FILTEROFF = 0x0008 } < 237 < 238 extern(Windows) export HDDEDATA DdeClientTransaction( LPBYTE pData, DWORD cbDa < 239 HCONV hConv, HSZ hszItem, UINT wFmt, UINT wType, < 240 DWORD dwTimeout, LPDWORD pdwResult); < 241 < 242 extern(Windows) export HDDEDATA DdeCreateDataHandle( DWORD idInst, LPBYTE pSrc < 243 DWORD cbOff, HSZ hszItem, UINT wFmt, UINT afCmd); < 244 extern(Windows) export HDDEDATA DdeAddData( HDDEDATA hData, LPBYTE pSrc, DWOR < 245 extern(Windows) export DWORD DdeGetData( HDDEDATA hData, LPBYTE pDst, DWORD c < 246 extern(Windows) export LPBYTE DdeAccessData( HDDEDATA hData, LPDWORD pcbDataSi < 247 extern(Windows) export BOOL DdeUnaccessData( HDDEDATA hData); < 248 extern(Windows) export BOOL DdeFreeDataHandle( HDDEDATA hData); < 249 < 250 enum : uint { HDATA_APPOWNED = 0x0001 } < 251 < 252 extern(Windows) export UINT DdeGetLastError( DWORD idInst); < 253 < 254 enum : uint { DMLERR_NO_ERROR = 0 } < 255 < 256 enum : uint { DMLERR_FIRST = 0x4000 } < 257 < 258 enum : uint { DMLERR_ADVACKTIMEOUT = 0x4000 } < 259 enum : uint { DMLERR_BUSY = 0x4001 } < 260 enum : uint { DMLERR_DATAACKTIMEOUT = 0x4002 } < 261 enum : uint { DMLERR_DLL_NOT_INITIALIZED = 0x4003 } < 262 enum : uint { DMLERR_DLL_USAGE = 0x4004 } < 263 enum : uint { DMLERR_EXECACKTIMEOUT = 0x4005 } < 264 enum : uint { DMLERR_INVALIDPARAMETER = 0x4006 } < 265 enum : uint { DMLERR_LOW_MEMORY = 0x4007 } < 266 enum : uint { DMLERR_MEMORY_ERROR = 0x4008 } < 267 enum : uint { DMLERR_NOTPROCESSED = 0x4009 } < 268 enum : uint { DMLERR_NO_CONV_ESTABLISHED = 0x400a } < 269 enum : uint { DMLERR_POKEACKTIMEOUT = 0x400b } < 270 enum : uint { DMLERR_POSTMSG_FAILED = 0x400c } < 271 enum : uint { DMLERR_REENTRANCY = 0x400d } < 272 enum : uint { DMLERR_SERVER_DIED = 0x400e } < 273 enum : uint { DMLERR_SYS_ERROR = 0x400f } < 274 enum : uint { DMLERR_UNADVACKTIMEOUT = 0x4010 } < 275 enum : uint { DMLERR_UNFOUND_QUEUE_ID = 0x4011 } < 276 < 277 enum : uint { DMLERR_LAST = 0x4011 } < > 318 alias MONMSGSTRUCT* PMONMSGSTRUCT; 278 319 279 extern(Windows) export HSZ DdeCreateStringHandleA( DWORD idInst, LPCSTR psz, | 320 extern (Windows) { > 321 BOOL DdeAbandonTransaction(DWORD, HCONV, DWORD); > 322 PBYTE DdeAccessData(HDDEDATA, PDWORD); > 323 HDDEDATA DdeAddData(HDDEDATA, PBYTE, DWORD, DWORD); > 324 HDDEDATA DdeClientTransaction(PBYTE, DWORD, HCONV, HSZ, UINT, UINT, > 325 DWORD, PDWORD); > 326 int DdeCmpStringHandles(HSZ, HSZ); > 327 HCONV DdeConnect(DWORD, HSZ, HSZ, PCONVCONTEXT); > 328 HCONVLIST DdeConnectList(DWORD, HSZ, HSZ, HCONVLIST, PCONVCONTEXT); > 329 HDDEDATA DdeCreateDataHandle(DWORD, PBYTE, DWORD, DWORD, HSZ, UINT, > 330 UINT); 280 extern(Windows) export HSZ DdeCreateStringHandleW( DWORD idInst, LPCWSTR psz, | 331 HSZ DdeCreateStringHandleA(DWORD, LPSTR, int); 281 // #ifdef UNICODE < 282 alias DdeCreateStringHandleW DdeCreateStringHandle; | 332 HSZ DdeCreateStringHandleW(DWORD, LPWSTR, int); 283 // #else < 284 // #... < 285 // #endif // !UNICODE < 286 extern(Windows) export DWORD DdeQueryStringA( DWORD idInst, HSZ hsz, LPSTR p < 287 extern(Windows) export DWORD DdeQueryStringW( DWORD idInst, HSZ hsz, LPWSTR < 288 // #ifdef UNICODE < 289 alias DdeQueryStringW DdeQueryString; < 290 // #else < 291 // #... < 292 // #endif // !UNICODE | 333 BOOL DdeDisconnect(HCONV); > 334 BOOL DdeDisconnectList(HCONVLIST); > 335 BOOL DdeEnableCallback(DWORD, HCONV, UINT); > 336 BOOL DdeFreeDataHandle(HDDEDATA); 293 extern(Windows) export BOOL DdeFreeStringHandle( DWORD idInst, HSZ hsz); | 337 BOOL DdeFreeStringHandle(DWORD, HSZ); 294 extern(Windows) export BOOL DdeKeepStringHandle( DWORD idInst, HSZ hsz); < 295 extern(Windows) export int DdeCmpStringHandles( HSZ hsz1, HSZ hsz2); < 296 < 297 // #ifndef NODDEMLSPY | 338 DWORD DdeGetData(HDDEDATA, PBYTE, DWORD, DWORD); 298 < > 339 UINT DdeGetLastError(DWORD); 299 struct tagDDEML_MSG_HOOK_DATA { | 340 BOOL DdeImpersonateClient(HCONV); 300 UINT_PTR uiLo; | 341 UINT DdeInitializeA(PDWORD, PFNCALLBACK, DWORD, DWORD); 301 UINT_PTR uiHi; | 342 UINT DdeInitializeW(PDWORD, PFNCALLBACK, DWORD, DWORD); 302 DWORD cbData; | 343 BOOL DdeKeepStringHandle(DWORD, HSZ); 303 DWORD Data[8]; | 344 HDDEDATA DdeNameService(DWORD, HSZ, HSZ, UINT); > 345 BOOL DdePostAdvise(DWORD, HSZ, HSZ); > 346 UINT DdeQueryConvInfo(HCONV, DWORD, PCONVINFO); > 347 HCONV DdeQueryNextServer(HCONVLIST, HCONV); > 348 DWORD DdeQueryStringA(DWORD, HSZ, LPSTR, DWORD, int); > 349 DWORD DdeQueryStringW(DWORD, HSZ, LPWSTR, DWORD, int); > 350 HCONV DdeReconnect(HCONV); > 351 BOOL DdeSetUserHandle(HCONV, DWORD, DWORD); > 352 BOOL DdeUnaccessData(HDDEDATA); > 353 BOOL DdeUninitialize(DWORD); 304 } 354 } 305 alias tagDDEML_MSG_HOOK_DATA DDEML_MSG_HOOK_DATA; < 306 alias tagDDEML_MSG_HOOK_DATA* PDDEML_MSG_HOOK_DATA; < 307 355 308 struct tagMONMSGSTRUCT { | 356 const TCHAR[] 309 UINT cb; | 357 SZDDESYS_TOPIC = "System", 310 HWND hwndTo; | 358 SZDDESYS_ITEM_TOPICS = "Topics", 311 DWORD dwTime; | 359 SZDDESYS_ITEM_SYSITEMS = "SysItems", 312 HANDLE hTask; | 360 SZDDESYS_ITEM_RTNMSG = "ReturnMessage", 313 UINT wMsg; | 361 SZDDESYS_ITEM_STATUS = "Status", 314 WPARAM wParam; | 362 SZDDESYS_ITEM_FORMATS = "Formats", 315 LPARAM lParam; | 363 SZDDESYS_ITEM_HELP = "Help", 316 DDEML_MSG_HOOK_DATA dmhd; | 364 SZDDE_ITEM_ITEMLIST = "TopicItemList"; 317 } < 318 alias tagMONMSGSTRUCT MONMSGSTRUCT; < 319 alias tagMONMSGSTRUCT* PMONMSGSTRUCT; < 320 365 321 struct tagMONCBSTRUCT { | 366 version (Unicode) { 322 UINT cb; | 367 alias DdeCreateStringHandleW DdeCreateStringHandle; 323 DWORD dwTime; | 368 alias DdeInitializeW DdeInitialize; 324 HANDLE hTask; | 369 alias DdeQueryStringW DdeQueryString; 325 DWORD dwRet; < 326 UINT wType; < 327 UINT wFmt; < 328 HCONV hConv; < 329 HSZ hsz1; < 330 HSZ hsz2; < 331 HDDEDATA hData; < 332 ULONG_PTR dwData1; < 333 ULONG_PTR dwData2; < 334 CONVCONTEXT cc; < 335 DWORD cbData; < 336 DWORD Data[8]; < 337 } < 338 alias tagMONCBSTRUCT MONCBSTRUCT; < 339 alias tagMONCBSTRUCT* PMONCBSTRUCT; < 340 < 341 struct tagMONHSZSTRUCTA { < 342 UINT cb; < 343 BOOL fsAction; < 344 DWORD dwTime; < 345 HSZ hsz; < 346 HANDLE hTask; < 347 CHAR str[1]; < 348 } < 349 alias tagMONHSZSTRUCTA MONHSZSTRUCTA; < 350 alias tagMONHSZSTRUCTA* PMONHSZSTRUCTA; < 351 < 352 struct tagMONHSZSTRUCTW { < 353 UINT cb; < 354 BOOL fsAction; < 355 DWORD dwTime; < 356 HSZ hsz; < 357 HANDLE hTask; < 358 WCHAR str[1]; < 359 } < 360 alias tagMONHSZSTRUCTW MONHSZSTRUCTW; < 361 alias tagMONHSZSTRUCTW* PMONHSZSTRUCTW; < 362 < 363 // #ifdef UNICODE < 364 alias MONHSZSTRUCTW MONHSZSTRUCT; < 365 alias PMONHSZSTRUCTW PMONHSZSTRUCT; < 366 // #else | 370 } else { 367 // ... < 368 // #endif // UNICODE < > 371 alias DdeCreateStringHandleA DdeCreateStringHandle; > 372 alias DdeInitializeA DdeInitialize; > 373 alias DdeQueryStringA DdeQueryString; 369 | 374 } 370 enum : uint { MH_CREATE = 1 } < 371 enum : uint { MH_KEEP = 2 } < 372 enum : uint { MH_DELETE = 3 } < 373 enum : uint { MH_CLEANUP = 4 } < 374 < 375 struct tagMONERRSTRUCT { < 376 UINT cb; < 377 UINT wLastError; < 378 DWORD dwTime; < 379 HANDLE hTask; < 380 } < 381 alias tagMONERRSTRUCT MONERRSTRUCT; < 382 alias tagMONERRSTRUCT* PMONERRSTRUCT; < 383 < 384 struct tagMONLINKSTRUCT { < 385 UINT cb; < 386 DWORD dwTime; < 387 HANDLE hTask; < 388 BOOL fEstablished; < 389 BOOL fNoData; < 390 HSZ hszSvc; < 391 HSZ hszTopic; < 392 HSZ hszItem; < 393 UINT wFmt; < 394 BOOL fServer; < 395 HCONV hConvServer; < 396 HCONV hConvClient; < 397 } < 398 alias tagMONLINKSTRUCT MONLINKSTRUCT; < 399 alias tagMONLINKSTRUCT* PMONLINKSTRUCT; < 400 < 401 struct tagMONCONVSTRUCT { < 402 UINT cb; < 403 BOOL fConnect; < 404 DWORD dwTime; < 405 HANDLE hTask; < 406 HSZ hszSvc; < 407 HSZ hszTopic; < 408 HCONV hConvClient; < 409 HCONV hConvServer; < 410 } < 411 alias tagMONCONVSTRUCT MONCONVSTRUCT; < 412 alias tagMONCONVSTRUCT* PMONCONVSTRUCT; < 413 < 414 enum : uint { MAX_MONITORS = 4 } < 415 enum : uint { APPCLASS_MONITOR = 0x00000001 } < 416 const uint XTYP_MONITOR = 0x00F0 | XCLASS_NOTIFICATION | XTYPF_NOBLOCK; < 417 < 418 enum : uint { MF_HSZ_INFO = 0x01000000 } < 419 enum : uint { MF_SENDMSGS = 0x02000000 } < 420 enum : uint { MF_POSTMSGS = 0x04000000 } < 421 enum : uint { MF_CALLBACKS = 0x08000000 } < 422 enum : uint { MF_ERRORS = 0x10000000 } < 423 enum : uint { MF_LINKS = 0x20000000 } < 424 enum : uint { MF_CONV = 0x40000000 } < 425 < 426 enum : uint { MF_MASK = 0xFF000000 } < 427 // #endif /* NODDEMLSPY */ < 428 < 429 // #ifdef __cplusplus < 430 // } < 431 // #endif /* __cplusplus */ < 432 < 433 // #endif /* _INC_DDEMLH */ < 434 <