Changeset 155

trunk/win32/accctrl.d

r146	r155
11	11	module win32.accctrl;
12	12
13		private import win32.w32api, win32.winbase, win32.windef;
14		private import win32.basetyps;
	13	private import win32.basetyps, win32.w32api, win32.winbase, win32.windef;
15	14
16	15	// FIXME: check types and grouping of constants

trunk/win32/aclui.d

r146	r155
12	12	pragma(lib, "aclui.lib");
13	13
14		import win32.objbase, win32.commctrl, win32.accctrl;
15		private import win32.winuser;
16		private import win32.windef;
17		private import win32.basetyps;
18		private import win32.unknwn;
19		private import win32.prsht;
	14	import win32.accctrl, win32.commctrl, win32.objbase;
	15	private import win32.basetyps, win32.prsht, win32.unknwn, win32.windef,
	16	win32.winuser;
20	17
21	18	struct SI_OBJECT_INFO {

trunk/win32/basetyps.d

r100	r155
9	9	\***********************************************************************/
10	10	module win32.basetyps;
	11
11	12	private import win32.windef;
12	13

trunk/win32/cguid.d

r141	r155
9	9	\***********************************************************************/
10	10	module win32.cguid;
	11
11	12	private import win32.basetyps;
12	13

trunk/win32/comcat.d

r146	r155
12	12
13	13	import win32.windows, win32.ole2;
14		private import win32.~~unknwn, win32.windef, win32.basetyps;~~
15		~~private import win32.cguid, win32.objbase~~, win32.wtypes;
	14	private import win32.basetyps, win32.cguid, win32.objbase, win32.unknwn,
	15	win32.windef, win32.wtypes;
16	16
17	17	alias IEnumGUID* LPENUMGUID;

trunk/win32/commctrl.d

r135	r155
12	12	pragma(lib, "comctl32.lib");
13	13
14		private import win32.w32api;
15		private import win32.windef;
16		private import win32.winuser;
	14	private import win32.w32api, win32.windef, win32.winuser;
17	15	private import win32.winbase; // for SYSTEMTIME
18	16	private import win32.objfwd; // for LPSTREAM

trunk/win32/commdlg.d

r141	r155
12	12
13	13	private import win32.w32api;
14		import win32.windef;
	14	import win32.windef, win32.winuser;
15	15	import win32.wingdi; // for LPLOGFONTA
16		~~import win32.winuser;~~
17	16
18	17	const TCHAR []

trunk/win32/core.d

r146	r155
6	6	* Placed into public domain *
7	7	\***********************************************************************/
	8	module win32.core;
	9
8	10	/**
9	11	The core Windows API functions.
…	…
16	18
17	19	*/
18		~~module win32.core;~~
19	20
20	21	public import win32.windef;

trunk/win32/cpl.d

r104	r155
11	11	module win32.cpl;
12	12
13		private import win32.win~~user, win32.windef~~;
	13	private import win32.windef, win32.winuser;
14	14
15	15	enum : uint {

trunk/win32/d3d9.d

r146	r155
11	11	module win32.d3d9;
12	12
13		private import win32.objbase;
14		public import win32.d3d9types;
15		public import win32.d3d9caps;
16		private import win32.wingdi, win32.windef;
17		private import win32.basetyps, win32.unknwn;
	13	import win32.d3d9caps, win32.d3d9types, win32.objbase;
	14	private import win32.basetyps, win32.unknwn, win32.windef, win32.wingdi;
18	15
19	16	// FIXME: check types and gropuing of some constants

trunk/win32/d3d9caps.d

r123	r155
11	11	module win32.d3d9caps;
12	12
13		private import win32.~~windef, win32.d3d9types~~;
	13	private import win32.d3d9types, win32.windef;
14	14
15	15	// FIXME: check types of constants

trunk/win32/d3d9types.d

r146	r155
11	11	module win32.d3d9types;
12	12
13		private import win32.~~windef, win32.basetyps~~;
	13	private import win32.basetyps, win32.windef;
14	14
15	15	// FIXME: check types and grouping of constants

trunk/win32/dbt.d

r146	r155
11	11	module win32.dbt;
12	12
13		private import win32.w~~indef, win32.w32api~~;
	13	private import win32.w32api, win32.windef;
14	14
15	15	// FIXME: clean up Windows version support

trunk/win32/dde.d

r147	r155
159	159	}
160	160
161		version(WindowsUnitTest) {
162
163		unittest {
164		DDEACK ddeack;
165
166		with (ddeack) {
167		reserved = 10;
168		assert (_bf == 0x0A);
169		fBusy = true;
170		assert (_bf == 0x4A);
171		fAck = true;
172		assert (_bf == 0xCA);
173
174		assert (reserved == 10);
175		assert (fBusy == true);
176		assert (fAck == true);
177
178		reserved = 43;
179		assert (_bf == 0xEB);
180		fBusy = false;
181		assert (_bf == 0xAB);
182		fAck = false;
183		assert (_bf == 0x2B);
184
185		assert (reserved == 43);
186		assert (fBusy == false);
187		assert (fAck == false);
188		}
189
190		DDEPOKE ddepoke;
191
192		with (ddepoke) {
193		unused = 3456;
194		assert (_bf == 0x0D80);
195		fRelease = true;
196		assert (_bf == 0x2D80);
197		fReserved = 2;
198		assert (_bf == 0xAD80);
199
200		assert (unused == 3456);
201		assert (fRelease == true);
202		assert (fReserved == 2);
203
204		unused = 2109;
205		assert (_bf == 0xa83d);
206		fRelease = false;
207		assert (_bf == 0x883d);
208		fReserved = 1;
209		assert (_bf == 0x483d);
210
211		assert (unused == 2109);
212		assert (fRelease == false);
213		assert (fReserved == 1);
214		}
215		}
216		}
	161	debug (WindowsUnitTest) {
	162	unittest {
	163	DDEACK ddeack;
	164
	165	with (ddeack) {
	166	reserved = 10;
	167	assert (_bf == 0x0A);
	168	fBusy = true;
	169	assert (_bf == 0x4A);
	170	fAck = true;
	171	assert (_bf == 0xCA);
	172
	173	assert (reserved == 10);
	174	assert (fBusy == true);
	175	assert (fAck == true);
	176
	177	reserved = 43;
	178	assert (_bf == 0xEB);
	179	fBusy = false;
	180	assert (_bf == 0xAB);
	181	fAck = false;
	182	assert (_bf == 0x2B);
	183
	184	assert (reserved == 43);
	185	assert (fBusy == false);
	186	assert (fAck == false);
	187	}
	188
	189	DDEPOKE ddepoke;
	190
	191	with (ddepoke) {
	192	unused = 3456;
	193	assert (_bf == 0x0D80);
	194	fRelease = true;
	195	assert (_bf == 0x2D80);
	196	fReserved = 2;
	197	assert (_bf == 0xAD80);
	198
	199	assert (unused == 3456);
	200	assert (fRelease == true);
	201	assert (fReserved == 2);
	202
	203	unused = 2109;
	204	assert (_bf == 0xa83d);
	205	fRelease = false;
	206	assert (_bf == 0x883d);
	207	fReserved = 1;
	208	assert (_bf == 0x483d);
	209
	210	assert (unused == 2109);
	211	assert (fRelease == false);
	212	assert (fReserved == 1);
	213	}
	214	}
	215	}

trunk/win32/ddeml.d

r135	r155
12	12	pragma(lib, "user32.lib");
13	13
14		private import win32.~~winnt, win32.windef, win32.basetsd~~;
	14	private import win32.basetsd, win32.windef, win32.winnt;
15	15
16	16	enum : int {

trunk/win32/docobj.d

r146	r155
9	9	\***********************************************************************/
10	10	module win32.docobj;
11		private import win32.unknwn;
12		private import win32.wtypes;
13		private import win32.oleidl;
14		private import win32.objidl;
15		private import win32.oaidl;
16		private import win32.windef, win32.basetyps;
	11
	12	private import win32.basetyps, win32.oaidl, win32.objidl, win32.oleidl,
	13	win32.unknwn, win32.windef, win32.wtypes;
17	14
18	15	// FIXME: remove inherited methods from interface definitions
19	16
20		const OLECMDERR_E_UNKNOWNGROUP = -2147221244;
21		const OLECMDERR_E_CANCELED = -2147221245;
22		const OLECMDERR_E_NOHELP = -2147221246;
23		const OLECMDERR_E_DISABLED = -2147221247;
24		const OLECMDERR_E_NOTSUPPORTED = -2147221248;
	17	enum {
	18	OLECMDERR_E_UNKNOWNGROUP = -2147221244,
	19	OLECMDERR_E_CANCELED = -2147221245,
	20	OLECMDERR_E_NOHELP = -2147221246,
	21	OLECMDERR_E_DISABLED = -2147221247,
	22	OLECMDERR_E_NOTSUPPORTED = -2147221248
	23	}
25	24
26	25	enum OLECMDID {

trunk/win32/dxerr8.d

r123	r155
	1	/***********************************************************************\
	2	* dxerr8.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	module win32.dxerr8;
2	11
…	…
34	43
35	44	debug (dxerr) {
36		version (Unicode) {
37		HRESULT DXTRACE_MSG (WCHAR* str) {
38		return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE);
39		}
	45	HRESULT DXTRACE_MSG(TCHAR* str) {
	46	return DXTrace(__FILE__, __LINE__, 0, str, FALSE);
	47	}
40	48
41		~~HRESULT DXTRACE_ERR (W~~CHAR* str, HRESULT hr) {
42		~~return DXTrace(__FILE__, cast(DWORD)~~__LINE__, hr, str, TRUE);
43		}
	49	HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) {
	50	return DXTrace(__FILE__, __LINE__, hr, str, TRUE);
	51	}
44	52
45		HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) {
46		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE);
47		}
48		} else {
49		HRESULT DXTRACE_MSG (char* str) {
50		return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE);
51		}
52
53		HRESULT DXTRACE_ERR (char* str, HRESULT hr) {
54		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, TRUE);
55		}
56
57		HRESULT DXTRACE_ERR_NOMSGBOX (char* str, HRESULT hr) {
58		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE);
59		}
	53	HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) {
	54	return DXTrace(__FILE__, __LINE__, hr, str, FALSE);
60	55	}
61	56	} else {
62		version (Unicode) {
63		HRESULT DXTRACE_MSG (WCHAR* str) {
64		return 0;
65		}
	57	HRESULT DXTRACE_MSG(TCHAR* str) {
	58	return 0;
	59	}
66	60
67		~~HRESULT DXTRACE_ERR (W~~CHAR* str, HRESULT hr) {
68		return hr;
69		}
	61	HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) {
	62	return hr;
	63	}
70	64
71		HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) {
72		return hr;
73		}
74		} else {
75		HRESULT DXTRACE_MSG (char* str) {
76		return 0;
77		}
78
79		HRESULT DXTRACE_ERR (char* str, HRESULT hr) {
80		return hr;
81		}
82
83		HRESULT DXTRACE_ERR_NOMSGBOX (char* str, HRESULT hr) {
84		return hr;
85		}
	65	HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) {
	66	return hr;
86	67	}
87	68	}

trunk/win32/dxerr9.d

r123	r155
	1	/***********************************************************************\
	2	* dxerr9.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	module win32.dxerr9;
2	11
…	…
35	44
36	45	debug (dxerr) {
37		version (Unicode) {
38		HRESULT DXTRACE_MSG (WCHAR* str) {
39		return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE);
40		}
	46	HRESULT DXTRACE_MSG(TCHAR* str) {
	47	return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE);
	48	}
41	49
42		~~HRESULT DXTRACE_ERR (W~~CHAR* str, HRESULT hr) {
43		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE);
44		}
	50	HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) {
	51	return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE);
	52	}
45	53
46		HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) {
47		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, TRUE);
48		}
49		} else {
50		HRESULT DXTRACE_MSG (char* str) {
51		return DXTrace(__FILE__, cast(DWORD)__LINE__, 0, str, FALSE);
52		}
53
54		HRESULT DXTRACE_ERR (char* str, HRESULT hr) {
55		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, FALSE);
56		}
57
58		HRESULT DXTRACE_ERR_NOMSGBOX (char* str, HRESULT hr) {
59		return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, TRUE);
60		}
	54	HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) {
	55	return DXTrace(__FILE__, cast(DWORD)__LINE__, hr, str, TRUE);
61	56	}
62	57	} else {
63		version (Unicode) {
64		HRESULT DXTRACE_MSG (WCHAR* str) {
65		return 0;
66		}
	58	HRESULT DXTRACE_MSG(TCHAR* str) {
	59	return 0;
	60	}
67	61
68		~~HRESULT DXTRACE_ERR (W~~CHAR* str, HRESULT hr) {
69		return hr;
70		}
	62	HRESULT DXTRACE_ERR(TCHAR* str, HRESULT hr) {
	63	return hr;
	64	}
71	65
72		HRESULT DXTRACE_ERR_NOMSGBOX (WCHAR* str, HRESULT hr) {
73		return hr;
74		}
75		} else {
76		HRESULT DXTRACE_MSG (char* str) {
77		return 0;
78		}
79
80		HRESULT DXTRACE_ERR (char* str, HRESULT hr) {
81		return hr;
82		}
83
84		HRESULT DXTRACE_ERR_NOMSGBOX (char* str, HRESULT hr) {
85		return hr;
86		}
	66	HRESULT DXTRACE_ERR_NOMSGBOX(TCHAR* str, HRESULT hr) {
	67	return hr;
87	68	}
88	69	}

trunk/win32/exdisp.d

r146	r155
10	10	module win32.exdisp;
11	11
12		import win32.oaidl;
13		import win32.ocidl;
14		import win32.docobj;
15		private import win32.wtypes, win32.basetyps, win32.windef;
	12	import win32.docobj, win32.oaidl, win32.ocidl;
	13	private import win32.basetyps, win32.windef, win32.wtypes;
16	14
17	15

trunk/win32/httpext.d

r135	r155
	1	/***********************************************************************\
	2	* httpext.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	module win32.httpext;
2	11

trunk/win32/imagehlp.d

r135	r155
9	9	* Placed into public domain *
10	10	\***********************************************************************/
	11	module win32.imagehlp;
	12
11	13	/* Comment from MinGW
12	14	NOTE: This strictly does not belong in the Win32 API since it's
…	…
14	16	as well provide it here.
15	17	*/
16		~~module win32.imagehlp;~~
17	18
18	19	private import win32.winbase, win32.windef;

trunk/win32/imm.d

r141	r155
11	11	pragma(lib, "imm32.lib");
12	12
	13	import win32.windef, win32.wingdi;
	14	import win32.winuser; // for the MFS_xxx enums.
13	15	private import win32.w32api;
14		~~import win32.windef;~~
15		~~import win32.wingdi;~~
16		~~import win32.winuser; // for the MFS_xxx enums.~~
17	16
18	17	const WM_CONVERTREQUESTEX = 0x108;

trunk/win32/intshcut.d

r141	r155
11	11	module win32.intshcut;
12	12
13		private import win32.~~windef, win32.unknwn~~;
	13	private import win32.unknwn, win32.windef;
14	14
15	15	enum : SCODE {

trunk/win32/iphlpapi.d

r141	r155
11	11	module win32.iphlpapi;
12	12
13		import win32.ip~~rtrmib, win32.ipexport~~, win32.iptypes;
14		private import win32.win~~def, win32.winbase~~;
	13	import win32.ipexport, win32.iprtrmib, win32.iptypes;
	14	private import win32.winbase, win32.windef;
15	15
16	16	extern (Windows) {

trunk/win32/lm.d

r135	r155
18	18	}
19	19
20		import win32.lmcons;
21		import win32.lmaccess;
22		import win32.lmalert;
23		import win32.lmat;
24		import win32.lmerr;
25		import win32.lmmsg;
26		import win32.lmshare;
27		import win32.lmapibuf;
28		import win32.lmremutl;
29		import win32.lmrepl;
30		import win32.lmuse;
	20	public import win32.lmcons;
	21	public import win32.lmaccess;
	22	public import win32.lmalert;
	23	public import win32.lmat;
	24	public import win32.lmerr;
	25	public import win32.lmmsg;
	26	public import win32.lmshare;
	27	public import win32.lmapibuf;
	28	public import win32.lmremutl;
	29	public import win32.lmrepl;
	30	public import win32.lmuse;
31	31
32	32	version (WIN32_WINNT_ONLY) {
33		import win32.lmwksta;
34		import win32.lmserver;
	33	public import win32.lmwksta;
	34	public import win32.lmserver;
35	35	}
36		import win32.lmstats;
	36	public import win32.lmstats;
37	37
38	38	// FIXME: Everything in these next files seems to be deprecated!

trunk/win32/lmaccess.d

r127	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.lmaccess;
	11	pragma(lib, "netapi32.lib");
	12
10	13	/**
11	14	Changes relative to MinGW:
12		USER_POSIX_ID_PARMNUM and GROUP_POSIX_ID_PARMNUM aren't in MinGW or in ~~the Platform SDK docs,~~
13		so they have been dropped from this file.
	15	USER_POSIX_ID_PARMNUM and GROUP_POSIX_ID_PARMNUM aren't in MinGW or in
	16	the Platform SDK docs, so they have been dropped from this file.
14	17	*/
15	18
16		module win32.lmaccess;
17		pragma(lib, "netapi32.lib");
18		private import win32.windef;
19		private import win32.lmcons;
	19	private import win32.lmcons, win32.windef;
20	20
21	21	const wchar[]
…	…
25	25	GROUP_SPECIALGRP_LOCAL = "LOCAL";
26	26
27		const ACCESS_LETTERS="RWCXDAP ";
	27	const ACCESS_LETTERS = "RWCXDAP ";
28	28
29	29	const NETLOGON_CONTROL_QUERY=1;

trunk/win32/lmalert.d

r127	r155
10	10	module win32.lmalert;
11	11	pragma(lib, "netapi32.lib");
12		~~private import win32.lmcons;~~
13		~~private import win32.windef;~~
14	12
	13	private import win32.lmcons, win32.windef;
15	14
16	15	const TCHAR[]

trunk/win32/lmapibuf.d

r127	r155
10	10	module win32.lmapibuf;
11	11	pragma(lib, "netapi32.lib");
12		private import win32.windef;
13		private import win32.lmcons;
	12
	13	private import win32.lmcons, win32.windef;
14	14
15	15	extern (Windows) {

trunk/win32/lmat.d

r127	r155
10	10	module win32.lmat;
11	11	pragma(lib, "netapi32.lib");
12		private import win32.lmcons;
13		private import win32.windef;
	12
	13	private import win32.lmcons, win32.windef;
14	14
15	15	const JOB_RUN_PERIODICALLY = 1;

trunk/win32/lmaudit.d

r127	r155
10	10	// COMMENT: This file may be deprecated.
11	11	module win32.lmaudit;
12		private import win32.lmcons;
13		private import win32.windef;
	12
	13	private import win32.lmcons, win32.windef;
14	14
15	15	const LOGFLAGS_FORWARD = 0;

trunk/win32/lmbrowsr.d

r123	r155
9	9	\***********************************************************************/
10	10	module win32.lmbrowsr;
11		private import win32.lmcons;
12		private import win32.windef;
	11
	12	private import win32.lmcons, win32.windef;
13	13
14	14	const BROWSER_ROLE_PDC = 1;

trunk/win32/lmchdev.d

r127	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.lmchdev;
10	11
11	12	// COMMENT: This file might be deprecated.
12		module win32.lmchdev;
13		private import win32.lmcons;
14		private import win32.windef;
	13
	14	private import win32.lmcons, win32.windef;
15	15
16	16	const CHARDEVQ_NO_REQUESTS = -1;
…	…
78	78
79	79	extern (Windows) {
80		~~NET_API_STATUS NetCharDevEnum(LPCWSTR,DWORD,PBYTE*,DWORD,PDWORD,PDWORD,~~PDWORD);
81		~~NET_API_STATUS NetCharDevGetInfo(LPCWSTR,LPCWSTR,DWORD,~~PBYTE*);
82		~~NET_API_STATUS NetCharDevControl(LPCWSTR,LPCWSTR,~~DWORD);
83		~~NET_API_STATUS NetCharDevQEnum(LPCWSTR,LPCWSTR,DWORD,PBYTE*,DWORD,PDWORD,PDWORD,~~PDWORD);
84		~~NET_API_STATUS NetCharDevQGetInfo(LPCWSTR,LPCWSTR,LPCWSTR,DWORD,~~PBYTE*);
85		~~NET_API_STATUS NetCharDevQSetInfo(LPCWSTR,LPCWSTR,DWORD,PBYTE,~~PDWORD);
86		~~NET_API_STATUS NetCharDevQPurge(LPCWSTR,~~LPCWSTR);
87		~~NET_API_STATUS NetCharDevQPurgeSelf(LPCWSTR,LPCWSTR,~~LPCWSTR);
88		~~NET_API_STATUS NetHandleGetInfo(HANDLE,DWORD,~~PBYTE*);
89		~~NET_API_STATUS NetHandleSetInfo(HANDLE,DWORD,PBYTE,DWORD,~~PDWORD);
	80	NET_API_STATUS NetCharDevEnum(LPCWSTR, DWORD, PBYTE*, DWORD, PDWORD, PDWORD, PDWORD);
	81	NET_API_STATUS NetCharDevGetInfo(LPCWSTR, LPCWSTR, DWORD, PBYTE*);
	82	NET_API_STATUS NetCharDevControl(LPCWSTR, LPCWSTR, DWORD);
	83	NET_API_STATUS NetCharDevQEnum(LPCWSTR, LPCWSTR, DWORD, PBYTE*, DWORD, PDWORD, PDWORD, PDWORD);
	84	NET_API_STATUS NetCharDevQGetInfo(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, PBYTE*);
	85	NET_API_STATUS NetCharDevQSetInfo(LPCWSTR, LPCWSTR, DWORD, PBYTE, PDWORD);
	86	NET_API_STATUS NetCharDevQPurge(LPCWSTR, LPCWSTR);
	87	NET_API_STATUS NetCharDevQPurgeSelf(LPCWSTR, LPCWSTR, LPCWSTR);
	88	NET_API_STATUS NetHandleGetInfo(HANDLE, DWORD, PBYTE*);
	89	NET_API_STATUS NetHandleSetInfo(HANDLE, DWORD, PBYTE, DWORD, PDWORD);
90	90	}

trunk/win32/lmconfig.d

r127	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.lmconfig;
	11
10	12	// All functions in this file are deprecated!
11		module win32.lmconfig;
12		private import win32.windef;
13		private import win32.lmcons;
	13
	14	private import win32.lmcons, win32.windef;
14	15
15	16	deprecated {
	17	struct CONFIG_INFO_0 {
	18	LPWSTR cfgi0_key;
	19	LPWSTR cfgi0_data;
	20	}
	21	alias CONFIG_INFO_0* PCONFIG_INFO_0, LPCONFIG_INFO_0;
16	22
17		struct CONFIG_INFO_0 {
18		LPWSTR cfgi0_key;
19		LPWSTR cfgi0_data;
	23	extern (Windows) {
	24	NET_API_STATUS NetConfigGet(LPCWSTR, LPCWSTR, LPCWSTR, PBYTE*);
	25	NET_API_STATUS NetConfigGetAll(LPCWSTR, LPCWSTR, PBYTE*);
	26	NET_API_STATUS NetConfigSet(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, DWORD,
	27	PBYTE, DWORD);
	28	}
20	29	}
21		~~alias CONFIG_INFO_0* PCONFIG_INFO_0, LPCONFIG_INFO_0;~~
22
23		~~extern (Windows) {~~
24		~~NET_API_STATUS NetConfigGet(LPCWSTR, LPCWSTR, LPCWSTR, PBYTE*);~~
25		~~NET_API_STATUS NetConfigGetAll(LPCWSTR, LPCWSTR, PBYTE*);~~
26		~~NET_API_STATUS NetConfigSet(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, DWORD,~~
27		~~PBYTE, DWORD);~~
28		}
29		}

trunk/win32/lmcons.d

r117	r155
9	9	\***********************************************************************/
10	10	module win32.lmcons;
	11
11	12	private import win32.windef;
12	13	private import win32.lmerr; // for NERR_BASE
13	14
14		const TCHAR[]
	15	const TCHAR[]
15	16	MESSAGE_FILENAME = "NETMSG",
16	17	OS2MSG_FILENAME = "BASE",

trunk/win32/lmerr.d

r99	r155
9	9	\***********************************************************************/
10	10	module win32.lmerr;
	11
11	12	import win32.winerror;
12	13

trunk/win32/lmerrlog.d

r135	r155
1	1	/***********************************************************************\
2		* ~~lmerrlog.d~~ *
	2	* lmerrlog.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.lmerrlog;
	11
10	12	// COMMENT: This appears to be only for Win16. All functions are deprecated.
11		module win32.lmerrlog;
12		private import win32.lmcons;
13		private import win32.windef;
	13
	14	private import win32.lmcons, win32.windef;
14	15	private import win32.lmaudit; // for LPHLOG
15	16

trunk/win32/lmmsg.d

r127	r155
10	10	module win32.lmmsg;
11	11	pragma(lib, "netapi32.lib");
12		private import win32.lmcons;
13		private import win32.windef;
	12
	13	private import win32.lmcons, win32.windef;
14	14
15	15	// NOTE: Requires Windows XP or later

trunk/win32/lmremutl.d

r127	r155
1	1	/***********************************************************************\
2		* ~~lmremutl.d~~ *
	2	* lmremutl.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
10		~~// D Conversion Note: DESC_CHAR is defined as TCHAR.~~
11	10	module win32.lmremutl;
12	11	pragma(lib, "netapi32.lib");
13		private import win32.lmcons;
14		private import win32.windef;
	12
	13	// D Conversion Note: DESC_CHAR is defined as TCHAR.
	14
	15	private import win32.lmcons, win32.windef;
15	16
16	17	const SUPPORTS_REMOTE_ADMIN_PROTOCOL = 2;

trunk/win32/lmrepl.d

r135	r155
1	1	/***********************************************************************\
2		* ~~lmrepl.d~~ *
	2	* lmrepl.d *
3	3	* *
4	4	* Windows API header module *
…	…
11	11	pragma(lib, "netapi32.lib");
12	12
13		private import win32.lmcons;
14		private import win32.windef;
	13	private import win32.lmcons, win32.windef;
15	14
16	15	const REPL_ROLE_EXPORT=1;

trunk/win32/lmserver.d

r135	r155
1	1	/***********************************************************************\
2		* ~~lmserver.d~~ *
	2	* lmserver.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.lmserver;
	11
11	12	import win32.winsvc;
12		private import win32.lmcons;
13		private import win32.windef;
	13	private import win32.lmcons, win32.windef;
14	14
15	15	struct SERVER_INFO_100 {

trunk/win32/lmshare.d

r127	r155
9	9	\***********************************************************************/
10	10	module win32.lmshare;
	11
11	12	import win32.lmcons;
12		private import win32.windef;
13
14
15		private import win32.w32api;
	13	private import win32.w32api, win32.windef;
	14
16	15	static if (_WIN32_WINNT_ONLY) {
17	16	pragma(lib, "netapi.lib");
…	…
62	61	alias FILE_INFO_2* PFILE_INFO_2, LPFILE_INFO_2;
63	62
64		struct FILE_INFO_3{
	63	struct FILE_INFO_3 {
65	64	DWORD fi3_id;
66	65	DWORD fi3_permissions;
…	…
76	75	alias SHARE_INFO_0* PSHARE_INFO_0, LPSHARE_INFO_0;
77	76
78		struct SHARE_INFO_1{
	77	struct SHARE_INFO_1 {
79	78	LPTSTR shi1_netname;
80	79	DWORD shi1_type;
…	…
83	82	alias SHARE_INFO_1* PSHARE_INFO_1, LPSHARE_INFO_1;
84	83
85		struct SHARE_INFO_2{
	84	struct SHARE_INFO_2 {
86	85	LPTSTR shi2_netname;
87	86	DWORD shi2_type;
…	…
95	94	alias SHARE_INFO_2* PSHARE_INFO_2, LPSHARE_INFO_2;
96	95
97		struct SHARE_INFO_502{
	96	struct SHARE_INFO_502 {
98	97	LPTSTR shi502_netname;
99	98	DWORD shi502_type;
…	…
109	108	alias SHARE_INFO_502* PSHARE_INFO_502, LPSHARE_INFO_502;
110	109
111		struct SHARE_INFO_1004{
	110	struct SHARE_INFO_1004 {
112	111	LPTSTR shi1004_remark;
113	112	}
114	113	alias SHARE_INFO_1004* PSHARE_INFO_1004, LPSHARE_INFO_1004;
115	114
116		struct SHARE_INFO_1006{
	115	struct SHARE_INFO_1006 {
117	116	DWORD shi1006_max_uses;
118	117	}
119	118	alias SHARE_INFO_1006* PSHARE_INFO_1006, LPSHARE_INFO_1006;
120	119
121		struct SHARE_INFO_1501{
	120	struct SHARE_INFO_1501 {
122	121	DWORD shi1501_reserved;
123	122	PSECURITY_DESCRIPTOR shi1501_security_descriptor;
…	…
130	129	alias SESSION_INFO_0* PSESSION_INFO_0, LPSESSION_INFO_0;
131	130
132		struct SESSION_INFO_1{
	131	struct SESSION_INFO_1 {
133	132	LPTSTR sesi1_cname;
134	133	LPTSTR sesi1_username;
…	…
140	139	alias SESSION_INFO_1* PSESSION_INFO_1, LPSESSION_INFO_1;
141	140
142		struct SESSION_INFO_2{
	141	struct SESSION_INFO_2 {
143	142	LPTSTR sesi2_cname;
144	143	LPTSTR sesi2_username;
…	…
151	150	alias SESSION_INFO_2* PSESSION_INFO_2, LPSESSION_INFO_2;
152	151
153		struct SESSION_INFO_10{
	152	struct SESSION_INFO_10 {
154	153	LPWSTR sesi10_cname;
155	154	LPWSTR sesi10_username;
…	…
159	158	alias SESSION_INFO_10* PSESSION_INFO_10, LPSESSION_INFO_10;
160	159
161		struct SESSION_INFO_502{
	160	struct SESSION_INFO_502 {
162	161	LPWSTR sesi502_cname;
163	162	LPWSTR sesi502_username;
…	…
176	175	alias CONNECTION_INFO_0* PCONNECTION_INFO_0, LPCONNECTION_INFO_0;
177	176
178		struct CONNECTION_INFO_1{
	177	struct CONNECTION_INFO_1 {
179	178	DWORD coni1_id;
180	179	DWORD coni1_type;

trunk/win32/lmsname.d

r117	r155
	1	/***********************************************************************\
	2	* lmsname.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	module win32.lmsname;
	11
2	12	private import win32.windef;
3	13

trunk/win32/lmstats.d

r127	r155
1	1	/***********************************************************************\
2		* ~~lmstats.d~~ *
	2	* lmstats.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.lmstats;
11	11	pragma(lib, "netapi32.lib");
12		private import win32.lmcons;
13		private import win32.windef;
	12
	13	private import win32.lmcons, win32.windef;
14	14
15	15	const ULONG

trunk/win32/lmsvc.d

r135	r155
1	1	/***********************************************************************\
2		* ~~lmsvc.d~~ *
	2	* lmsvc.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.lmsvc;
	11
10	12	// FIXME: Is this file deprecated? All of the functions are only for Win16.
11	13	/**
…	…
15	17	// TODO: 5 macros
16	18
17		module win32.lmsvc;
18		private import win32.lmsname;
19		private import win32.lmcons;
20		private import win32.windef;
	19	private import win32.lmcons, win32.lmsname, win32.windef;
21	20
22	21	const TCHAR[] SERVICE_DOS_ENCRYPTION = "ENCRYPT";

trunk/win32/lmuse.d

r127	r155
10	10	module win32.lmuse;
11	11	pragma(lib, "netapi32.lib");
	12
12	13	import win32.lmuseflg;
13		private import win32.lmcons;
14		private import win32.windef;
	14	private import win32.lmcons, win32.windef;
15	15
16	16	enum {

trunk/win32/lmuseflg.d

r116	r155
	1	/***********************************************************************\
	2	* lmuseflg.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	module win32.lmuseflg;
2	11

trunk/win32/lmwksta.d

r127	r155
10	10	module win32.lmwksta;
11	11	pragma(lib, "netapi32.lib");
12		private import win32.lmcons;
	12
13	13	import win32.lmuseflg;
14		private import win32.windef;
	14	private import win32.lmcons, win32.windef;
15	15
16	16	pragma(lib, "Netapi32.lib");

trunk/win32/lzexpand.d

r127	r155
10	10	module win32.lzexpand;
11	11	pragma(lib, "lz32.lib");
12		private import win32.windef;
13		private import win32.winbase;
	12
	13	private import win32.winbase, win32.windef;
14	14
15	15	enum : LONG {

trunk/win32/mmsystem.d

r135	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
10
11		~~// The #defines MAKEFOURCC, mmioFOURCC, sndAlias are used to define compile-time constants,~~
12		~~// so they are implemented as templates.~~
13
14	10	module win32.mmsystem;
15	11	pragma(lib, "winmm.lib");
16		private import win32.w32api;
17		private import win32.winver;
18		private import win32.windef;
	12
	13	/* The #defines MAKEFOURCC, mmioFOURCC, sndAlias are used to define
	14	* compile-time constants, so they are implemented as templates.
	15	*/
	16
	17	private import win32.w32api, win32.windef, win32.winver;
19	18
20	19	align(1):

trunk/win32/msacm.d

r147	r155
11	11	module win32.msacm;
12	12
13		private import win32.~~windef, win32.basetsd, win32.mmsystem~~;
	13	private import win32.basetsd, win32.mmsystem, win32.windef;
14	14
15	15	alias HANDLE HACMDRIVERID, HACMDRIVER;

trunk/win32/mshtml.d

r146	r155
1	1	/***********************************************************************\
2		* mshtml.d *
	2	* mshtml.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.mshtml;
11	11
12		private import win32.unknwn;
13		private import win32.wtypes;
14		private import win32.oaidl, win32.basetyps, win32.windef;
15
	12	private import win32.basetyps, win32.oaidl, win32.unknwn,
	13	win32.windef, win32.wtypes;
16	14
17	15	// These are used in this file, but not defined in MinGW.

trunk/win32/mswsock.d

r129	r155
11	11	module win32.mswsock;
12	12
	13	import win32.winbase, win32.windef;
13	14	private import win32.w32api;
14	15
15	16	// FIXME: clean up Windows version support
16
17		~~import win32.winbase;~~
18		~~import win32.windef;~~
19	17
20	18	// Pull in Winsock2 if the user has put "Win32_Winsock2" on the compile

trunk/win32/nddeapi.d

r147	r155
10	10	\***********************************************************************/
11	11	module win32.nddeapi;
12		version { }
	12
	13	private import win32.windef;
	14
	15	// FIXME: check types and grouping of constants
	16
	17	/+
	18	#ifndef CNLEN /* also in lmcons.h */
	19	#define CNLEN 15
	20	#define UNCLEN (CNLEN + 2)
	21	#endif
	22	+/
	23
	24	const char SEP_CHAR = ',';
	25	const char[] BAR_CHAR = "\|";
	26	const wchar SEP_WCHAR = ',';
	27	const wchar[] BAR_WCHAR = "\|";
	28
	29	enum {
	30	NDDE_NO_ERROR,
	31	NDDE_ACCESS_DENIED,
	32	NDDE_BUF_TOO_SMALL,
	33	NDDE_ERROR_MORE_DATA,
	34	NDDE_INVALID_SERVER,
	35	NDDE_INVALID_SHARE,
	36	NDDE_INVALID_PARAMETER,
	37	NDDE_INVALID_LEVEL,
	38	NDDE_INVALID_PASSWORD,
	39	NDDE_INVALID_ITEMNAME,
	40	NDDE_INVALID_TOPIC,
	41	NDDE_INTERNAL_ERROR,
	42	NDDE_OUT_OF_MEMORY,
	43	NDDE_INVALID_APPNAME,
	44	NDDE_NOT_IMPLEMENTED,
	45	NDDE_SHARE_ALREADY_EXIST,
	46	NDDE_SHARE_NOT_EXIST,
	47	NDDE_INVALID_FILENAME,
	48	NDDE_NOT_RUNNING,
	49	NDDE_INVALID_WINDOW,
	50	NDDE_INVALID_SESSION,
	51	NDDE_INVALID_ITEM_LIST,
	52	NDDE_SHARE_DATA_CORRUPTED,
	53	NDDE_REGISTRY_ERROR,
	54	NDDE_CANT_ACCESS_SERVER,
	55	NDDE_INVALID_SPECIAL_COMMAND,
	56	NDDE_INVALID_SECURITY_DESC,
	57	NDDE_TRUST_SHARE_FAIL
	58	}
	59
	60	const size_t
	61	MAX_NDDESHARENAME = 256,
	62	MAX_DOMAINNAME = 15,
	63	MAX_USERNAME = 15,
	64	MAX_APPNAME = 255,
	65	MAX_TOPICNAME = 255,
	66	MAX_ITEMNAME = 255;
	67
	68	const NDDEF_NOPASSWORDPROMPT = 1;
	69	const NDDEF_NOCACHELOOKUP = 2;
	70	const NDDEF_STRIP_NDDE = 4;
	71
	72	const SHARE_TYPE_OLD = 1;
	73	const SHARE_TYPE_NEW = 2;
	74	const SHARE_TYPE_STATIC = 4;
	75
	76	const uint
	77	NDDE_CMD_SHOW_MASK = 0x0000FFFF,
	78	NDDE_TRUST_CMD_SHOW = 0x10000000,
	79	NDDE_TRUST_SHARE_DEL = 0x20000000,
	80	NDDE_TRUST_SHARE_INIT = 0x40000000,
	81	NDDE_TRUST_SHARE_START = 0x80000000;
	82
	83	struct NDdeShareInfo_tag {
	84	LONG lRevision;
	85	LPTSTR lpszShareName;
	86	LONG lShareType;
	87	LPTSTR lpszAppTopicList;
	88	LONG fSharedFlag;
	89	LONG fService;
	90	LONG fStartAppFlag;
	91	LONG nCmdShow;
	92	LONG[2] qModifyId;
	93	LONG cNumItems;
	94	LPTSTR lpszItemList;
	95	}
	96	extern (C) { // huh?
	97	NDdeShareInfo_tag NDDESHAREINFO;
	98	NDdeShareInfo_tag* PNDDESHAREINFO;
	99	}
	100
	101	extern (Windows) {
	102	UINT NDdeGetErrorStringA(UINT, LPSTR, DWORD);
	103	UINT NDdeGetErrorStringW(UINT, LPWSTR, DWORD);
	104	UINT NDdeGetShareSecurityA(LPSTR, LPSTR, SECURITY_INFORMATION,
	105	PSECURITY_DESCRIPTOR, DWORD, PDWORD);
	106	UINT NDdeGetShareSecurityW(LPWSTR, LPWSTR, SECURITY_INFORMATION,
	107	PSECURITY_DESCRIPTOR, DWORD, PDWORD);
	108	UINT NDdeGetTrustedShareA(LPSTR, LPSTR, PDWORD, PDWORD, PDWORD);
	109	UINT NDdeGetTrustedShareW(LPWSTR, LPWSTR, PDWORD, PDWORD, PDWORD);
	110	BOOL NDdeIsValidShareNameA(LPSTR);
	111	BOOL NDdeIsValidShareNameW(LPWSTR);
	112	BOOL NDdeIsValidAppTopicListA(LPSTR);
	113	BOOL NDdeIsValidAppTopicListW(LPWSTR);
	114	UINT NDdeSetShareSecurityA(LPSTR, LPSTR, SECURITY_INFORMATION,
	115	PSECURITY_DESCRIPTOR);
	116	UINT NDdeSetShareSecurityW(LPWSTR, LPWSTR, SECURITY_INFORMATION,
	117	PSECURITY_DESCRIPTOR);
	118	UINT NDdeSetTrustedShareA(LPSTR, LPSTR, DWORD);
	119	UINT NDdeSetTrustedShareW(LPWSTR, LPWSTR, DWORD);
	120	UINT NDdeShareAddA(LPSTR, UINT, PSECURITY_DESCRIPTOR, PBYTE, DWORD);
	121	UINT NDdeShareAddW(LPWSTR, UINT, PSECURITY_DESCRIPTOR, PBYTE, DWORD);
	122	UINT NDdeShareDelA(LPSTR, LPSTR, UINT);
	123	UINT NDdeShareDelW(LPWSTR, LPWSTR, UINT);
	124	UINT NDdeShareEnumA(LPSTR, UINT, PBYTE, DWORD, PDWORD, PDWORD);
	125	UINT NDdeShareEnumW(LPWSTR, UINT, PBYTE, DWORD, PDWORD, PDWORD);
	126	UINT NDdeShareGetInfoA(LPSTR, LPSTR, UINT, PBYTE, DWORD, PDWORD, PWORD);
	127	UINT NDdeShareGetInfoW(LPWSTR, LPWSTR, UINT, PBYTE, DWORD, PDWORD, PWORD);
	128	UINT NDdeShareSetInfoA(LPSTR, LPSTR, UINT, PBYTE, DWORD, WORD);
	129	UINT NDdeShareSetInfoW(LPWSTR, LPWSTR, UINT, PBYTE, DWORD, WORD);
	130	UINT NDdeTrustedShareEnumA(LPSTR, UINT, PBYTE, DWORD, PDWORD, PDWORD);
	131	UINT NDdeTrustedShareEnumW(LPWSTR, UINT, PBYTE, DWORD, PDWORD, PDWORD);
	132	}
	133
	134	version (Unicode) {
	135	alias NDdeShareAddW NDdeShareAdd;
	136	alias NDdeShareDelW NDdeShareDel;
	137	alias NDdeSetShareSecurityW NDdeSetShareSecurity;
	138	alias NDdeGetShareSecurityW NDdeGetShareSecurity;
	139	alias NDdeShareEnumW NDdeShareEnum;
	140	alias NDdeShareGetInfoW NDdeShareGetInfo;
	141	alias NDdeShareSetInfoW NDdeShareSetInfo;
	142	alias NDdeGetErrorStringW NDdeGetErrorString;
	143	alias NDdeIsValidShareNameW NDdeIsValidShareName;
	144	alias NDdeIsValidAppTopicListW NDdeIsValidAppTopicList;
	145	alias NDdeSetTrustedShareW NDdeSetTrustedShare;
	146	alias NDdeGetTrustedShareW NDdeGetTrustedShare;
	147	alias NDdeTrustedShareEnumW NDdeTrustedShareEnum;
	148	} else {
	149	alias NDdeShareAddA NDdeShareAdd;
	150	alias NDdeShareDelA NDdeShareDel;
	151	alias NDdeSetShareSecurityA NDdeSetShareSecurity;
	152	alias NDdeGetShareSecurityA NDdeGetShareSecurity;
	153	alias NDdeShareEnumA NDdeShareEnum;
	154	alias NDdeShareGetInfoA NDdeShareGetInfo;
	155	alias NDdeShareSetInfoA NDdeShareSetInfo;
	156	alias NDdeGetErrorStringA NDdeGetErrorString;
	157	alias NDdeIsValidShareNameA NDdeIsValidShareName;
	158	alias NDdeIsValidAppTopicListA NDdeIsValidAppTopicList;
	159	alias NDdeSetTrustedShareA NDdeSetTrustedShare;
	160	alias NDdeGetTrustedShareA NDdeGetTrustedShare;
	161	alias NDdeTrustedShareEnumA NDdeTrustedShareEnum;
	162	}

trunk/win32/nspapi.d

r147	r155
11	11	module win32.nspapi;
12	12
13		private import win32.windef, win32.basetyps;
	13	private import win32.basetyps, win32.windef;
	14
14	15	// FIXME: check types of constants
15	16

trunk/win32/oaidl.d

r127	r155
10	10	module win32.oaidl;
11	11
12		private import win32.basetyps;
13		private import win32.windef;
14		private import win32.unknwn;
15		private import win32.wtypes;
	12	private import win32.basetyps, win32.unknwn, win32.windef, win32.wtypes;
16	13
17	14	const DISPID_UNKNOWN = -1;

trunk/win32/objbase.d

r146	r155
1	1	/***********************************************************************\
2		* ~~objbase.d~~ *
	2	* objbase.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.objbase;
11	11	pragma(lib, "ole32.lib");
12		private import win32.winbase;
13		private import win32.basetyps;
14		private import win32.windef;
15		private import win32.objfwd;
16		private import win32.rpcdce;
17		import win32.wtypes;
18		import win32.cguid;
19		import win32.unknwn;
20		import win32.objidl;
	12
	13	import win32.cguid, win32.objidl, win32.unknwn, win32.wtypes;
	14	private import win32.basetyps, win32.objfwd, win32.rpcdce, win32.winbase,
	15	win32.windef;
21	16
22	17	// DAC: Not needed for D?
23		//MACRO #define LISet32(li,~~v) ((li).HighPart=(v)<0?-1:0,~~(li).LowPart=(v))
24		//MACRO #define ULISet32(li,~~v) ((li).HighPart=0,~~(li).LowPart=(v))
	18	//MACRO #define LISet32(li, v) ((li).HighPart=(v)<0?-1:0, (li).LowPart=(v))
	19	//MACRO #define ULISet32(li, v) ((li).HighPart=0, (li).LowPart=(v))
25	20
26	21	const CLSCTX_ALL = CLSCTX.CLSCTX_INPROC_SERVER\|CLSCTX.CLSCTX_INPROC_HANDLER\|CLSCTX.CLSCTX_LOCAL_SERVER;
…	…
101	96
102	97	extern(Windows) {
103
104		alias HRESULT function(REFCLSID,REFIID,PVOID*) LPFNGETCLASSOBJECT;
105		alias HRESULT function() LPFNCANUNLOADNOW;
106
107		DWORD CoBuildVersion();
108		HRESULT CoInitialize(PVOID);
109		HRESULT CoInitializeEx(LPVOID,DWORD);
110		void CoUninitialize();
111		HRESULT CoGetMalloc(DWORD,LPMALLOC*);
112		DWORD CoGetCurrentProcess();
113		HRESULT CoRegisterMallocSpy(LPMALLOCSPY);
114		HRESULT CoRevokeMallocSpy();
115		HRESULT CoCreateStandardMalloc(DWORD,IMalloc**);
116		//#ifdef DBG
117		ULONG DebugCoGetRpcFault();
118		void DebugCoSetRpcFault(ULONG);
119		//#endif
120		HRESULT CoGetClassObject(REFCLSID,DWORD,COSERVERINFO,REFIID,PVOID);
121		HRESULT CoRegisterClassObject(REFCLSID,LPUNKNOWN,DWORD,DWORD,PDWORD);
122		HRESULT CoRevokeClassObject(DWORD);
123		HRESULT CoGetMarshalSizeMax(ULONG*,REFIID,LPUNKNOWN,DWORD,PVOID,DWORD);
124		HRESULT CoMarshalInterface(LPSTREAM,REFIID,LPUNKNOWN,DWORD,PVOID,DWORD);
125		HRESULT CoUnmarshalInterface(LPSTREAM,REFIID,PVOID*);
126		HRESULT CoMarshalHresult(LPSTREAM,HRESULT);
127		HRESULT CoUnmarshalHresult(LPSTREAM,HRESULT*);
128		HRESULT CoReleaseMarshalData(LPSTREAM);
129		HRESULT CoDisconnectObject(LPUNKNOWN,DWORD);
130		HRESULT CoLockObjectExternal(LPUNKNOWN,BOOL,BOOL);
131		HRESULT CoGetStandardMarshal(REFIID,LPUNKNOWN,DWORD,PVOID,DWORD,LPMARSHAL*);
132		HRESULT CoGetStdMarshalEx(LPUNKNOWN,DWORD,LPUNKNOWN*);
133		BOOL CoIsHandlerConnected(LPUNKNOWN);
134		BOOL CoHasStrongExternalConnections(LPUNKNOWN);
135		HRESULT CoMarshalInterThreadInterfaceInStream(REFIID,LPUNKNOWN,LPSTREAM*);
136		HRESULT CoGetInterfaceAndReleaseStream(LPSTREAM,REFIID,PVOID*);
137		HRESULT CoCreateFreeThreadedMarshaler(LPUNKNOWN,LPUNKNOWN*);
138		HINSTANCE CoLoadLibrary(LPOLESTR,BOOL);
139		void CoFreeLibrary(HINSTANCE);
140		void CoFreeAllLibraries();
141		void CoFreeUnusedLibraries();
142		HRESULT CoCreateInstance(REFCLSID,LPUNKNOWN,DWORD,REFIID,PVOID*);
143		HRESULT CoCreateInstanceEx(REFCLSID,IUnknown,DWORD,COSERVERINFO,DWORD,MULTI_QI*);
144		HRESULT StringFromCLSID(REFCLSID,LPOLESTR*);
145		HRESULT CLSIDFromString(LPOLESTR,LPCLSID);
146		HRESULT StringFromIID(REFIID,LPOLESTR*);
147		HRESULT IIDFromString(LPOLESTR,LPIID);
148		BOOL CoIsOle1Class(REFCLSID);
149		HRESULT ProgIDFromCLSID(REFCLSID,LPOLESTR*);
150		HRESULT CLSIDFromProgID(LPCOLESTR,LPCLSID);
151		int StringFromGUID2(REFGUID,LPOLESTR,int);
152		HRESULT CoCreateGuid(GUID*);
153		BOOL CoFileTimeToDosDateTime(FILETIME*,LPWORD,LPWORD);
154		BOOL CoDosDateTimeToFileTime(WORD,WORD,FILETIME*);
155		HRESULT CoFileTimeNow(FILETIME*);
156		HRESULT CoRegisterMessageFilter(LPMESSAGEFILTER,LPMESSAGEFILTER*);
157		HRESULT CoGetTreatAsClass(REFCLSID,LPCLSID);
158		HRESULT CoTreatAsClass(REFCLSID,REFCLSID);
159		HRESULT DllGetClassObject(REFCLSID,REFIID,PVOID*);
160		HRESULT DllCanUnloadNow();
161		PVOID CoTaskMemAlloc(ULONG);
162		PVOID CoTaskMemRealloc(PVOID,ULONG);
163		void CoTaskMemFree(PVOID);
164		HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*);
165		HRESULT CreateDataCache(LPUNKNOWN,REFCLSID,REFIID,PVOID*);
166		HRESULT StgCreateDocfile(OLECHAR,DWORD,DWORD,IStorage*);
167		HRESULT StgCreateDocfileOnILockBytes(ILockBytes,DWORD,DWORD,IStorage*);
168		HRESULT StgOpenStorage(OLECHAR,IStorage,DWORD,SNB,DWORD,IStorage**);
169		HRESULT StgOpenStorageOnILockBytes(ILockBytes,IStorage,DWORD,SNB,DWORD,IStorage**);
170		HRESULT StgIsStorageFile(OLECHAR*);
171		HRESULT StgIsStorageILockBytes(ILockBytes*);
172		HRESULT StgSetTimes(OLECHAR ,FILETIME ,FILETIME ,FILETIME );
173		HRESULT StgCreateStorageEx(WCHAR,DWORD,DWORD,DWORD,STGOPTIONS,void,REFIID,void*);
174		HRESULT StgOpenStorageEx(WCHAR,DWORD,DWORD,DWORD,STGOPTIONS,void,REFIID,void*);
175		HRESULT BindMoniker(LPMONIKER,DWORD,REFIID,PVOID*);
176		HRESULT CoGetObject(LPCWSTR,BIND_OPTS,REFIID,void*);
177		HRESULT MkParseDisplayName(LPBC,LPCOLESTR,ULONG,LPMONIKER);
178		HRESULT MonikerRelativePathTo(LPMONIKER,LPMONIKER,LPMONIKER*,BOOL);
179		HRESULT MonikerCommonPrefixWith(LPMONIKER,LPMONIKER,LPMONIKER*);
180		HRESULT CreateBindCtx(DWORD,LPBC*);
181		HRESULT CreateGenericComposite(LPMONIKER,LPMONIKER,LPMONIKER*);
182		HRESULT GetClassFile (LPCOLESTR,CLSID*);
183		HRESULT CreateFileMoniker(LPCOLESTR,LPMONIKER*);
184		HRESULT CreateItemMoniker(LPCOLESTR,LPCOLESTR,LPMONIKER*);
185		HRESULT CreateAntiMoniker(LPMONIKER*);
186		HRESULT CreatePointerMoniker(LPUNKNOWN,LPMONIKER*);
187		HRESULT GetRunningObjectTable(DWORD,LPRUNNINGOBJECTTABLE*);
188		HRESULT CoInitializeSecurity(PSECURITY_DESCRIPTOR,LONG,SOLE_AUTHENTICATION_SERVICE, void,DWORD,DWORD,void,DWORD,void);
189		HRESULT CoGetCallContext(REFIID,void**);
190		HRESULT CoQueryProxyBlanket(IUnknown, DWORD,DWORD,OLECHAR,DWORD,DWORD,RPC_AUTH_IDENTITY_HANDLE,DWORD*);
191		HRESULT CoSetProxyBlanket(IUnknown,DWORD,DWORD,OLECHAR,DWORD,DWORD,RPC_AUTH_IDENTITY_HANDLE, DWORD);
192		HRESULT CoCopyProxy(IUnknown,IUnknown*);
193		HRESULT CoQueryClientBlanket(DWORD,DWORD,OLECHAR*, DWORD,DWORD,RPC_AUTHZ_HANDLE,DWORD*);
194		HRESULT CoImpersonateClient();
195		HRESULT CoRevertToSelf();
196		HRESULT CoQueryAuthenticationServices(DWORD, SOLE_AUTHENTICATION_SERVICE*);
197		HRESULT CoSwitchCallContext(IUnknown,IUnknown*);
198		HRESULT CoGetInstanceFromFile(COSERVERINFO, CLSID,IUnknown,DWORD,DWORD,OLECHAR,DWORD,MULTI_QI*);
199		HRESULT CoGetInstanceFromIStorage(COSERVERINFO,CLSID, IUnknown,DWORD, IStorage, DWORD,MULTI_QI*);
200		ULONG CoAddRefServerProcess();
201		ULONG CoReleaseServerProcess();
202		HRESULT CoResumeClassObjects();
203		HRESULT CoSuspendClassObjects();
204		HRESULT CoGetPSClsid(REFIID,CLSID*);
205		HRESULT CoRegisterPSClsid(REFIID,REFCLSID);
206		}
	98	alias HRESULT function(REFCLSID, REFIID, PVOID*) LPFNGETCLASSOBJECT;
	99	alias HRESULT function() LPFNCANUNLOADNOW;
	100
	101	DWORD CoBuildVersion();
	102	HRESULT CoInitialize(PVOID);
	103	HRESULT CoInitializeEx(LPVOID, DWORD);
	104	void CoUninitialize();
	105	HRESULT CoGetMalloc(DWORD, LPMALLOC*);
	106	DWORD CoGetCurrentProcess();
	107	HRESULT CoRegisterMallocSpy(LPMALLOCSPY);
	108	HRESULT CoRevokeMallocSpy();
	109	HRESULT CoCreateStandardMalloc(DWORD, IMalloc**);
	110	//#ifdef DBG
	111	ULONG DebugCoGetRpcFault();
	112	void DebugCoSetRpcFault(ULONG);
	113	//#endif
	114	HRESULT CoGetClassObject(REFCLSID, DWORD, COSERVERINFO, REFIID, PVOID);
	115	HRESULT CoRegisterClassObject(REFCLSID, LPUNKNOWN, DWORD, DWORD, PDWORD);
	116	HRESULT CoRevokeClassObject(DWORD);
	117	HRESULT CoGetMarshalSizeMax(ULONG*, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
	118	HRESULT CoMarshalInterface(LPSTREAM, REFIID, LPUNKNOWN, DWORD, PVOID, DWORD);
	119	HRESULT CoUnmarshalInterface(LPSTREAM, REFIID, PVOID*);
	120	HRESULT CoMarshalHresult(LPSTREAM, HRESULT);
	121	HRESULT CoUnmarshalHresult(LPSTREAM, HRESULT*);
	122	HRESULT CoReleaseMarshalData(LPSTREAM);
	123	HRESULT CoDisconnectObject(LPUNKNOWN, DWORD);
	124	HRESULT CoLockObjectExternal(LPUNKNOWN, BOOL, BOOL);
	125	HRESULT CoGetStandardMarshal(REFIID, LPUNKNOWN, DWORD, PVOID, DWORD, LPMARSHAL*);
	126	HRESULT CoGetStdMarshalEx(LPUNKNOWN, DWORD, LPUNKNOWN*);
	127	BOOL CoIsHandlerConnected(LPUNKNOWN);
	128	BOOL CoHasStrongExternalConnections(LPUNKNOWN);
	129	HRESULT CoMarshalInterThreadInterfaceInStream(REFIID, LPUNKNOWN, LPSTREAM*);
	130	HRESULT CoGetInterfaceAndReleaseStream(LPSTREAM, REFIID, PVOID*);
	131	HRESULT CoCreateFreeThreadedMarshaler(LPUNKNOWN, LPUNKNOWN*);
	132	HINSTANCE CoLoadLibrary(LPOLESTR, BOOL);
	133	void CoFreeLibrary(HINSTANCE);
	134	void CoFreeAllLibraries();
	135	void CoFreeUnusedLibraries();
	136	HRESULT CoCreateInstance(REFCLSID, LPUNKNOWN, DWORD, REFIID, PVOID*);
	137	HRESULT CoCreateInstanceEx(REFCLSID, IUnknown, DWORD, COSERVERINFO, DWORD, MULTI_QI*);
	138	HRESULT StringFromCLSID(REFCLSID, LPOLESTR*);
	139	HRESULT CLSIDFromString(LPOLESTR, LPCLSID);
	140	HRESULT StringFromIID(REFIID, LPOLESTR*);
	141	HRESULT IIDFromString(LPOLESTR, LPIID);
	142	BOOL CoIsOle1Class(REFCLSID);
	143	HRESULT ProgIDFromCLSID(REFCLSID, LPOLESTR*);
	144	HRESULT CLSIDFromProgID(LPCOLESTR, LPCLSID);
	145	int StringFromGUID2(REFGUID, LPOLESTR, int);
	146	HRESULT CoCreateGuid(GUID*);
	147	BOOL CoFileTimeToDosDateTime(FILETIME*, LPWORD, LPWORD);
	148	BOOL CoDosDateTimeToFileTime(WORD, WORD, FILETIME*);
	149	HRESULT CoFileTimeNow(FILETIME*);
	150	HRESULT CoRegisterMessageFilter(LPMESSAGEFILTER, LPMESSAGEFILTER*);
	151	HRESULT CoGetTreatAsClass(REFCLSID, LPCLSID);
	152	HRESULT CoTreatAsClass(REFCLSID, REFCLSID);
	153	HRESULT DllGetClassObject(REFCLSID, REFIID, PVOID*);
	154	HRESULT DllCanUnloadNow();
	155	PVOID CoTaskMemAlloc(ULONG);
	156	PVOID CoTaskMemRealloc(PVOID, ULONG);
	157	void CoTaskMemFree(PVOID);
	158	HRESULT CreateDataAdviseHolder(LPDATAADVISEHOLDER*);
	159	HRESULT CreateDataCache(LPUNKNOWN, REFCLSID, REFIID, PVOID*);
	160	HRESULT StgCreateDocfile(OLECHAR, DWORD, DWORD, IStorage*);
	161	HRESULT StgCreateDocfileOnILockBytes(ILockBytes, DWORD, DWORD, IStorage*);
	162	HRESULT StgOpenStorage(OLECHAR, IStorage, DWORD, SNB, DWORD, IStorage**);
	163	HRESULT StgOpenStorageOnILockBytes(ILockBytes, IStorage, DWORD, SNB, DWORD, IStorage**);
	164	HRESULT StgIsStorageFile(OLECHAR*);
	165	HRESULT StgIsStorageILockBytes(ILockBytes*);
	166	HRESULT StgSetTimes(OLECHAR , FILETIME , FILETIME , FILETIME );
	167	HRESULT StgCreateStorageEx(WCHAR, DWORD, DWORD, DWORD, STGOPTIONS, void, REFIID, void*);
	168	HRESULT StgOpenStorageEx(WCHAR, DWORD, DWORD, DWORD, STGOPTIONS, void, REFIID, void*);
	169	HRESULT BindMoniker(LPMONIKER, DWORD, REFIID, PVOID*);
	170	HRESULT CoGetObject(LPCWSTR, BIND_OPTS, REFIID, void*);
	171	HRESULT MkParseDisplayName(LPBC, LPCOLESTR, ULONG, LPMONIKER);
	172	HRESULT MonikerRelativePathTo(LPMONIKER, LPMONIKER, LPMONIKER*, BOOL);
	173	HRESULT MonikerCommonPrefixWith(LPMONIKER, LPMONIKER, LPMONIKER*);
	174	HRESULT CreateBindCtx(DWORD, LPBC*);
	175	HRESULT CreateGenericComposite(LPMONIKER, LPMONIKER, LPMONIKER*);
	176	HRESULT GetClassFile (LPCOLESTR, CLSID*);
	177	HRESULT CreateFileMoniker(LPCOLESTR, LPMONIKER*);
	178	HRESULT CreateItemMoniker(LPCOLESTR, LPCOLESTR, LPMONIKER*);
	179	HRESULT CreateAntiMoniker(LPMONIKER*);
	180	HRESULT CreatePointerMoniker(LPUNKNOWN, LPMONIKER*);
	181	HRESULT GetRunningObjectTable(DWORD, LPRUNNINGOBJECTTABLE*);
	182	HRESULT CoInitializeSecurity(PSECURITY_DESCRIPTOR, LONG, SOLE_AUTHENTICATION_SERVICE, void, DWORD, DWORD, void, DWORD, void);
	183	HRESULT CoGetCallContext(REFIID, void**);
	184	HRESULT CoQueryProxyBlanket(IUnknown, DWORD, DWORD, OLECHAR, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE, DWORD*);
	185	HRESULT CoSetProxyBlanket(IUnknown, DWORD, DWORD, OLECHAR, DWORD, DWORD, RPC_AUTH_IDENTITY_HANDLE, DWORD);
	186	HRESULT CoCopyProxy(IUnknown, IUnknown*);
	187	HRESULT CoQueryClientBlanket(DWORD, DWORD, OLECHAR*, DWORD, DWORD, RPC_AUTHZ_HANDLE, DWORD*);
	188	HRESULT CoImpersonateClient();
	189	HRESULT CoRevertToSelf();
	190	HRESULT CoQueryAuthenticationServices(DWORD, SOLE_AUTHENTICATION_SERVICE*);
	191	HRESULT CoSwitchCallContext(IUnknown, IUnknown*);
	192	HRESULT CoGetInstanceFromFile(COSERVERINFO, CLSID, IUnknown, DWORD, DWORD, OLECHAR, DWORD, MULTI_QI*);
	193	HRESULT CoGetInstanceFromIStorage(COSERVERINFO, CLSID, IUnknown, DWORD, IStorage, DWORD, MULTI_QI*);
	194	ULONG CoAddRefServerProcess();
	195	ULONG CoReleaseServerProcess();
	196	HRESULT CoResumeClassObjects();
	197	HRESULT CoSuspendClassObjects();
	198	HRESULT CoGetPSClsid(REFIID, CLSID*);
	199	HRESULT CoRegisterPSClsid(REFIID, REFCLSID);
	200	}

trunk/win32/objfwd.d

r135	r155
1	1	/***********************************************************************\
2		* ~~objfwd.d~~ *
	2	* objfwd.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.objfwd;
	11
11	12	private import win32.objidl;
12	13

trunk/win32/ocidl.d

r146	r155
11	11	module win32.ocidl;
12	12
13		private import win32.ole2;
14		private import win32.wingdi; // for TEXTMETRICW
	13	private import win32.ole2, win32.oleidl, win32.oaidl, win32.objfwd,
	14	win32.windef, win32.wtypes;
	15	private import win32.objidl; // for CLIPFORMAT
	16	private import win32.wingdi; // for TEXTMETRICW
15	17	private import win32.winuser; // for LPMSG
16		~~private import win32.windef, win32.wtypes;~~
17		~~private import win32.objidl; // for CLIPFORMAT~~
18		~~private import win32.oleidl;~~
19		~~private import win32.oaidl;~~
20		~~private import win32.objfwd;~~
21	18
22	19	interface IBindHost : public IUnknown {}

trunk/win32/odbcinst.d

r142	r155
1	1	/***********************************************************************\
2		* ~~sql.d~~ *
	2	* odbcinst.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.odbcinst;
	11
11	12	import win32.sql;
12	13	private import win32.windef;
13	14
14		// FIXME: The Unicode/Ansi functions situation is a mess. How do the xxxA versions of these functions fit into the scheme?
	15	/* FIXME: The Unicode/Ansi functions situation is a mess. How do the xxxA
	16	* versions of these functions fit into the scheme?
	17	*/
15	18
16	19	// SQLConfigDataSource()

trunk/win32/ole2.d

r146	r155
1	1	/***********************************************************************\
2		* ~~ole2.d~~ *
	2	* ole2.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.ole2;
11	11	pragma(lib, "ole32.lib");
12		public import win32.winerror;
13		public import win32.objbase;
14		public import win32.olectlid;
15		public import win32.oleauto;
16		public import win32.oleidl;
	12
	13	public import win32.basetyps, win32.objbase, win32.oleauto, win32.olectlid,
	14	win32.oleidl, win32.unknwn, win32.winerror;
	15	private import win32.objfwd, win32.objidl, win32.windef, win32.wtypes;
17	16	private import win32.winuser; // for LPMSG
18		~~private import win32.windef;~~
19		~~private import win32.objfwd;~~
20		~~private import win32.objidl;~~
21		~~private import win32.wtypes;~~
22		~~public import win32.unknwn;~~
23		~~public import win32.basetyps;~~
24
25	17
26	18	const E_DRAW = VIEW_E_DRAW;
…	…
44	36
45	37	align(8):
46		struct OLESTREAM{
	38	struct OLESTREAM {
47	39	LPOLESTREAMVTBL lpstbl;
48	40	}
…	…
50	42
51	43	extern (Windows) {
52		struct OLESTREAMVTBL{
	44	struct OLESTREAMVTBL {
53	45	DWORD function (LPOLESTREAM, void*, DWORD) Get;
54	46	DWORD function (LPOLESTREAM, void*, DWORD) Put;

trunk/win32/ole2ver.d

r99	r155
1		// Public domain.
	1	/***********************************************************************\
	2	* ole2ver.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
2	10	module win32.ole2ver;
3	11

trunk/win32/oleacc.d

r146	r155
1	1	/***********************************************************************\
2		* ~~oleacc.d~~ *
	2	* oleacc.d *
3	3	* *
4	4	* Windows API header module *
…	…
11	11	pragma(lib, "oleacc.lib");
12	12
13		private import win32.oaidl;
14		private import win32.wtypes;
15		private import win32.basetyps;
16		private import win32.windef;
17		private import win32.unknwn;
	13	private import win32.basetyps, win32.oaidl, win32.unknwn, win32.wtypes,
	14	win32.windef;
18	15
19	16	enum {

trunk/win32/oleauto.d

r146	r155
12	12
13	13	import win32.oaidl;
14		private import win32.windef;
15		private import win32.unknwn;
16		private import win32.basetyps;
17		private import win32.wtypes;
	14	private import win32.basetyps, win32.unknwn, win32.windef, win32.wtypes;
18	15	private import win32.winbase; // for SYSTEMTIME
19	16

trunk/win32/olectl.d

r146	r155
1	1	/***********************************************************************\
2		* ~~olectl.d~~ *
	2	* olectl.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.olectl;
	11
10	12	// In conversion from MinGW, the following was deleted:
11		//#define FONTSIZE(n) {n##0000,0}
12
13		module win32.olectl;
14
15		import win32.ocidl;
16		import win32.olectlid;
17		private import win32.wingdi;
18		private import win32.wtypes;
19		private import win32.oleauto;
20		private import win32.winuser;
21		private import win32.winerror;
22		private import win32.windef, win32.wtypes, win32.unknwn, win32.basetyps;
23		private import win32.oaidl, win32.objfwd;
	13	//#define FONTSIZE(n) {n##0000, 0}
	14
	15	import win32.ocidl, win32.olectlid;
	16	private import win32.basetyps, win32.oaidl, win32.oleauto, win32.unknwn,
	17	win32.windef, win32.wingdi, win32.winuser, win32.wtypes;
	18	private import win32.ntdef; // for NTSTATUS
	19	private import win32.objfwd; // for LPSTREAM
	20	private import win32.winerror; // for SCODE
24	21
25	22
26	23	private {
27		// These replace C macros.
28		template ITF_ERROR_SCODE_FOR_D(int c)
29		{
30		const SCODE ITF_ERROR_SCODE_FOR_D = (SEVERITY_ERROR << 31) \| (FACILITY_ITF << 16) \| c;
31		}
32
33		template ITF_SUCCESS_SCODE_FOR_D(int c)
34		{
35		const SCODE ITF_SUCCESS_SCODE_FOR_D = (SEVERITY_SUCCESS << 31) \| (FACILITY_ITF << 16) \| c;
36		}
37
38		template STD_CTL_SCODE(int c)
39		{
40		const SCODE STD_CTL_SCODE = (SEVERITY_ERROR << 31) \| (FACILITY_CONTROL << 16) \| c;
41		}
	24	// These replace C macros.
	25	template ITF_ERROR_SCODE_FOR_D(int c)
	26	{
	27	const SCODE ITF_ERROR_SCODE_FOR_D
	28	= (SEVERITY_ERROR << 31) \| (FACILITY_ITF << 16) \| c;
	29	}
	30
	31	template ITF_SUCCESS_SCODE_FOR_D(int c)
	32	{
	33	const SCODE ITF_SUCCESS_SCODE_FOR_D
	34	= (SEVERITY_SUCCESS << 31) \| (FACILITY_ITF << 16) \| c;
	35	}
	36
	37	template STD_CTL_SCODE(int c)
	38	{
	39	const SCODE STD_CTL_SCODE
	40	= (SEVERITY_ERROR << 31) \| (FACILITY_CONTROL << 16) \| c;
	41	}
42	42	}
43	43
…	…
384	384	HRESULT DllRegisterServer();
385	385	HRESULT DllUnregisterServer();
386		HRESULT OleCreateFontIndirect(LPFONTDESC,~~REFIID,~~PVOID*);
387		HRESULT OleCreatePictureIndirect(LPPICTDESC,~~REFIID,BOOL,~~PVOID*);
388		HRESULT OleCreatePropertyFrame(HWND,~~UINT,UINT,LPCOLESTR,ULONG,LPUNKNOWN*,ULONG,LPCLSID,LCID,DWORD,~~PVOID);
	386	HRESULT OleCreateFontIndirect(LPFONTDESC, REFIID, PVOID*);
	387	HRESULT OleCreatePictureIndirect(LPPICTDESC, REFIID, BOOL, PVOID*);
	388	HRESULT OleCreatePropertyFrame(HWND, UINT, UINT, LPCOLESTR, ULONG, LPUNKNOWN*, ULONG, LPCLSID, LCID, DWORD, PVOID);
389	389	HRESULT OleCreatePropertyFrameIndirect(LPOCPFIPARAMS);
390		HCURSOR OleIconToCursor(HINSTANCE,HICON);
391		HRESULT OleLoadPicture(LPSTREAM,~~LONG,BOOL,REFIID,~~PVOID*);
392		HRESULT OleLoadPictureEx(LPSTREAM,~~LONG,BOOL,REFIID,DWORD,DWORD,DWORD,~~LPVOID*);
393		HRESULT OleLoadPicturePath(LPOLESTR,~~LPUNKNOWN,DWORD,OLE_COLOR,REFIID,~~LPVOID*);
394		HRESULT OleLoadPictureFile(VARIANT,LPDISPATCH*);
395		HRESULT OleLoadPictureFileEx(VARIANT,~~DWORD,DWORD,DWORD,~~LPDISPATCH*);
396		HRESULT OleSavePictureFile(LPDISPATCH,BSTR);
397		HRESULT OleTranslateColor(OLE_COLOR,~~HPALETTE,~~COLORREF*);
398		}
	390	HCURSOR OleIconToCursor(HINSTANCE, HICON);
	391	HRESULT OleLoadPicture(LPSTREAM, LONG, BOOL, REFIID, PVOID*);
	392	HRESULT OleLoadPictureEx(LPSTREAM, LONG, BOOL, REFIID, DWORD, DWORD, DWORD, LPVOID*);
	393	HRESULT OleLoadPicturePath(LPOLESTR, LPUNKNOWN, DWORD, OLE_COLOR, REFIID, LPVOID*);
	394	HRESULT OleLoadPictureFile(VARIANT, LPDISPATCH*);
	395	HRESULT OleLoadPictureFileEx(VARIANT, DWORD, DWORD, DWORD, LPDISPATCH*);
	396	HRESULT OleSavePictureFile(LPDISPATCH, BSTR);
	397	HRESULT OleTranslateColor(OLE_COLOR, HPALETTE, COLORREF*);
	398	}

trunk/win32/olectlid.d

r141	r155
1	1	/***********************************************************************\
2		* ~~olectlid.d~~ *
	2	* olectlid.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.olectlid;
	11
11	12	private import win32.basetyps;
12	13

trunk/win32/oledlg.d

r146	r155
1	1	/***********************************************************************\
2		* ~~oledlg.d~~ *
	2	* oledlg.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.oledlg;
11	11
12		import win32.windows;
13		import win32.shellapi;
14		import win32.commdlg;
15		import win32.ole2;
16
17		import win32.dlgs;
18		import win32.prsht;
19		private import win32.winnt, win32.objidl, win32.objfwd;
20		private import win32.winbase;
	12	import win32.commdlg, win32.dlgs, win32.ole2, win32.prsht, win32.shellapi,
	13	win32.windows;
	14	private import win32.winbase, win32.objidl, win32.objfwd, win32.winnt;
21	15
22	16	// FIXME: remove inherited methods from interface definitions

trunk/win32/oleidl.d

r146	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.oleidl;
	11
10	12	// DAC: This is defined in ocidl !!
11	13	// what is it doing in here?
12	14	//alias IEnumOleUndoUnits* LPENUMOLEUNDOUNITS;
13	15
14		module win32.oleidl;
15
	16	private import win32.basetyps, win32.objidl, win32.unknwn, win32.windef,
	17	win32.winuser, win32.wtypes;
16	18	private import win32.objfwd; // for LPMONIKER
17		~~private import win32.windef;~~
18		~~private import win32.basetyps;~~
19		~~private import win32.unknwn;~~
20		~~private import win32.wtypes;~~
21		~~private import win32.objidl;~~
22		~~private import win32.winuser;~~
23	19	private import win32.wingdi; // for LPLOGPALETTE
24	20

trunk/win32/prsht.d

r141	r155
11	11	module win32.prsht;
12	12	pragma(lib, "comctl32.lib");
13		private import win32.w32api;
14		private import win32.windef;
15		private import win32.winuser;
	13
	14	private import win32.w32api, win32.windef, win32.winuser;
16	15
17	16	const MAXPROPPAGES = 100;
…	…
189	188	}
190	189
191		alias UINT function(HWND,UINT,LPPROPSHEETPAGEA)* LPFNPSPCALLBACKA;
192		alias UINT function(HWND,UINT,LPPROPSHEETPAGEW)* LPFNPSPCALLBACKW;
193		alias int function(HWND,UINT,LPARAM)* PFNPROPSHEETCALLBACK;
	190	alias UINT function(HWND, UINT, LPPROPSHEETPAGEA) LPFNPSPCALLBACKA;
	191	alias UINT function(HWND, UINT, LPPROPSHEETPAGEW) LPFNPSPCALLBACKW;
	192	alias int function(HWND, UINT, LPARAM) PFNPROPSHEETCALLBACK;
194	193
195	194	align(4):
…	…
313	312	alias PROPSHEETHEADERW* LPPROPSHEETHEADERW, LPCPROPSHEETHEADERW;
314	313
315		alias BOOL function(HPROPSHEETPAGE,LPARAM)* LPFNADDPROPSHEETPAGE;
316		alias BOOL function(LPVOID,LPFNADDPROPSHEETPAGE,LPARAM)* LPFNADDPROPSHEETPAGES;
	314	alias BOOL function(HPROPSHEETPAGE, LPARAM) LPFNADDPROPSHEETPAGE;
	315	alias BOOL function(LPVOID, LPFNADDPROPSHEETPAGE, LPARAM)
	316	LPFNADDPROPSHEETPAGES;
317	317
318	318	struct PSHNOTIFY {
…	…
356	356	}
357	357
358		BOOL PropSheet_SetCurSel(HWND hPropSheetDlg,HPROPSHEETPAGE hpage,HPROPSHEETPAGE index) {
359		return cast(BOOL)SendMessage(hPropSheetDlg,PSM_SETCURSEL,cast(WPARAM)index,cast(LPARAM)hpage);
360		}
361
362		VOID PropSheet_RemovePage(HWND hPropSheetDlg,int index,HPROPSHEETPAGE hpage) {
363		SendMessage(hPropSheetDlg,PSM_REMOVEPAGE,index,cast(LPARAM)hpage);
	358	BOOL PropSheet_SetCurSel(HWND hPropSheetDlg, HPROPSHEETPAGE hpage,
	359	HPROPSHEETPAGE index) {
	360	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_SETCURSEL,
	361	cast(WPARAM) index, cast(LPARAM) hpage);
	362	}
	363
	364	VOID PropSheet_RemovePage(HWND hPropSheetDlg, int index, HPROPSHEETPAGE hpage) {
	365	SendMessage(hPropSheetDlg, PSM_REMOVEPAGE, index, cast(LPARAM) hpage);
364	366	}
365	367
366	368	BOOL PropSheet_AddPage(HWND hPropSheetDlg, HPROPSHEETPAGE hpage) {
367		return cast(BOOL)SendMessage(hPropSheetDlg,PSM_ADDPAGE,0,cast(LPARAM)hpage);
	369	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_ADDPAGE,
	370	0, cast(LPARAM) hpage);
368	371	}
369	372
370	373	VOID PropSheet_Changed(HWND hPropSheetDlg, HWND hwndPage) {
371		SendMessage(hPropSheetDlg,~~PSM_CHANGED,cast(WPARAM)hwndPage,~~0);
	374	SendMessage(hPropSheetDlg, PSM_CHANGED, cast(WPARAM) hwndPage, 0);
372	375	}
373	376
374	377	VOID PropSheet_RestartWindows(HWND hPropSheetDlg) {
375		SendMessage(hPropSheetDlg,~~PSM_RESTARTWINDOWS,0,~~0);
	378	SendMessage(hPropSheetDlg, PSM_RESTARTWINDOWS, 0, 0);
376	379	}
377	380
378	381	VOID PropSheet_RebootSystem(HWND hPropSheetDlg) {
379		SendMessage(hPropSheetDlg,~~PSM_REBOOTSYSTEM,0,~~0);
	382	SendMessage(hPropSheetDlg, PSM_REBOOTSYSTEM, 0, 0);
380	383	}
381	384
382	385	VOID PropSheet_CancelToClose(HWND hPropSheetDlg) {
383		SendMessage(hPropSheetDlg,~~PSM_CANCELTOCLOSE,0,~~0);
384		}
385
386		int PropSheet_QuerySiblings(HWND hPropSheetDlg,~~WPARAM param1,~~LPARAM param2) {
387		return SendMessage(hPropSheetDlg,~~PSM_QUERYSIBLINGS,param1,~~param2);
	386	SendMessage(hPropSheetDlg, PSM_CANCELTOCLOSE, 0, 0);
	387	}
	388
	389	int PropSheet_QuerySiblings(HWND hPropSheetDlg, WPARAM param1, LPARAM param2) {
	390	return SendMessage(hPropSheetDlg, PSM_QUERYSIBLINGS, param1, param2);
388	391	}
389	392
390	393	VOID PropSheet_UnChanged(HWND hPropSheetDlg, HWND hwndPage) {
391		SendMessage(hPropSheetDlg,~~PSM_UNCHANGED,cast(WPARAM)hwndPage,~~0);
	394	SendMessage(hPropSheetDlg, PSM_UNCHANGED, cast(WPARAM) hwndPage, 0);
392	395	}
393	396
394	397	BOOL PropSheet_Apply(HWND hPropSheetDlg) {
395		return cast(BOOL)~~SendMessage(hPropSheetDlg,PSM_APPLY,0,~~0);
396		}
397
398		VOID PropSheet_SetTitle(HWND hPropSheetDlg,~~DWORD wStyle,~~LPTSTR lpszText) {
399		SendMessage(hPropSheetDlg,~~PSM_SETTITLE,wStyle,cast(LPARAM)~~lpszText);
400		}
401
402		VOID PropSheet_SetWizButtons(HWND hPropSheetDlg,DWORD dwFlags) {
403		PostMessage(hPropSheetDlg,~~PSM_SETWIZBUTTONS,0,cast(LPARAM)~~dwFlags);
	398	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_APPLY, 0, 0);
	399	}
	400
	401	VOID PropSheet_SetTitle(HWND hPropSheetDlg, DWORD wStyle, LPTSTR lpszText) {
	402	SendMessage(hPropSheetDlg, PSM_SETTITLE, wStyle, cast(LPARAM) lpszText);
	403	}
	404
	405	VOID PropSheet_SetWizButtons(HWND hPropSheetDlg, DWORD dwFlags) {
	406	PostMessage(hPropSheetDlg, PSM_SETWIZBUTTONS, 0, cast(LPARAM) dwFlags);
404	407	}
405	408
406	409	BOOL PropSheet_PressButton(HWND hPropSheetDlg, int iButton) {
407		return cast(BOOL)~~SendMessage(hPropSheetDlg,PSM_PRESSBUTTON,iButton,~~0);
408		}
409
410		BOOL PropSheet_SetCurSelByID(HWND hPropSheetDlg,int id) {
411		return cast(BOOL)~~SendMessage(hPropSheetDlg,PSM_SETCURSELID,0,~~id);
412		}
413
414		VOID PropSheet_SetFinishText(HWND hPropSheetDlg,LPTSTR lpszText) {
415		SendMessage(hPropSheetDlg,~~PSM_SETFINISHTEXT,0,cast(LPARAM)~~lpszText);
	410	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_PRESSBUTTON, iButton, 0);
	411	}
	412
	413	BOOL PropSheet_SetCurSelByID(HWND hPropSheetDlg, int id) {
	414	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_SETCURSELID, 0, id);
	415	}
	416
	417	VOID PropSheet_SetFinishText(HWND hPropSheetDlg, LPTSTR lpszText) {
	418	SendMessage(hPropSheetDlg, PSM_SETFINISHTEXT, 0, cast(LPARAM) lpszText);
416	419	}
417	420
418	421	HWND PropSheet_GetTabControl(HWND hPropSheetDlg) {
419		return cast(HWND)~~SendMessage(hPropSheetDlg,PSM_GETTABCONTROL,0,~~0);
	422	return cast(HWND) SendMessage(hPropSheetDlg, PSM_GETTABCONTROL, 0, 0);
420	423	}
421	424
422	425	BOOL PropSheet_IsDialogMessage(HWND hDlg, LPMSG pMsg) {
423		return cast(BOOL)SendMessage(hDlg,PSM_ISDIALOGMESSAGE,0,cast(LPARAM)pMsg);
	426	return cast(BOOL) SendMessage(hDlg, PSM_ISDIALOGMESSAGE,
	427	0, cast(LPARAM) pMsg);
424	428	}
425	429
426	430	HWND PropSheet_GetCurrentPageHwnd(HWND hDlg) {
427		return cast(HWND)SendMessage(hDlg,PSM_GETCURRENTPAGEHWND,0,0);
428		}
429
430		BOOL PropSheet_InsertPage(HWND hPropSheetDlg, WPARAM wInsertAfter, HPROPSHEETPAGE hpage) {
431		return cast(BOOL)SendMessage(hPropSheetDlg,PSM_INSERTPAGE,wInsertAfter,cast(LPARAM)hpage);
432		}
	431	return cast(HWND) SendMessage(hDlg, PSM_GETCURRENTPAGEHWND, 0, 0);
	432	}
	433
	434	BOOL PropSheet_InsertPage(HWND hPropSheetDlg, WPARAM wInsertAfter,
	435	HPROPSHEETPAGE hpage) {
	436	return cast(BOOL) SendMessage(hPropSheetDlg, PSM_INSERTPAGE,
	437	wInsertAfter, cast(LPARAM) hpage);
	438	}

trunk/win32/ras.d

r146	r155
9	9	\***********************************************************************/
10	10	module win32.ras;
11		~~private import win32.lmcons;~~
12		~~private import win32.w32api;~~
13		~~private import win32.windef, win32.basetyps;~~
14
15	11	pragma(lib, "rasapi32.lib");
	12
	13	private import win32.basetyps, win32.lmcons, win32.w32api, win32.windef;
16	14
17	15	align(4):

trunk/win32/raserror.d

r99	r155
1	1	/***********************************************************************\
2		* ~~raserror.d~~ *
	2	* raserror.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.raserror;
11
	11
12	12	enum {
13		SUCCESS = 0,
	13	SUCCESS = 0,
14	14	RASBASE = 600,
15	15	PENDING = RASBASE,

trunk/win32/readme.txt

r153	r155
8	8	The project started off as an improvement of Y. Tomino's translation, but is now officially a derivative of the public domain MinGW Windows headers. However, it is useful to have to hand a copy of Tomino's work (or some other D translation of the Win32 headers) in order to test-compile the modules while the work is in progress.
9	9
10		An up-to-date version of this project can be downloaded from
11		http://pr.stewartsplace.org.uk/d/win32.zip
12		Email me with updates/comments/suggestions/bug reports: smjg@iname.com
	10	The official project page is at
	11
	12	http://www.prowiki.org/wiki4d/wiki.cgi?WindowsAPI
	13
	14	There, you can find the most up-to-date version of the translation, see who is working on each module, assign modules to yourself to work on, and generally discuss the project.
	15
	16	Email me with comments/suggestions/bug reports: smjg@iname.com
13	17
14	18
…	…
17	21	1. Module naming
18	22
19		The name of each module shall be win32.qwert, where qwert.h is the name of the original header file. This ~~is for compatibility with the Tomino translation, but~~ may change in the future.
	23	The name of each module shall be win32.qwert, where qwert.h is the name of the original header file. This may change in the future.
20	24
21	25
…	…
79	83	A few structs use bit fields. Because D doesn't have bit fields, they must be simulated using property getters/setters. See dde.d for an example. Use bool for one-bit members; otherwise use the smallest integer type that will accommodate the required number of bits.
80	84
81		Some structs end with a one-element array, designed to be followed immediately in memory by more elements of the same type. Name such struct members with a leading underscore, and use a property getter to return just the pointer in order to prevent bounds checking.
	85	Some structs end with a one-element array, designed to be followed immediately in memory by more elements of the same type. Name such struct members with a leading underscore, and use a property getter to return just the pointer in order to prevent bounds checking. (A
82	86
83	87
84	88	4. COM interfaces
85	89
86		Translate DECLARE_INTERFACE constructions into D interfaces. See unknwn.d for an example. The macros used to access interface functions become unnecessary and may therefore be removed.
	90	Translate DECLARE_INTERFACE constructions into D interfaces. Be sure to omit inherited members. See unknwn.d for an example. The macros used to access interface functions become unnecessary and may therefore be removed.
87	91
88	92
…	…
107	111	7. Consolidate ANSI/Unicode selection into version blocks
108	112
109		Where #ifdef UNICODE is used to select A/W versions of functions and other identifiers, replace with version (Unicode). Use only aliases, rather than enums or const declarations, within these version blocks. These should be defined in one place at the end of each module, or at the end of some logical section within the module. ~~Consolidate any aliases of these aliases into the alias declarations within these version blocks.~~
	113	Where #ifdef UNICODE is used to select A/W versions of functions and other identifiers, replace with version (Unicode). Use only aliases, rather than enums or const declarations, within these version blocks. These should be defined in one place at the end of each module, or at the end of some logical section within the module.
110	114
111	115	As an exception, reduce string constants to a single declaration of type TCHAR[], bypassing the need to put such a constant in a version block.
	116
	117	Any aliases based on identifiers defined in these version blocks (e.g. pointer type aliases without A/W) should be declared after the version blocks.
112	118
113	119
…	…
116	122	Every module that uses this conditional compilation must privately import win32.w32api, which defines the constants used to set the minimum version of Windows an application supports.
117	123
118		Unlike with the C headers, the programmer is expected to specify both the minimum Windows 9x version and the minimum Windows NT version, so both _WIN32_WINDOWS and _WIN32_WINNT are defined in any project. Conditional compilation must therefore, in general, involve checking the values of both constants ~~either directly or indirectly. The WINVER and _WIN32_WINNT_ONLY constants are also~~ defined for syntactic sugar.
	124	Unlike with the C headers, the programmer is expected to specify both the minimum Windows 9x version and the minimum Windows NT version, so both _WIN32_WINDOWS and _WIN32_WINNT are defined in any project. Conditional compilation must therefore, in general, involve checking the values of both constants - either directly, using the && operator, or with the help of the WINVER and _WIN32_WINNT_ONLY constants defined for syntactic sugar.
119	125
120	126	Rather than relying on the conditionals in the MinGW headers, it is a good idea to look on http://msdn.microsoft.com/ to see which Windows versions support each entity that is CC'd.
	127
	128	Also available is the _WIN32_IE constant, for functions that rely on a particular version of Internet Explorer being installed.
	129
	130	Exception: To import modules conditionally, always use the version identifiers directly. This is in order to support Build.
121	131
122	132
…	…
124	134
125	135	Use the built-in version (Win32) and version (Win64) to deal with _WIN64 conditional blocks.
	136
	137	Treat STRICT as always defined.
126	138
127	139	For other #ifdefs designed to be specified by the programmer, leave the directive in, commented out. This is pending decision on which to include and which to leave out, and how to name them.
…	…
152	164	Always indent the contents of a { ... } block of any kind by one tab character below the level of that in which it is contained.
153	165
	166	The opening '{' doesn't have a line to itself, and is separated from the function signature, struct identifier, etc. by one space.
	167
	168	Use one space after a comma (e.g. in function signatures), no space before.
	169
154	170
155	171	13. Section heading comments (optional)
…	…
174	190	Sometimes there will be errors due to undefined types or other identifiers. These compiled in C because of the nature of C preprocessor macros, but fail in D where they are treated symbolically. To deal with this, use a private import.
175	191
176		It is a good idea to try compiling under all meaningful configurations of Windows versions:
177
178		* none specified (equivalent to Windows 95/NT 4)
179		* -version=Windows98
180		* -version=WindowsME
181		* -version=WindowsNTonly
182		* -version=Windows2000
183		* -version=Windows98 -version=Windows2000
184		* -version=WindowsME -version=Windows2000
185		* -version=WindowsNTonly -version=Windows2000
186		* -version=WindowsXP
187		* -version=Windows2003
	192	It is a good idea to try compiling under all meaningful configurations of Windows versions. This can be done by using the testcompile.bat file included in the distribution.

trunk/win32/regstr.d

r135	r155
1	1	/***********************************************************************\
2		* ~~regstr.d~~ *
	2	* regstr.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.regstr;
	11
10	12	// TODO: fix possible conflict with shloj. Sort out NEC_98 issue.
11		module win32.regstr;
	13
12	14	private import win32.windef;
13	15

trunk/win32/richedit.d

r141	r155
1	1	/***********************************************************************\
2		* ~~richedit.d~~ *
	2	* richedit.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.richedit;
11		private import win32.windef;
12		private import win32.winuser;
	11
	12	private import win32.windef, win32.winuser;
13	13	private import win32.wingdi; // for LF_FACESIZE
14	14
…	…
23	23	const RICHEDIT_CLASS10A = "RICHEDIT";
24	24
25		const TCHAR []
	25	const TCHAR[]
26	26	CF_RTF = "Rich Text Format",
27	27	CF_RTFNOOBJS = "Rich Text Format Without Objects",

trunk/win32/richole.d

r146	r155
1	1	/***********************************************************************\
2		* ~~richole.d~~ *
	2	* richole.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.richole;
11		private import win32.unknwn;
12		private import win32.~~windef;~~
13		~~private import win32.ole2~~;
	11
	12	private import win32.objfwd, win32.objidl, win32.ole2, win32.unknwn,
	13	win32.windef;
14	14	private import win32.richedit; // for CHARRANGE
15		~~private import win32.objfwd;~~
16		~~private import win32.objidl;~~
17	15
18	16	align(4):

trunk/win32/rpc.d

r127	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.rpc;
10	11
11	12	/* Moved to rpcdecp (duplicate definition).
12		typedef void *I_RPC_HANDLE;
13		alias long RPC_STATUS;
14		// Moved to rpcdce:
15		RpcImpersonateClient
16		RpcRevertToSelf
17
	13	typedef void *I_RPC_HANDLE;
	14	alias long RPC_STATUS;
	15	// Moved to rpcdce:
	16	RpcImpersonateClient
	17	RpcRevertToSelf
18	18	*/
19	19
20		module win32.rpc;
21
22		import win32.unknwn;
	20	public import win32.unknwn;
	21	public import win32.rpcdce; // also pulls in rpcdcep
	22	public import win32.rpcnsi;
	23	public import win32.rpcnterr;
	24	public import win32.winerror;
23	25
24	26	alias MIDL_user_allocate midl_user_allocate;
25	27	alias MIDL_user_free midl_user_free;
26	28
27		~~import win32.rpcdce; // also pulls in rpcdcep~~
28		~~import win32.rpcnsi;~~
29		~~import win32.rpcnterr;~~
30
31		~~import win32.winerror;~~
32
33	29	extern (Windows) {
34		int I_RpcMapWin32Status(RPC_STATUS);
	30	int I_RpcMapWin32Status(RPC_STATUS);
35	31	}

trunk/win32/rpcdce.d

r135	r155
1	1	/***********************************************************************\
2		* ~~rpcdce.d~~ *
	2	* rpcdce.d *
3	3	* *
4		* ~~Windows API header module~~ *
	4	* Windows API header module *
5	5	* *
6		* ~~Translated from MinGW Windows headers~~ *
	6	* Translated from MinGW Windows headers *
7	7	* *
8		* ~~Placed into public domain~~ *
	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.rpcdce;
	11	pragma(lib, "Rpcrt4.lib");
	12
10	13	// TODO: I think MinGW got this wrong. RPC_UNICODE_SUPPORTED should be
11	14	// replaced aliases for version(Unicode)
12		~~module win32.rpcdce;~~
13		~~pragma(lib, "Rpcrt4.lib");~~
14	15
15	16	public import win32.rpcdcep;

trunk/win32/rpcdcep.d

r135	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
10
11	10	module win32.rpcdcep;
12	11
	12	private import win32.basetyps;
13	13	private import win32.w32api;
14	14	private import win32.windef;
15		~~private import win32.basetyps;~~
16	15
17		typedef void *I_RPC_HANDLE;
	16	alias HANDLE I_RPC_HANDLE;
18	17	alias long RPC_STATUS;
19	18
…	…
36	35	}
37	36	struct RPC_SYNTAX_IDENTIFIER {
38		GUID SyntaxGUID;
	37	GUID SyntaxGUID;
39	38	RPC_VERSION SyntaxVersion;
40	39	}
41		alias RPC_SYNTAX_IDENTIFIER * PRPC_SYNTAX_IDENTIFIER;
	40	alias RPC_SYNTAX_IDENTIFIER* PRPC_SYNTAX_IDENTIFIER;
42	41
43	42	struct RPC_MESSAGE {
44	43	HANDLE Handle;
45		uint DataRepresentation;
46		void *Buffer;
47		uint BufferLength;
48		uint ProcNum;
	44	uint DataRepresentation;
	45	void* Buffer;
	46	uint BufferLength;
	47	uint ProcNum;
49	48	PRPC_SYNTAX_IDENTIFIER TransferSyntax;
50		void *RpcInterfaceInformation;
51		void *ReservedForRuntime;
52		void *ManagerEpv;
53		void *ImportContext;
54		uint RpcFlags;
	49	void* RpcInterfaceInformation;
	50	void* ReservedForRuntime;
	51	void* ManagerEpv;
	52	void* ImportContext;
	53	uint RpcFlags;
55	54	}
56		alias RPC_MESSAGE * PRPC_MESSAGE;
	55	alias RPC_MESSAGE* PRPC_MESSAGE;
57	56
58	57	extern (Windows) {
59		alias void function ( PRPC_MESSAGE Message) RPC_DISPATCH_FUNCTION;
	58	alias void function (PRPC_MESSAGE Message) RPC_DISPATCH_FUNCTION;
60	59	}
61	60
62	61	struct RPC_DISPATCH_TABLE {
63	62	uint DispatchTableCount;
64		RPC_DISPATCH_FUNCTION *DispatchTable;
65		int Reserved;
	63	RPC_DISPATCH_FUNCTION* DispatchTable;
	64	int Reserved;
66	65	}
67		alias RPC_DISPATCH_TABLE * PRPC_DISPATCH_TABLE;
	66	alias RPC_DISPATCH_TABLE* PRPC_DISPATCH_TABLE;
68	67
69	68	struct RPC_PROTSEQ_ENDPOINT {
70		ubyte *RpcProtocolSequence;
71		ubyte *Endpoint;
	69	ubyte* RpcProtocolSequence;
	70	ubyte* Endpoint;
72	71	}
73		alias RPC_PROTSEQ_ENDPOINT * PRPC_PROTSEQ_ENDPOINT;
	72	alias RPC_PROTSEQ_ENDPOINT* PRPC_PROTSEQ_ENDPOINT;
74	73
75	74	struct RPC_SERVER_INTERFACE {
76		uint Length;
	75	uint Length;
77	76	RPC_SYNTAX_IDENTIFIER InterfaceId;
78	77	RPC_SYNTAX_IDENTIFIER TransferSyntax;
79		PRPC_DISPATCH_TABLE DispatchTable;
80		uint RpcProtseqEndpointCount;
	78	PRPC_DISPATCH_TABLE DispatchTable;
	79	uint RpcProtseqEndpointCount;
81	80	PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
82		void *DefaultManagerEpv;
83		void *InterpreterInfo;
	81	void* DefaultManagerEpv;
	82	void* InterpreterInfo;
84	83	}
85		alias RPC_SERVER_INTERFACE * PRPC_SERVER_INTERFACE;
	84	alias RPC_SERVER_INTERFACE* PRPC_SERVER_INTERFACE;
86	85
87	86	struct RPC_CLIENT_INTERFACE {
88		uint Length;
	87	uint Length;
89	88	RPC_SYNTAX_IDENTIFIER InterfaceId;
90	89	RPC_SYNTAX_IDENTIFIER TransferSyntax;
91		PRPC_DISPATCH_TABLE DispatchTable;
92		uint RpcProtseqEndpointCount;
	90	PRPC_DISPATCH_TABLE DispatchTable;
	91	uint RpcProtseqEndpointCount;
93	92	PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
94		uint Reserved;
95		void *InterpreterInfo;
	93	uint Reserved;
	94	void* InterpreterInfo;
96	95	}
97		alias RPC_CLIENT_INTERFACE * PRPC_CLIENT_INTERFACE;
	96	alias RPC_CLIENT_INTERFACE* PRPC_CLIENT_INTERFACE;
98	97
99		typedef void *I_RPC_MUTEX;
	98	typedef void* I_RPC_MUTEX;
100	99
101	100	struct RPC_TRANSFER_SYNTAX {
102		GUID Uuid;
	101	GUID Uuid;
103	102	ushort VersMajor;
104	103	ushort VersMinor;
105	104	}
106		alias RPC_STATUS function(void,~~void,~~void*) RPC_BLOCKING_FN;
	105	alias RPC_STATUS function(void, void, void*) RPC_BLOCKING_FN;
107	106
108	107	extern (Windows) {
109		int I_RpcGetBuffer(RPC_MESSAGE*);
110		int I_RpcSendReceive(RPC_MESSAGE*);
111		int I_RpcSend(RPC_MESSAGE*);
112		int I_RpcFreeBuffer(RPC_MESSAGE*);
113		void I_RpcRequestMutex(I_RPC_MUTEX*);
114		void I_RpcClearMutex(I_RPC_MUTEX);
115		void I_RpcDeleteMutex(I_RPC_MUTEX);
116		void * I_RpcAllocate(uint);
117		void I_RpcFree(void*);
118		void I_RpcPauseExecution(uint);
119		alias void function (void*) PRPC_RUNDOWN;
120		int I_RpcMonitorAssociation(HANDLE,PRPC_RUNDOWN,void*);
121		int I_RpcStopMonitorAssociation(HANDLE);
122		HANDLE I_RpcGetCurrentCallHandle();
123		int I_RpcGetAssociationContext(void**);
124		int I_RpcSetAssociationContext(void*);
	108	int I_RpcGetBuffer(RPC_MESSAGE*);
	109	int I_RpcSendReceive(RPC_MESSAGE*);
	110	int I_RpcSend(RPC_MESSAGE*);
	111	int I_RpcFreeBuffer(RPC_MESSAGE*);
	112	void I_RpcRequestMutex(I_RPC_MUTEX*);
	113	void I_RpcClearMutex(I_RPC_MUTEX);
	114	void I_RpcDeleteMutex(I_RPC_MUTEX);
	115	void* I_RpcAllocate(uint);
	116	void I_RpcFree(void*);
	117	void I_RpcPauseExecution(uint);
	118	int I_RpcMonitorAssociation(HANDLE, PRPC_RUNDOWN, void*);
	119	int I_RpcStopMonitorAssociation(HANDLE);
	120	HANDLE I_RpcGetCurrentCallHandle();
	121	int I_RpcGetAssociationContext(void**);
	122	int I_RpcSetAssociationContext(void*);
125	123
126		static if (_WIN32_WINNT_ONLY) {
127		~~int I_RpcNsBindingSetEntryName(HANDLE,uint,~~wchar*);
128		int I_RpcBindingInqDynamicEndpoint(HANDLE, wchar**);
129		} else {
130		~~int I_RpcNsBindingSetEntryName(HANDLE,uint, char~~ *);
131		~~int~~ I_RpcBindingInqDynamicEndpoint(HANDLE, char**);
132		}
	124	static if (_WIN32_WINNT_ONLY) {
	125	int I_RpcNsBindingSetEntryName(HANDLE, uint, wchar*);
	126	int I_RpcBindingInqDynamicEndpoint(HANDLE, wchar**);
	127	} else {
	128	int I_RpcNsBindingSetEntryName(HANDLE, uint, char*);
	129	int I_RpcBindingInqDynamicEndpoint(HANDLE, char**);
	130	}
133	131
134		int I_RpcBindingInqTransportType(HANDLE,uint*);
135		int I_RpcIfInqTransferSyntaxes(HANDLE,RPC_TRANSFER_SYNTAX,uint,uint);
136		int I_UuidCreate(GUID*);
137		int I_RpcBindingCopy(HANDLE,HANDLE*);
138		int I_RpcBindingIsClientLocal(HANDLE,uint*);
139		void I_RpcSsDontSerializeContext();
140		int I_RpcServerRegisterForwardFunction( int function (GUID,RPC_VERSION,GUID,ubyte,void**) );
141		int I_RpcConnectionInqSockBuffSize(uint,uint);
142		int I_RpcConnectionSetSockBuffSize(uint,uint);
143		int I_RpcBindingSetAsync(HANDLE,RPC_BLOCKING_FN);
144		int I_RpcAsyncSendReceive(RPC_MESSAGE,void);
145		int I_RpcGetThreadWindowHandle(void**);
146		int I_RpcServerThreadPauseListening();
147		int I_RpcServerThreadContinueListening();
148		int I_RpcServerUnregisterEndpointA(ubyte,ubyte);
149		int I_RpcServerUnregisterEndpointW(ushort,ushort);
	132	int I_RpcBindingInqTransportType(HANDLE, uint*);
	133	int I_RpcIfInqTransferSyntaxes(HANDLE, RPC_TRANSFER_SYNTAX*, uint,
	134	uint*);
	135	int I_UuidCreate(GUID*);
	136	int I_RpcBindingCopy(HANDLE, HANDLE*);
	137	int I_RpcBindingIsClientLocal(HANDLE, uint*);
	138	void I_RpcSsDontSerializeContext();
	139	int I_RpcServerRegisterForwardFunction(int function (GUID*,
	140	RPC_VERSION, GUID, ubyte, void*));
	141	int I_RpcConnectionInqSockBuffSize(uint, uint);
	142	int I_RpcConnectionSetSockBuffSize(uint, uint);
	143	int I_RpcBindingSetAsync(HANDLE, RPC_BLOCKING_FN);
	144	int I_RpcAsyncSendReceive(RPC_MESSAGE, void);
	145	int I_RpcGetThreadWindowHandle(void**);
	146	int I_RpcServerThreadPauseListening();
	147	int I_RpcServerThreadContinueListening();
	148	int I_RpcServerUnregisterEndpointA(ubyte, ubyte);
	149	int I_RpcServerUnregisterEndpointW(ushort, ushort);
	150
	151	alias void function(void*) PRPC_RUNDOWN;
150	152	}
151	153
152	154	version(Unicode) {
153		alias I_RpcServerUnregisterEndpointW I_RpcServerUnregisterEndpoint;
	155	alias I_RpcServerUnregisterEndpointW I_RpcServerUnregisterEndpoint;
154	156	} else {
155		alias I_RpcServerUnregisterEndpointA I_RpcServerUnregisterEndpoint;
	157	alias I_RpcServerUnregisterEndpointA I_RpcServerUnregisterEndpoint;
156	158	}

trunk/win32/rpcndr.d

r146	r155
9	9	\***********************************************************************/
10	10	module win32.rpcndr;
	11	pragma(lib, "rpcrt4.lib");
	12
11	13	/* Translation notes:
12	14	RPC_CLIENT_ALLOC, RPC_CLIENT_FREE were replaced with PRPC_CLIENT_ALLOC, PRPC_CLIENT_FREE
…	…
17	19	const __RPCNDR_H_VERSION__= 450;
18	20
19		~~private import win32.rpc;~~
20	21	import win32.rpcnsip;
	22	private import win32.rpc, win32.rpcdce, win32.unknwn, win32.windef;
21	23	private import win32.objidl; // for IRpcChannelBuffer, IRpcStubBuffer
22		private import win32.rpcdce;
23		private import win32.unknwn;
24		private import win32.windef;
25
26		pragma(lib,"rpcrt4.lib");
	24
27	25
28	26	extern (Windows):

trunk/win32/rpcnsi.d

r135	r155
11	11	module win32.rpcnsi;
12	12	pragma(lib, "rpcns4.lib");
13		~~private import win32.w32api;~~
14		~~private import win32.basetyps;~~
15		~~private import win32.rpcdcep;~~
16		~~private import win32.rpcnsi;~~
17		~~private import win32.rpcdce;~~
18	13
19		alias void *RPC_NS_HANDLE;
	14	private import win32.basetyps, win32.rpcdcep, win32.rpcnsi, win32.rpcdce,
	15	win32.w32api;
	16	private import win32.windef; // for HANDLE
	17
	18	alias HANDLE RPC_NS_HANDLE;
20	19
21	20	const RPC_C_NS_SYNTAX_DEFAULT=0;
…	…
29	28
30	29	extern (Windows) {
31		RPC_STATUS RpcNsBindingExportA(uint,ubyte,RPC_IF_HANDLE,RPC_BINDING_VECTOR,UUID_VECTOR*);
32		RPC_STATUS RpcNsBindingUnexportA(uint,ubyte,RPC_IF_HANDLE,UUID_VECTOR);
33		RPC_STATUS RpcNsBindingLookupBeginA(uint,ubyte,RPC_IF_HANDLE,UUID,uint,RPC_NS_HANDLE*);
34		RPC_STATUS RpcNsBindingLookupNext(RPC_NS_HANDLE,RPC_BINDING_VECTOR**);
35		RPC_STATUS RpcNsBindingLookupDone(RPC_NS_HANDLE*);
36		RPC_STATUS RpcNsGroupDeleteA(uint,ubyte*);
37		RPC_STATUS RpcNsGroupMbrAddA(uint,ubyte,uint,ubyte);
38		RPC_STATUS RpcNsGroupMbrRemoveA(uint,ubyte,uint,ubyte);
39		RPC_STATUS RpcNsGroupMbrInqBeginA(uint,ubyte,uint,RPC_NS_HANDLE);
40		RPC_STATUS RpcNsGroupMbrInqNextA(RPC_NS_HANDLE,ubyte**);
41		RPC_STATUS RpcNsGroupMbrInqDone(RPC_NS_HANDLE*);
42		RPC_STATUS RpcNsProfileDeleteA(uint,ubyte*);
43		RPC_STATUS RpcNsProfileEltAddA(uint,ubyte,RPC_IF_ID,uint,ubyte,uint,ubyte);
44		RPC_STATUS RpcNsProfileEltRemoveA(uint,ubyte,RPC_IF_ID,uint,ubyte*);
45		RPC_STATUS RpcNsProfileEltInqBeginA(uint,ubyte,uint,RPC_IF_ID,uint,uint,ubyte,RPC_NS_HANDLE);
46		RPC_STATUS RpcNsProfileEltInqNextA(RPC_NS_HANDLE,RPC_IF_ID,ubyte,uint,ubyte**);
47		RPC_STATUS RpcNsProfileEltInqDone(RPC_NS_HANDLE*);
48		RPC_STATUS RpcNsEntryObjectInqNext(in RPC_NS_HANDLE, out UUID*);
49		RPC_STATUS RpcNsEntryObjectInqDone(inout RPC_NS_HANDLE*);
50		RPC_STATUS RpcNsEntryExpandNameA(uint,ubyte,ubyte*);
51		RPC_STATUS RpcNsMgmtBindingUnexportA(uint,ubyte,RPC_IF_ID,uint,UUID_VECTOR*);
52		RPC_STATUS RpcNsMgmtEntryCreateA(uint,ubyte*);
53		RPC_STATUS RpcNsMgmtEntryDeleteA(uint,ubyte*);
54		RPC_STATUS RpcNsMgmtEntryInqIfIdsA(uint,ubyte,RPC_IF_ID_VECTOR*);
55		RPC_STATUS RpcNsMgmtHandleSetExpAge(RPC_NS_HANDLE,uint);
56		RPC_STATUS RpcNsMgmtInqExpAge(uint*);
57		RPC_STATUS RpcNsMgmtSetExpAge(uint);
58		RPC_STATUS RpcNsBindingImportNext(RPC_NS_HANDLE,RPC_BINDING_HANDLE*);
59		RPC_STATUS RpcNsBindingImportDone(RPC_NS_HANDLE*);
60		RPC_STATUS RpcNsBindingSelect(RPC_BINDING_VECTOR,RPC_BINDING_HANDLE);
	30	RPC_STATUS RpcNsBindingExportA(uint, ubyte*, RPC_IF_HANDLE,
	31	RPC_BINDING_VECTOR, UUID_VECTOR);
	32	RPC_STATUS RpcNsBindingUnexportA(uint, ubyte*, RPC_IF_HANDLE,
	33	UUID_VECTOR*);
	34	RPC_STATUS RpcNsBindingLookupBeginA(uint, ubyte, RPC_IF_HANDLE, UUID,
	35	uint, RPC_NS_HANDLE*);
	36	RPC_STATUS RpcNsBindingLookupNext(RPC_NS_HANDLE, RPC_BINDING_VECTOR**);
	37	RPC_STATUS RpcNsBindingLookupDone(RPC_NS_HANDLE*);
	38	RPC_STATUS RpcNsGroupDeleteA(uint, ubyte*);
	39	RPC_STATUS RpcNsGroupMbrAddA(uint, ubyte, uint, ubyte);
	40	RPC_STATUS RpcNsGroupMbrRemoveA(uint, ubyte, uint, ubyte);
	41	RPC_STATUS RpcNsGroupMbrInqBeginA(uint, ubyte, uint, RPC_NS_HANDLE);
	42	RPC_STATUS RpcNsGroupMbrInqNextA(RPC_NS_HANDLE, ubyte**);
	43	RPC_STATUS RpcNsGroupMbrInqDone(RPC_NS_HANDLE*);
	44	RPC_STATUS RpcNsProfileDeleteA(uint, ubyte*);
	45	RPC_STATUS RpcNsProfileEltAddA(uint, ubyte, RPC_IF_ID, uint, ubyte*,
	46	uint, ubyte*);
	47	RPC_STATUS RpcNsProfileEltRemoveA(uint, ubyte, RPC_IF_ID, uint, ubyte*);
	48	RPC_STATUS RpcNsProfileEltInqBeginA(uint, ubyte, uint, RPC_IF_ID, uint,
	49	uint, ubyte, RPC_NS_HANDLE);
	50	RPC_STATUS RpcNsProfileEltInqNextA(RPC_NS_HANDLE, RPC_IF_ID, ubyte*,
	51	uint, ubyte*);
	52	RPC_STATUS RpcNsProfileEltInqDone(RPC_NS_HANDLE*);
	53	RPC_STATUS RpcNsEntryObjectInqNext(in RPC_NS_HANDLE, out UUID*);
	54	RPC_STATUS RpcNsEntryObjectInqDone(inout RPC_NS_HANDLE*);
	55	RPC_STATUS RpcNsEntryExpandNameA(uint, ubyte, ubyte*);
	56	RPC_STATUS RpcNsMgmtBindingUnexportA(uint, ubyte, RPC_IF_ID, uint,
	57	UUID_VECTOR*);
	58	RPC_STATUS RpcNsMgmtEntryCreateA(uint, ubyte*);
	59	RPC_STATUS RpcNsMgmtEntryDeleteA(uint, ubyte*);
	60	RPC_STATUS RpcNsMgmtEntryInqIfIdsA(uint, ubyte, RPC_IF_ID_VECTOR*);
	61	RPC_STATUS RpcNsMgmtHandleSetExpAge(RPC_NS_HANDLE, uint);
	62	RPC_STATUS RpcNsMgmtInqExpAge(uint*);
	63	RPC_STATUS RpcNsMgmtSetExpAge(uint);
	64	RPC_STATUS RpcNsBindingImportNext(RPC_NS_HANDLE, RPC_BINDING_HANDLE*);
	65	RPC_STATUS RpcNsBindingImportDone(RPC_NS_HANDLE*);
	66	RPC_STATUS RpcNsBindingSelect(RPC_BINDING_VECTOR, RPC_BINDING_HANDLE);
61	67	}
62	68
63		// For the cases where Win95,98, ME have no _W versions, and we must alias to
	69	// For the cases where Win95, 98, ME have no _W versions, and we must alias to
64	70	// _A even for version(Unicode).
65	71
…	…
71	77	}
72	78	} else {
73		const bool _WIN32_USE_UNICODE = false;
	79	const bool _WIN32_USE_UNICODE = false;
74	80	}
75	81
76	82	static if (!_WIN32_USE_UNICODE) {
77		RPC_STATUS RpcNsEntryObjectInqBeginA(uint,ubyte,RPC_NS_HANDLE);
78		RPC_STATUS RpcNsBindingImportBeginA(uint,ubyte,RPC_IF_HANDLE,UUID,RPC_NS_HANDLE*);
	83	RPC_STATUS RpcNsEntryObjectInqBeginA(uint, ubyte, RPC_NS_HANDLE);
	84	RPC_STATUS RpcNsBindingImportBeginA(uint, ubyte, RPC_IF_HANDLE, UUID,
	85	RPC_NS_HANDLE*);
79	86	}
80	87
81	88	static if (_WIN32_WINNT_ONLY) {
82		RPC_STATUS RpcNsBindingExportW(uint,ushort,RPC_IF_HANDLE,RPC_BINDING_VECTOR,UUID_VECTOR*);
83		RPC_STATUS RpcNsBindingUnexportW(uint,ushort,RPC_IF_HANDLE,UUID_VECTOR);
84		RPC_STATUS RpcNsBindingLookupBeginW(uint,ushort,RPC_IF_HANDLE,UUID,uint,RPC_NS_HANDLE*);
85		RPC_STATUS RpcNsGroupDeleteW(uint,ushort*);
86		RPC_STATUS RpcNsGroupMbrAddW(uint,ushort,uint,ushort);
87		RPC_STATUS RpcNsGroupMbrRemoveW(uint,ushort,uint,ushort);
88		RPC_STATUS RpcNsGroupMbrInqBeginW(uint,ushort,uint,RPC_NS_HANDLE);
89		RPC_STATUS RpcNsGroupMbrInqNextW(RPC_NS_HANDLE,ushort**);
90		RPC_STATUS RpcNsProfileDeleteW(uint,ushort*);
91		RPC_STATUS RpcNsProfileEltAddW(uint,ushort, RPC_IF_ID,uint,ushort,uint,ushort);
92		RPC_STATUS RpcNsProfileEltRemoveW(uint,ushort, RPC_IF_ID,uint,ushort*);
93		RPC_STATUS RpcNsProfileEltInqBeginW(uint,ushort, uint,RPC_IF_ID,uint,uint,ushort, RPC_NS_HANDLE);
94		RPC_STATUS RpcNsProfileEltInqNextW(RPC_NS_HANDLE,RPC_IF_ID, ushort,uint,ushort**);
95		RPC_STATUS RpcNsEntryObjectInqBeginW(uint,ushort,RPC_NS_HANDLE);
96		RPC_STATUS RpcNsEntryExpandNameW(uint,ushort,ushort*);
97		RPC_STATUS RpcNsMgmtBindingUnexportW(uint,ushort,RPC_IF_ID,uint,UUID_VECTOR*);
98		RPC_STATUS RpcNsMgmtEntryCreateW(uint,ushort*);
99		RPC_STATUS RpcNsMgmtEntryDeleteW(uint,ushort*);
100		RPC_STATUS RpcNsMgmtEntryInqIfIdsW(uint,ushort , RPC_IF_ID_VECTOR**);
101		RPC_STATUS RpcNsBindingImportBeginW(uint,ushort,RPC_IF_HANDLE,UUID,RPC_NS_HANDLE*);
	89	RPC_STATUS RpcNsBindingExportW(uint, ushort*, RPC_IF_HANDLE,
	90	RPC_BINDING_VECTOR, UUID_VECTOR);
	91	RPC_STATUS RpcNsBindingUnexportW(uint, ushort*, RPC_IF_HANDLE,
	92	UUID_VECTOR*);
	93	RPC_STATUS RpcNsBindingLookupBeginW(uint, ushort, RPC_IF_HANDLE, UUID,
	94	uint, RPC_NS_HANDLE*);
	95	RPC_STATUS RpcNsGroupDeleteW(uint, ushort*);
	96	RPC_STATUS RpcNsGroupMbrAddW(uint, ushort, uint, ushort);
	97	RPC_STATUS RpcNsGroupMbrRemoveW(uint, ushort, uint, ushort);
	98	RPC_STATUS RpcNsGroupMbrInqBeginW(uint, ushort, uint, RPC_NS_HANDLE);
	99	RPC_STATUS RpcNsGroupMbrInqNextW(RPC_NS_HANDLE, ushort**);
	100	RPC_STATUS RpcNsProfileDeleteW(uint, ushort*);
	101	RPC_STATUS RpcNsProfileEltAddW(uint, ushort, RPC_IF_ID, uint, ushort*,
	102	uint, ushort*);
	103	RPC_STATUS RpcNsProfileEltRemoveW(uint, ushort, RPC_IF_ID, uint,
	104	ushort*);
	105	RPC_STATUS RpcNsProfileEltInqBeginW(uint, ushort, uint, RPC_IF_ID,
	106	uint, uint, ushort, RPC_NS_HANDLE);
	107	RPC_STATUS RpcNsProfileEltInqNextW(RPC_NS_HANDLE, RPC_IF_ID, ushort*,
	108	uint, ushort*);
	109	RPC_STATUS RpcNsEntryObjectInqBeginW(uint, ushort, RPC_NS_HANDLE);
	110	RPC_STATUS RpcNsEntryExpandNameW(uint, ushort, ushort*);
	111	RPC_STATUS RpcNsMgmtBindingUnexportW(uint, ushort, RPC_IF_ID, uint,
	112	UUID_VECTOR*);
	113	RPC_STATUS RpcNsMgmtEntryCreateW(uint, ushort*);
	114	RPC_STATUS RpcNsMgmtEntryDeleteW(uint, ushort*);
	115	RPC_STATUS RpcNsMgmtEntryInqIfIdsW(uint, ushort , RPC_IF_ID_VECTOR**);
	116	RPC_STATUS RpcNsBindingImportBeginW(uint, ushort, RPC_IF_HANDLE, UUID,
	117	RPC_NS_HANDLE*);
102	118	} // _WIN32_WINNT_ONLY
103	119
104	120	static if (_WIN32_USE_UNICODE) {
105		alias RpcNsBindingLookupBeginW RpcNsBindingLookupBegin;
106		alias RpcNsBindingImportBeginW RpcNsBindingImportBegin;
107		alias RpcNsBindingExportW RpcNsBindingExport;
108		alias RpcNsBindingUnexportW RpcNsBindingUnexport;
109		alias RpcNsGroupDeleteW RpcNsGroupDelete;
110		alias RpcNsGroupMbrAddW RpcNsGroupMbrAdd;
111		alias RpcNsGroupMbrRemoveW RpcNsGroupMbrRemove;
112		alias RpcNsGroupMbrInqBeginW RpcNsGroupMbrInqBegin;
113		alias RpcNsGroupMbrInqNextW RpcNsGroupMbrInqNext;
114		alias RpcNsEntryExpandNameW RpcNsEntryExpandName;
115		alias RpcNsEntryObjectInqBeginW RpcNsEntryObjectInqBegin;
116		alias RpcNsMgmtBindingUnexportW RpcNsMgmtBindingUnexport;
117		alias RpcNsMgmtEntryCreateW RpcNsMgmtEntryCreate;
118		alias RpcNsMgmtEntryDeleteW RpcNsMgmtEntryDelete;
119		alias RpcNsMgmtEntryInqIfIdsW RpcNsMgmtEntryInqIfIds;
120		alias RpcNsProfileDeleteW RpcNsProfileDelete;
121		alias RpcNsProfileEltAddW RpcNsProfileEltAdd;
122		alias RpcNsProfileEltRemoveW RpcNsProfileEltRemove;
123		alias RpcNsProfileEltInqBeginW RpcNsProfileEltInqBegin;
124		alias RpcNsProfileEltInqNextW RpcNsProfileEltInqNext;
	121	alias RpcNsBindingLookupBeginW RpcNsBindingLookupBegin;
	122	alias RpcNsBindingImportBeginW RpcNsBindingImportBegin;
	123	alias RpcNsBindingExportW RpcNsBindingExport;
	124	alias RpcNsBindingUnexportW RpcNsBindingUnexport;
	125	alias RpcNsGroupDeleteW RpcNsGroupDelete;
	126	alias RpcNsGroupMbrAddW RpcNsGroupMbrAdd;
	127	alias RpcNsGroupMbrRemoveW RpcNsGroupMbrRemove;
	128	alias RpcNsGroupMbrInqBeginW RpcNsGroupMbrInqBegin;
	129	alias RpcNsGroupMbrInqNextW RpcNsGroupMbrInqNext;
	130	alias RpcNsEntryExpandNameW RpcNsEntryExpandName;
	131	alias RpcNsEntryObjectInqBeginW RpcNsEntryObjectInqBegin;
	132	alias RpcNsMgmtBindingUnexportW RpcNsMgmtBindingUnexport;
	133	alias RpcNsMgmtEntryCreateW RpcNsMgmtEntryCreate;
	134	alias RpcNsMgmtEntryDeleteW RpcNsMgmtEntryDelete;
	135	alias RpcNsMgmtEntryInqIfIdsW RpcNsMgmtEntryInqIfIds;
	136	alias RpcNsProfileDeleteW RpcNsProfileDelete;
	137	alias RpcNsProfileEltAddW RpcNsProfileEltAdd;
	138	alias RpcNsProfileEltRemoveW RpcNsProfileEltRemove;
	139	alias RpcNsProfileEltInqBeginW RpcNsProfileEltInqBegin;
	140	alias RpcNsProfileEltInqNextW RpcNsProfileEltInqNext;
125	141	} else {
126		alias RpcNsBindingLookupBeginA RpcNsBindingLookupBegin;
127		alias RpcNsBindingImportBeginA RpcNsBindingImportBegin;
128		alias RpcNsBindingExportA RpcNsBindingExport;
129		alias RpcNsBindingUnexportA RpcNsBindingUnexport;
130		alias RpcNsGroupDeleteA RpcNsGroupDelete;
131		alias RpcNsGroupMbrAddA RpcNsGroupMbrAdd;
132		alias RpcNsGroupMbrRemoveA RpcNsGroupMbrRemove;
133		alias RpcNsGroupMbrInqBeginA RpcNsGroupMbrInqBegin;
134		alias RpcNsGroupMbrInqNextA RpcNsGroupMbrInqNext;
135		alias RpcNsEntryExpandNameA RpcNsEntryExpandName;
136		alias RpcNsEntryObjectInqBeginA RpcNsEntryObjectInqBegin;
137		alias RpcNsMgmtBindingUnexportA RpcNsMgmtBindingUnexport;
138		alias RpcNsMgmtEntryCreateA RpcNsMgmtEntryCreate;
139		alias RpcNsMgmtEntryDeleteA RpcNsMgmtEntryDelete;
140		alias RpcNsMgmtEntryInqIfIdsA RpcNsMgmtEntryInqIfIds;
141		alias RpcNsProfileDeleteA RpcNsProfileDelete;
142		alias RpcNsProfileEltAddA RpcNsProfileEltAdd;
143		alias RpcNsProfileEltRemoveA RpcNsProfileEltRemove;
144		alias RpcNsProfileEltInqBeginA RpcNsProfileEltInqBegin;
145		alias RpcNsProfileEltInqNextA RpcNsProfileEltInqNext;
	142	alias RpcNsBindingLookupBeginA RpcNsBindingLookupBegin;
	143	alias RpcNsBindingImportBeginA RpcNsBindingImportBegin;
	144	alias RpcNsBindingExportA RpcNsBindingExport;
	145	alias RpcNsBindingUnexportA RpcNsBindingUnexport;
	146	alias RpcNsGroupDeleteA RpcNsGroupDelete;
	147	alias RpcNsGroupMbrAddA RpcNsGroupMbrAdd;
	148	alias RpcNsGroupMbrRemoveA RpcNsGroupMbrRemove;
	149	alias RpcNsGroupMbrInqBeginA RpcNsGroupMbrInqBegin;
	150	alias RpcNsGroupMbrInqNextA RpcNsGroupMbrInqNext;
	151	alias RpcNsEntryExpandNameA RpcNsEntryExpandName;
	152	alias RpcNsEntryObjectInqBeginA RpcNsEntryObjectInqBegin;
	153	alias RpcNsMgmtBindingUnexportA RpcNsMgmtBindingUnexport;
	154	alias RpcNsMgmtEntryCreateA RpcNsMgmtEntryCreate;
	155	alias RpcNsMgmtEntryDeleteA RpcNsMgmtEntryDelete;
	156	alias RpcNsMgmtEntryInqIfIdsA RpcNsMgmtEntryInqIfIds;
	157	alias RpcNsProfileDeleteA RpcNsProfileDelete;
	158	alias RpcNsProfileEltAddA RpcNsProfileEltAdd;
	159	alias RpcNsProfileEltRemoveA RpcNsProfileEltRemove;
	160	alias RpcNsProfileEltInqBeginA RpcNsProfileEltInqBegin;
	161	alias RpcNsProfileEltInqNextA RpcNsProfileEltInqNext;
146	162	}

trunk/win32/rpcnsip.d

r99	r155
1	1	/***********************************************************************\
2		* ~~rpcnsip.d~~ *
	2	* rpcnsip.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.rpcnsip;
11		private import win32.rpcdcep;
12		private import win32.rpcnsi;
13		private import win32.rpcdce;
	11
	12	private import win32.rpcdce, win32.rpcdcep, win32.rpcnsi;
14	13
15	14	struct RPC_IMPORT_CONTEXT_P {
16		RPC_NS_HANDLE LookupContext;
17		RPC_BINDING_HANDLE ProposedHandle;
18		RPC_BINDING_VECTOR *Bindings;
	15	RPC_NS_HANDLE LookupContext;
	16	RPC_BINDING_HANDLE ProposedHandle;
	17	RPC_BINDING_VECTOR* Bindings;
19	18	}
20		alias RPC_IMPORT_CONTEXT_P * PRPC_IMPORT_CONTEXT_P;
	19	alias RPC_IMPORT_CONTEXT_P* PRPC_IMPORT_CONTEXT_P;
21	20
22	21	extern(Windows) {
23		~~RPC_STATUS I_RpcNsGetBuffer(in~~ PRPC_MESSAGE);
24		~~RPC_STATUS I_RpcNsSendReceive(in PRPC_MESSAGE, out~~ RPC_BINDING_HANDLE*);
25		~~void I_RpcNsRaiseException(in PRPC_MESSAGE, in~~ RPC_STATUS);
26		~~RPC_STATUS I_RpcReBindBuffer(in~~ PRPC_MESSAGE);
27		RPC_STATUS I_NsServerBindSearch();
28		RPC_STATUS I_NsClientBindSearch();
29		void I_NsClientBindDone();
	22	RPC_STATUS I_RpcNsGetBuffer(PRPC_MESSAGE);
	23	RPC_STATUS I_RpcNsSendReceive(PRPC_MESSAGE, RPC_BINDING_HANDLE*);
	24	void I_RpcNsRaiseException(PRPC_MESSAGE, RPC_STATUS);
	25	RPC_STATUS I_RpcReBindBuffer(PRPC_MESSAGE);
	26	RPC_STATUS I_NsServerBindSearch();
	27	RPC_STATUS I_NsClientBindSearch();
	28	void I_NsClientBindDone();
30	29	}

trunk/win32/rpcnterr.d

r99	r155
1	1	/***********************************************************************\
2		* ~~rpcnterr.d~~ *
	2	* rpcnterr.d *
3	3	* *
4	4	* Windows API header module *

trunk/win32/secext.d

r141	r155
	1	/***********************************************************************\
	2	* secext.d *
	3	* *
	4	* Windows API header module *
	5	* *
	6	* Translated from MinGW Windows headers *
	7	* *
	8	* Placed into public domain *
	9	\***********************************************************************/
1	10	// Don't include this file directly, use win32.security instead.
2	11	module win32.secext;
3		~~private import win32.w32api;~~
4		~~private import win32.windef;~~
5	12	pragma(lib, "secur32.lib");
	13
	14	private import win32.w32api, win32.windef;
6	15
7	16	static assert (_WIN32_WINNT >= 0x0501,

trunk/win32/servprov.d

r146	r155
1	1	/***********************************************************************\
2		* ~~servprov.d~~ *
	2	* servprov.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.servprov;
11		private import win32.unknwn;
12		private import win32.~~wtypes, win32.basetyps, win32.windef~~;
	11
	12	private import win32.basetyps, win32.unknwn, win32.windef, win32.wtypes;
13	13
14	14	extern (C) {

trunk/win32/setupapi.d

r146	r155
11	11	module win32.setupapi;
12	12	pragma(lib, "setupapi.lib");
13		private import win32.w32api;
14		private import win32.windef;
	13
	14	private import win32.basetyps, win32.commctrl, win32.prsht, win32.w32api,
	15	win32.winreg, win32.windef;
15	16	private import win32.winbase; // for SYSTEMTIME
16		~~private import win32.commctrl;~~
17		~~private import win32.winreg;~~
18		~~private import win32.prsht;~~
19		~~private import win32.basetyps;~~
20	17
21	18	/*static if(_WIN32_WINNT < _WIN32_WINDOWS) {

trunk/win32/shldisp.d

r146	r155
1	1	/***********************************************************************\
2		* ~~shldisp.d~~ *
	2	* shldisp.d *
3	3	* *
4	4	* Windows API header module *
…	…
9	9	\***********************************************************************/
10	10	module win32.shldisp;
	11
11	12	private import win32.unknwn, win32.windef, win32.wtypes;
12	13

trunk/win32/shlguid.d

r141	r155
1	1	/***********************************************************************\
2		* ~~shlguid.d~~ *
	2	* shlguid.d *
3	3	* *
4	4	* Windows API header module *
…	…
10	10	module win32.shlguid;
11	11
12		private import win32.basetyps;
13		private import win32.w32api;
	12	private import win32.basetyps, win32.w32api;
14	13
15	14	// FIXME: clean up Windows version support

trunk/win32/shlobj.d

r146	r155
1	1	/***********************************************************************\
2		* ~~shlobj.d~~ *
	2	* shlobj.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.shlobj;
	11	pragma(lib, "shell32.lib");
	12
10	13	// TODO: fix bitfields
11	14	// TODO: CMIC_VALID_SEE_FLAGS
12		module win32.shlobj;
13
14		/* SHGetFolderPath in shfolder.dll on W9x, NT4, also in shell32.dll on W2K */
15		pragma(lib, "shell32.lib");
16
17		private import win32.w32api;
18		private import win32.unknwn;
19		private import win32.winuser;
20		private import win32.winbase;
	15	// SHGetFolderPath in shfolder.dll on W9x, NT4, also in shell32.dll on W2K
	16
	17	import win32.commctrl, win32.ole2, win32.shlguid, win32.shellapi;
	18	private import win32.prsht, win32.unknwn, win32.w32api, win32.winbase,
	19	win32.winnt, win32.winuser, win32.wtypes, win32.objfwd, win32.objidl;
21	20	private import win32.winnetwk; // for NETRESOURCE
22		private import win32.winnt, win32.wtypes, win32.objfwd, win32.objidl;
23		private import win32.prsht;
24
25		import win32.ole2;
26		import win32.shlguid;
27		import win32.shellapi;
28		import win32.commctrl;
	21
29	22
30	23	// FIXME: clean up Windows version support

trunk/win32/shlwapi.d

r146	r155
25	25	*/
26	26
27		import win32.objbase;
28		import win32.shlobj;
29		private import win32.windef;
30		private import win32.winbase;
31		private import win32.winreg;
32		private import win32.unknwn, win32.objidl, win32.basetyps;
	27	import win32.objbase, win32.shlobj;
	28	private import win32.basetyps, win32.objidl, win32.unknwn, win32.windef,
	29	win32.winbase, win32.winreg;
33	30
34	31	const DLLVER_PLATFORM_WINDOWS = 0x00000001;

trunk/win32/sql.d

r146	r155
9	9	\***********************************************************************/
10	10	module win32.sql;
	11
11	12	public import win32.sqltypes;
12	13	private import win32.windef;
…	…
206	207
207	208	static if (ODBCVER >= 0x0200) {
208		const SQL_AT_ADD_COLUMN=1;
209		const SQL_AT_DROP_COLUMN=2;
210		}// #endif /* ODBCVER >= 0x0200 */
	209	const SQL_AT_ADD_COLUMN = 1;
	210	const SQL_AT_DROP_COLUMN = 2;
	211	}
	212
211	213	static if (ODBCVER >= 0x0201) {
212		const SQL_OJ_LEFT=1;
213		const SQL_OJ_RIGHT=2;
214		const SQL_OJ_FULL=4;
215		const SQL_OJ_NESTED=8;
216		const SQL_OJ_NOT_ORDERED=16;
217		const SQL_OJ_INNER=32;
218		const SQL_OJ_ALL_COMPARISON_OPS=64;
219		}// #endif /* ODBCVER >= 0x0201 */
	214	const SQL_OJ_LEFT = 1;
	215	const SQL_OJ_RIGHT = 2;
	216	const SQL_OJ_FULL = 4;
	217	const SQL_OJ_NESTED = 8;
	218	const SQL_OJ_NOT_ORDERED = 16;
	219	const SQL_OJ_INNER = 32;
	220	const SQL_OJ_ALL_COMPARISON_OPS = 64;
	221	}
	222
220	223	static if (ODBCVER >= 0x0300) {
221		const SQL_AM_CONNECTION=1;
222		const SQL_AM_NONE=0;
223		const SQL_AM_STATEMENT=2;
224		const SQL_API_SQLALLOCHANDLE=1001;
225		const SQL_API_SQLBINDPARAM=1002;
226		const SQL_API_SQLCLOSECURSOR=1003;
227		const SQL_API_SQLCOLATTRIBUTE=6;
228		const SQL_API_SQLCOPYDESC=1004;
229		const SQL_API_SQLENDTRAN=1005;
230		const SQL_API_SQLFETCHSCROLL=1021;
231		const SQL_API_SQLFREEHANDLE=1006;
232		const SQL_API_SQLGETCONNECTATTR=1007;
233		const SQL_API_SQLGETDESCFIELD=1008;
234		const SQL_API_SQLGETDESCREC=1009;
235		const SQL_API_SQLGETDIAGFIELD=1010;
236		const SQL_API_SQLGETDIAGREC=1011;
237		const SQL_API_SQLGETENVATTR=1012;
238		const SQL_API_SQLGETSTMTATTR=1014;
239		const SQL_API_SQLSETCONNECTATTR=1016;
240		const SQL_API_SQLSETDESCFIELD=1017;
241		const SQL_API_SQLSETDESCREC=1018;
242		const SQL_API_SQLSETENVATTR=1019;
243		const SQL_API_SQLSETSTMTATTR=1020;
244		const SQL_ARD_TYPE=-99;
245		const SQL_AT_ADD_CONSTRAINT=8;
246		const SQL_ATTR_APP_PARAM_DESC=10011;
247		const SQL_ATTR_APP_ROW_DESC=10010;
248		const SQL_ATTR_AUTO_IPD=10001;
249		const SQL_ATTR_CURSOR_SCROLLABLE=-1;
250		const SQL_ATTR_CURSOR_SENSITIVITY=-2;
251		const SQL_ATTR_IMP_PARAM_DESC=10013;
252		const SQL_ATTR_IMP_ROW_DESC=10012;
253		const SQL_ATTR_METADATA_ID=10014;
254		const SQL_ATTR_OUTPUT_NTS=10001;
255		const SQL_CATALOG_NAME=10003;
256		const SQL_CODE_DATE=1;
257		const SQL_CODE_TIME=2;
258		const SQL_CODE_TIMESTAMP=3;
259		const SQL_COLLATION_SEQ=10004;
260		const SQL_CURSOR_SENSITIVITY=10001;
261		const SQL_DATE_LEN=10;
262		const SQL_DATETIME=9;
263		const SQL_DEFAULT=99;
264
265		const SQL_DESC_ALLOC_AUTO=1;
266		const SQL_DESC_ALLOC_USER=2;
267		const SQL_DESC_ALLOC_TYPE=1099;
268		const SQL_DESC_COUNT=1001;
269		const SQL_DESC_TYPE=1002;
270		const SQL_DESC_LENGTH=1003;
271		const SQL_DESC_OCTET_LENGTH_PTR=1004;
272		const SQL_DESC_PRECISION=1005;
273		const SQL_DESC_SCALE=1006;
274		const SQL_DESC_DATETIME_INTERVAL_CODE=1007;
275		const SQL_DESC_NULLABLE=1008;
276		const SQL_DESC_INDICATOR_PTR=1009;
277		const SQL_DESC_DATA_PTR=1010;
278		const SQL_DESC_NAME=1011;
279		const SQL_DESC_UNNAMED=1012;
280		const SQL_DESC_OCTET_LENGTH=1013;
281
282		const SQL_DESCRIBE_PARAMETER=10002;
283
284		const SQL_DIAG_ALTER_DOMAIN=3;
285		const SQL_DIAG_ALTER_TABLE=4;
286		const SQL_DIAG_CALL=7;
287		const SQL_DIAG_CLASS_ORIGIN=8;
288		const SQL_DIAG_CONNECTION_NAME=10;
289		const SQL_DIAG_CREATE_ASSERTION=6;
290		const SQL_DIAG_CREATE_CHARACTER_SET=8;
291		const SQL_DIAG_CREATE_COLLATION=10;
292		const SQL_DIAG_CREATE_DOMAIN=23;
293		const SQL_DIAG_CREATE_INDEX=-1;
294		const SQL_DIAG_CREATE_SCHEMA=64;
295		const SQL_DIAG_CREATE_TABLE=77;
296		const SQL_DIAG_CREATE_TRANSLATION=79;
297		const SQL_DIAG_CREATE_VIEW=84;
298		const SQL_DIAG_DELETE_WHERE=19;
299		const SQL_DIAG_DROP_ASSERTION=24;
300		const SQL_DIAG_DROP_CHARACTER_SET=25;
301		const SQL_DIAG_DROP_COLLATION=26;
302		const SQL_DIAG_DROP_DOMAIN=27;
303		const SQL_DIAG_DROP_INDEX=(-2);
304		const SQL_DIAG_DROP_SCHEMA=31;
305		const SQL_DIAG_DROP_TABLE=32;
306		const SQL_DIAG_DROP_TRANSLATION=33;
307		const SQL_DIAG_DROP_VIEW=36;
308		const SQL_DIAG_DYNAMIC_DELETE_CURSOR=38;
309		const SQL_DIAG_DYNAMIC_FUNCTION=7;
310		const SQL_DIAG_DYNAMIC_FUNCTION_CODE=12;
311		const SQL_DIAG_DYNAMIC_UPDATE_CURSOR=81;
312		const SQL_DIAG_GRANT=48;
313		const SQL_DIAG_INSERT=50;
314		const SQL_DIAG_MESSAGE_TEXT=6;
315		const SQL_DIAG_NATIVE=5;
316		const SQL_DIAG_NUMBER=2;
317		const SQL_DIAG_RETURNCODE=1;
318		const SQL_DIAG_REVOKE=59;
319		const SQL_DIAG_ROW_COUNT=3;
320		const SQL_DIAG_SELECT_CURSOR=85;
321		const SQL_DIAG_SERVER_NAME=11;
322		const SQL_DIAG_SQLSTATE=4;
323		const SQL_DIAG_SUBCLASS_ORIGIN=9;
324		const SQL_DIAG_UNKNOWN_STATEMENT=0;
325		const SQL_DIAG_UPDATE_WHERE=82;
326
327		const SQL_FALSE=0;
328		const SQL_HANDLE_DBC=2;
329		const SQL_HANDLE_DESC=4;
330		const SQL_HANDLE_ENV=1;
331		const SQL_HANDLE_STMT=3;
332		const SQL_INSENSITIVE=1;
333		const SQL_MAX_CONCURRENT_ACTIVITIES=1;
334		const SQL_MAX_DRIVER_CONNECTIONS=0;
335		const SQL_MAX_IDENTIFIER_LEN=10005;
336		const SQL_MAXIMUM_CONCURRENT_ACTIVITIES=SQL_MAX_CONCURRENT_ACTIVITIES;
337		const SQL_MAXIMUM_DRIVER_CONNECTIONS=SQL_MAX_DRIVER_CONNECTIONS;
338		const SQL_MAXIMUM_IDENTIFIER_LENGTH=SQL_MAX_IDENTIFIER_LEN;
339		const SQL_NAMED=0;
340		const SQL_NO_DATA=100;
341		const SQL_NONSCROLLABLE=0;
342		const SQL_NULL_HANDLE=0L;
343		const SQL_NULL_HDESC=0;
344		const SQL_OJ_CAPABILITIES=115;
345		const SQL_OUTER_JOIN_CAPABILITIES=SQL_OJ_CAPABILITIES;
346		const SQL_PC_NON_PSEUDO=1;
347
348		const SQL_PRED_NONE=0;
349		const SQL_PRED_CHAR=1;
350		const SQL_PRED_BASIC=2;
351
352		const SQL_ROW_IDENTIFIER=1;
353		const SQL_SCROLLABLE=1;
354		const SQL_SENSITIVE=2;
355		const SQL_TIME_LEN=8;
356		const SQL_TIMESTAMP_LEN=19;
357		const SQL_TRUE=1;
358		const SQL_TYPE_DATE=91;
359		const SQL_TYPE_TIME=92;
360		const SQL_TYPE_TIMESTAMP=93;
361		const SQL_UNNAMED=1;
362		const SQL_UNSPECIFIED=0;
363		const SQL_XOPEN_CLI_YEAR=10000;
	224	const SQL_AM_CONNECTION=1;
	225	const SQL_AM_NONE=0;
	226	const SQL_AM_STATEMENT=2;
	227	const SQL_API_SQLALLOCHANDLE=1001;
	228	const SQL_API_SQLBINDPARAM=1002;
	229	const SQL_API_SQLCLOSECURSOR=1003;
	230	const SQL_API_SQLCOLATTRIBUTE=6;
	231	const SQL_API_SQLCOPYDESC=1004;
	232	const SQL_API_SQLENDTRAN=1005;
	233	const SQL_API_SQLFETCHSCROLL=1021;
	234	const SQL_API_SQLFREEHANDLE=1006;
	235	const SQL_API_SQLGETCONNECTATTR=1007;
	236	const SQL_API_SQLGETDESCFIELD=1008;
	237	const SQL_API_SQLGETDESCREC=1009;
	238	const SQL_API_SQLGETDIAGFIELD=1010;
	239	const SQL_API_SQLGETDIAGREC=1011;
	240	const SQL_API_SQLGETENVATTR=1012;
	241	const SQL_API_SQLGETSTMTATTR=1014;
	242	const SQL_API_SQLSETCONNECTATTR=1016;
	243	const SQL_API_SQLSETDESCFIELD=1017;
	244	const SQL_API_SQLSETDESCREC=1018;
	245	const SQL_API_SQLSETENVATTR=1019;
	246	const SQL_API_SQLSETSTMTATTR=1020;
	247	const SQL_ARD_TYPE=-99;
	248	const SQL_AT_ADD_CONSTRAINT=8;
	249	const SQL_ATTR_APP_PARAM_DESC=10011;
	250	const SQL_ATTR_APP_ROW_DESC=10010;
	251	const SQL_ATTR_AUTO_IPD=10001;
	252	const SQL_ATTR_CURSOR_SCROLLABLE=-1;
	253	const SQL_ATTR_CURSOR_SENSITIVITY=-2;
	254	const SQL_ATTR_IMP_PARAM_DESC=10013;
	255	const SQL_ATTR_IMP_ROW_DESC=10012;
	256	const SQL_ATTR_METADATA_ID=10014;
	257	const SQL_ATTR_OUTPUT_NTS=10001;
	258	const SQL_CATALOG_NAME=10003;
	259	const SQL_CODE_DATE=1;
	260	const SQL_CODE_TIME=2;
	261	const SQL_CODE_TIMESTAMP=3;
	262	const SQL_COLLATION_SEQ=10004;
	263	const SQL_CURSOR_SENSITIVITY=10001;
	264	const SQL_DATE_LEN=10;
	265	const SQL_DATETIME=9;
	266	const SQL_DEFAULT=99;
	267
	268	const SQL_DESC_ALLOC_AUTO=1;
	269	const SQL_DESC_ALLOC_USER=2;
	270	const SQL_DESC_ALLOC_TYPE=1099;
	271	const SQL_DESC_COUNT=1001;
	272	const SQL_DESC_TYPE=1002;
	273	const SQL_DESC_LENGTH=1003;
	274	const SQL_DESC_OCTET_LENGTH_PTR=1004;
	275	const SQL_DESC_PRECISION=1005;
	276	const SQL_DESC_SCALE=1006;
	277	const SQL_DESC_DATETIME_INTERVAL_CODE=1007;
	278	const SQL_DESC_NULLABLE=1008;
	279	const SQL_DESC_INDICATOR_PTR=1009;
	280	const SQL_DESC_DATA_PTR=1010;
	281	const SQL_DESC_NAME=1011;
	282	const SQL_DESC_UNNAMED=1012;
	283	const SQL_DESC_OCTET_LENGTH=1013;
	284
	285	const SQL_DESCRIBE_PARAMETER=10002;
	286
	287	const SQL_DIAG_ALTER_DOMAIN=3;
	288	const SQL_DIAG_ALTER_TABLE=4;
	289	const SQL_DIAG_CALL=7;
	290	const SQL_DIAG_CLASS_ORIGIN=8;
	291	const SQL_DIAG_CONNECTION_NAME=10;
	292	const SQL_DIAG_CREATE_ASSERTION=6;
	293	const SQL_DIAG_CREATE_CHARACTER_SET=8;
	294	const SQL_DIAG_CREATE_COLLATION=10;
	295	const SQL_DIAG_CREATE_DOMAIN=23;
	296	const SQL_DIAG_CREATE_INDEX=-1;
	297	const SQL_DIAG_CREATE_SCHEMA=64;
	298	const SQL_DIAG_CREATE_TABLE=77;
	299	const SQL_DIAG_CREATE_TRANSLATION=79;
	300	const SQL_DIAG_CREATE_VIEW=84;
	301	const SQL_DIAG_DELETE_WHERE=19;
	302	const SQL_DIAG_DROP_ASSERTION=24;
	303	const SQL_DIAG_DROP_CHARACTER_SET=25;
	304	const SQL_DIAG_DROP_COLLATION=26;
	305	const SQL_DIAG_DROP_DOMAIN=27;
	306	const SQL_DIAG_DROP_INDEX=(-2);
	307	const SQL_DIAG_DROP_SCHEMA=31;
	308	const SQL_DIAG_DROP_TABLE=32;
	309	const SQL_DIAG_DROP_TRANSLATION=33;
	310	const SQL_DIAG_DROP_VIEW=36;
	311	const SQL_DIAG_DYNAMIC_DELETE_CURSOR=38;
	312	const SQL_DIAG_DYNAMIC_FUNCTION=7;
	313	const SQL_DIAG_DYNAMIC_FUNCTION_CODE=12;
	314	const SQL_DIAG_DYNAMIC_UPDATE_CURSOR=81;
	315	const SQL_DIAG_GRANT=48;
	316	const SQL_DIAG_INSERT=50;
	317	const SQL_DIAG_MESSAGE_TEXT=6;
	318	const SQL_DIAG_NATIVE=5;
	319	const SQL_DIAG_NUMBER=2;
	320	const SQL_DIAG_RETURNCODE=1;
	321	const SQL_DIAG_REVOKE=59;
	322	const SQL_DIAG_ROW_COUNT=3;
	323	const SQL_DIAG_SELECT_CURSOR=85;
	324	const SQL_DIAG_SERVER_NAME=11;
	325	const SQL_DIAG_SQLSTATE=4;
	326	const SQL_DIAG_SUBCLASS_ORIGIN=9;
	327	const SQL_DIAG_UNKNOWN_STATEMENT=0;
	328	const SQL_DIAG_UPDATE_WHERE=82;
	329
	330	const SQL_FALSE=0;
	331	const SQL_HANDLE_DBC=2;
	332	const SQL_HANDLE_DESC=4;
	333	const SQL_HANDLE_ENV=1;
	334	const SQL_HANDLE_STMT=3;
	335	const SQL_INSENSITIVE=1;
	336	const SQL_MAX_CONCURRENT_ACTIVITIES=1;
	337	const SQL_MAX_DRIVER_CONNECTIONS=0;
	338	const SQL_MAX_IDENTIFIER_LEN=10005;
	339	const SQL_MAXIMUM_CONCURRENT_ACTIVITIES=SQL_MAX_CONCURRENT_ACTIVITIES;
	340	const SQL_MAXIMUM_DRIVER_CONNECTIONS=SQL_MAX_DRIVER_CONNECTIONS;
	341	const SQL_MAXIMUM_IDENTIFIER_LENGTH=SQL_MAX_IDENTIFIER_LEN;
	342	const SQL_NAMED=0;
	343	const SQL_NO_DATA=100;
	344	const SQL_NONSCROLLABLE=0;
	345	const SQL_NULL_HANDLE=0L;
	346	const SQL_NULL_HDESC=0;
	347	const SQL_OJ_CAPABILITIES=115;
	348	const SQL_OUTER_JOIN_CAPABILITIES=SQL_OJ_CAPABILITIES;
	349	const SQL_PC_NON_PSEUDO=1;
	350
	351	const SQL_PRED_NONE=0;
	352	const SQL_PRED_CHAR=1;
	353	const SQL_PRED_BASIC=2;
	354
	355	const SQL_ROW_IDENTIFIER=1;
	356	const SQL_SCROLLABLE=1;
	357	const SQL_SENSITIVE=2;
	358	const SQL_TIME_LEN=8;
	359	const SQL_TIMESTAMP_LEN=19;
	360	const SQL_TRUE=1;
	361	const SQL_TYPE_DATE=91;
	362	const SQL_TYPE_TIME=92;
	363	const SQL_TYPE_TIMESTAMP=93;
	364	const SQL_UNNAMED=1;
	365	const SQL_UNSPECIFIED=0;
	366	const SQL_XOPEN_CLI_YEAR=10000;
364	367	}//#endif /* ODBCVER >= 0x0300 */
365	368
366	369	extern (Windows) {
367
368		deprecated {
369		SQLRETURN SQLAllocConnect(SQLHENV,SQLHDBC*);
370		SQLRETURN SQLAllocEnv(SQLHENV*);
371		SQLRETURN SQLAllocStmt(SQLHDBC,SQLHSTMT*);
372		SQLRETURN SQLError(SQLHENV,SQLHDBC,SQLHSTMT,SQLCHAR,SQLINTEGER,SQLCHAR,SQLSMALLINT,SQLSMALLINT);
373		SQLRETURN SQLFreeConnect(SQLHDBC);
374		SQLRETURN SQLFreeEnv(SQLHENV);
375		SQLRETURN SQLSetParam(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLPOINTER,SQLLEN*);
376		SQLRETURN SQLGetConnectOption(SQLHDBC,SQLUSMALLINT,SQLPOINTER);
377		SQLRETURN SQLGetStmtOption(SQLHSTMT,SQLUSMALLINT,SQLPOINTER);
378		SQLRETURN SQLSetConnectOption(SQLHDBC,SQLUSMALLINT,SQLULEN);
379		SQLRETURN SQLSetStmtOption(SQLHSTMT,SQLUSMALLINT,SQLROWCOUNT);
	370	deprecated {
	371	SQLRETURN SQLAllocConnect(SQLHENV, SQLHDBC*);
	372	SQLRETURN SQLAllocEnv(SQLHENV*);
	373	SQLRETURN SQLAllocStmt(SQLHDBC, SQLHSTMT*);
	374	SQLRETURN SQLError(SQLHENV, SQLHDBC, SQLHSTMT, SQLCHAR, SQLINTEGER, SQLCHAR, SQLSMALLINT, SQLSMALLINT);
	375	SQLRETURN SQLFreeConnect(SQLHDBC);
	376	SQLRETURN SQLFreeEnv(SQLHENV);
	377	SQLRETURN SQLSetParam(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLULEN, SQLSMALLINT, SQLPOINTER, SQLLEN*);
	378	SQLRETURN SQLGetConnectOption(SQLHDBC, SQLUSMALLINT, SQLPOINTER);
	379	SQLRETURN SQLGetStmtOption(SQLHSTMT, SQLUSMALLINT, SQLPOINTER);
	380	SQLRETURN SQLSetConnectOption(SQLHDBC, SQLUSMALLINT, SQLULEN);
	381	SQLRETURN SQLSetStmtOption(SQLHSTMT, SQLUSMALLINT, SQLROWCOUNT);
	382	}
	383	SQLRETURN SQLBindCol(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN*);
	384	SQLRETURN SQLCancel(SQLHSTMT);
	385	SQLRETURN SQLConnect(SQLHDBC, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR*, SQLSMALLINT);
	386	SQLRETURN SQLDescribeCol(SQLHSTMT, SQLUSMALLINT, SQLCHAR, SQLSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLULEN, SQLSMALLINT, SQLSMALLINT);
	387	SQLRETURN SQLDisconnect(SQLHDBC);
	388	SQLRETURN SQLExecDirect(SQLHSTMT, SQLCHAR*, SQLINTEGER);
	389	SQLRETURN SQLExecute(SQLHSTMT);
	390	SQLRETURN SQLFetch(SQLHSTMT);
	391	SQLRETURN SQLFreeStmt(SQLHSTMT, SQLUSMALLINT);
	392	SQLRETURN SQLGetCursorName(SQLHSTMT, SQLCHAR, SQLSMALLINT, SQLSMALLINT);
	393	SQLRETURN SQLNumResultCols(SQLHSTMT, SQLSMALLINT*);
	394	SQLRETURN SQLPrepare(SQLHSTMT, SQLCHAR*, SQLINTEGER);
	395	SQLRETURN SQLRowCount(SQLHSTMT, SQLLEN*);
	396	SQLRETURN SQLSetCursorName(SQLHSTMT, SQLCHAR*, SQLSMALLINT);
	397	SQLRETURN SQLTransact(SQLHENV, SQLHDBC, SQLUSMALLINT);
	398	SQLRETURN SQLColumns(SQLHSTMT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT);
	399	SQLRETURN SQLGetData(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN*);
	400	SQLRETURN SQLGetFunctions(SQLHDBC, SQLUSMALLINT, SQLUSMALLINT*);
	401	SQLRETURN SQLGetInfo(SQLHDBC, SQLUSMALLINT, SQLPOINTER, SQLSMALLINT, SQLSMALLINT*);
	402	SQLRETURN SQLGetTypeInfo(SQLHSTMT, SQLSMALLINT);
	403	SQLRETURN SQLParamData(SQLHSTMT, SQLPOINTER*);
	404	SQLRETURN SQLPutData(SQLHSTMT, SQLPOINTER, SQLLEN);
	405	SQLRETURN SQLSpecialColumns(SQLHSTMT, SQLUSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR*, SQLSMALLINT, SQLUSMALLINT, SQLUSMALLINT);
	406	SQLRETURN SQLStatistics(SQLHSTMT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR*, SQLSMALLINT, SQLUSMALLINT, SQLUSMALLINT);
	407	SQLRETURN SQLTables(SQLHSTMT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLCHAR, SQLSMALLINT);
	408	SQLRETURN SQLDataSources(SQLHENV, SQLUSMALLINT, SQLCHAR, SQLSMALLINT, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLSMALLINT);
	409
	410	static if (ODBCVER >= 0x0300) {
	411	SQLRETURN SQLAllocHandle(SQLSMALLINT, SQLHANDLE, SQLHANDLE*);
	412	SQLRETURN SQLBindParam(SQLHSTMT, SQLUSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLULEN, SQLSMALLINT, SQLPOINTER, SQLLEN*);
	413	SQLRETURN SQLCloseCursor(SQLHSTMT);
	414	SQLRETURN SQLColAttribute(SQLHSTMT, SQLUSMALLINT, SQLUSMALLINT, SQLPOINTER, SQLSMALLINT, SQLSMALLINT*, SQLPOINTER);
	415	SQLRETURN SQLCopyDesc(SQLHDESC, SQLHDESC);
	416	SQLRETURN SQLEndTran(SQLSMALLINT, SQLHANDLE, SQLSMALLINT);
	417	SQLRETURN SQLFetchScroll(SQLHSTMT, SQLSMALLINT, SQLROWOFFSET);
	418	SQLRETURN SQLFreeHandle(SQLSMALLINT, SQLHANDLE);
	419	SQLRETURN SQLGetConnectAttr(SQLHDBC, SQLINTEGER, SQLPOINTER, SQLINTEGER, SQLINTEGER*);
	420	SQLRETURN SQLGetDescField(SQLHDESC, SQLSMALLINT, SQLSMALLINT, SQLPOINTER, SQLINTEGER, SQLINTEGER*);
	421	SQLRETURN SQLGetDescRec(SQLHDESC, SQLSMALLINT, SQLCHAR, SQLSMALLINT, SQLSMALLINT,
	422	SQLSMALLINT, SQLSMALLINT, SQLLEN, SQLSMALLINT, SQLSMALLINT, SQLSMALLINT);
	423	SQLRETURN SQLGetDiagField(SQLSMALLINT, SQLHANDLE, SQLSMALLINT, SQLSMALLINT, SQLPOINTER, SQLSMALLINT, SQLSMALLINT*);
	424	SQLRETURN SQLGetDiagRec(SQLSMALLINT, SQLHANDLE, SQLSMALLINT, SQLCHAR, SQLINTEGER, SQLCHAR, SQLSMALLINT, SQLSMALLINT);
	425	SQLRETURN SQLGetEnvAttr(SQLHENV, SQLINTEGER, SQLPOINTER, SQLINTEGER, SQLINTEGER*);
	426	SQLRETURN SQLGetStmtAttr(SQLHSTMT, SQLINTEGER, SQLPOINTER, SQLINTEGER, SQLINTEGER*);
	427	SQLRETURN SQLSetConnectAttr(SQLHDBC, SQLINTEGER, SQLPOINTER, SQLINTEGER);
	428	SQLRETURN SQLSetDescField(SQLHDESC, SQLSMALLINT, SQLSMALLINT, SQLPOINTER, SQLINTEGER);
	429	SQLRETURN SQLSetDescRec(SQLHDESC, SQLSMALLINT, SQLSMALLINT, SQLSMALLINT, SQLLEN, SQLSMALLINT,
	430	SQLSMALLINT, SQLPOINTER, SQLLEN, SQLLEN);
	431	SQLRETURN SQLSetEnvAttr(SQLHENV, SQLINTEGER, SQLPOINTER, SQLINTEGER);
	432	SQLRETURN SQLSetStmtAttr(SQLHSTMT, SQLINTEGER, SQLPOINTER, SQLINTEGER);
	433	}/* (ODBCVER >= 0x0300) */
380	434	}
381		~~SQLRETURN SQLBindCol(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*);~~
382		~~SQLRETURN SQLCancel(SQLHSTMT);~~
383		~~SQLRETURN SQLConnect(SQLHDBC,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR*,SQLSMALLINT);~~
384		~~SQLRETURN SQLDescribeCol(SQLHSTMT,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLSMALLINT);~~
385		~~SQLRETURN SQLDisconnect(SQLHDBC);~~
386		~~SQLRETURN SQLExecDirect(SQLHSTMT,SQLCHAR*,SQLINTEGER);~~
387		~~SQLRETURN SQLExecute(SQLHSTMT);~~
388		~~SQLRETURN SQLFetch(SQLHSTMT);~~
389		~~SQLRETURN SQLFreeStmt(SQLHSTMT,SQLUSMALLINT);~~
390		~~SQLRETURN SQLGetCursorName(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLSMALLINT);~~
391		~~SQLRETURN SQLNumResultCols(SQLHSTMT,SQLSMALLINT*);~~
392		~~SQLRETURN SQLPrepare(SQLHSTMT,SQLCHAR*,SQLINTEGER);~~
393		~~SQLRETURN SQLRowCount(SQLHSTMT,SQLLEN*);~~
394		~~SQLRETURN SQLSetCursorName(SQLHSTMT,SQLCHAR*,SQLSMALLINT);~~
395		~~SQLRETURN SQLTransact(SQLHENV,SQLHDBC,SQLUSMALLINT);~~
396		~~SQLRETURN SQLColumns(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT);~~
397		~~SQLRETURN SQLGetData(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN*);~~
398		~~SQLRETURN SQLGetFunctions(SQLHDBC,SQLUSMALLINT,SQLUSMALLINT*);~~
399		~~SQLRETURN SQLGetInfo(SQLHDBC,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);~~
400		~~SQLRETURN SQLGetTypeInfo(SQLHSTMT,SQLSMALLINT);~~
401		~~SQLRETURN SQLParamData(SQLHSTMT,SQLPOINTER*);~~
402		~~SQLRETURN SQLPutData(SQLHSTMT,SQLPOINTER,SQLLEN);~~
403		~~SQLRETURN SQLSpecialColumns(SQLHSTMT,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);~~
404		~~SQLRETURN SQLStatistics(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR*,SQLSMALLINT,SQLUSMALLINT,SQLUSMALLINT);~~
405		~~SQLRETURN SQLTables(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT);~~
406		~~SQLRETURN SQLDataSources(SQLHENV,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT);~~
407
408		~~static if (ODBCVER >= 0x0300) {~~
409		~~SQLRETURN SQLAllocHandle(SQLSMALLINT,SQLHANDLE,SQLHANDLE*);~~
410		~~SQLRETURN SQLBindParam(SQLHSTMT,SQLUSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,SQLPOINTER,SQLLEN*);~~
411		~~SQLRETURN SQLCloseCursor(SQLHSTMT);~~
412		~~SQLRETURN SQLColAttribute(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,SQLPOINTER);~~
413		~~SQLRETURN SQLCopyDesc(SQLHDESC,SQLHDESC);~~
414		~~SQLRETURN SQLEndTran(SQLSMALLINT,SQLHANDLE,SQLSMALLINT);~~
415		~~SQLRETURN SQLFetchScroll(SQLHSTMT,SQLSMALLINT,SQLROWOFFSET);~~
416		~~SQLRETURN SQLFreeHandle(SQLSMALLINT,SQLHANDLE);~~
417		~~SQLRETURN SQLGetConnectAttr(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);~~
418		~~SQLRETURN SQLGetDescField(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER,SQLINTEGER*);~~
419		~~SQLRETURN SQLGetDescRec(SQLHDESC,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,~~
420		~~SQLSMALLINT,SQLSMALLINT,SQLLEN,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT);~~
421		~~SQLRETURN SQLGetDiagField(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*);~~
422		~~SQLRETURN SQLGetDiagRec(SQLSMALLINT,SQLHANDLE,SQLSMALLINT,SQLCHAR,SQLINTEGER,SQLCHAR,SQLSMALLINT,SQLSMALLINT);~~
423		~~SQLRETURN SQLGetEnvAttr(SQLHENV,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);~~
424		~~SQLRETURN SQLGetStmtAttr(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER,SQLINTEGER*);~~
425		~~SQLRETURN SQLSetConnectAttr(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER);~~
426		~~SQLRETURN SQLSetDescField(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLINTEGER);~~
427		~~SQLRETURN SQLSetDescRec(SQLHDESC,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLLEN,SQLSMALLINT,~~
428		~~SQLSMALLINT,SQLPOINTER,SQLLEN,SQLLEN);~~
429		~~SQLRETURN SQLSetEnvAttr(SQLHENV,SQLINTEGER,SQLPOINTER,SQLINTEGER);~~
430		~~SQLRETURN SQLSetStmtAttr(SQLHSTMT,SQLINTEGER,SQLPOINTER,SQLINTEGER);~~
431		~~}/* (ODBCVER >= 0x0300) */~~
432		}

trunk/win32/sqlext.d

r146	r155
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.sqlext;
10	11
11	12	/* Conversion notes:
…	…
15	16	creating a circular dependency!
16	17	*/
17		module win32.sqlext;
	18
18	19	public import win32.sql;
19	20	private import win32.windef;
…	…
21	22	const SQL_SPEC_MAJOR = 3;
22	23	const SQL_SPEC_MINOR = 51;
23		const char [] SQL_SPEC_STRING = "03.51";
	24	const char[] SQL_SPEC_STRING = "03.51";
24	25	const SQL_ACCESS_MODE = 101;
25	26	const SQL_ACTIVE_CONNECTIONS = 0;
…	…
36	37	const SQL_ALL_EXCEPT_LIKE = 2;
37	38
38		const SQL_API_ALL_FUNCTIONS = 0;
39		const SQL_API_SQLCOLATTRIBUTES = 6;
40		const SQL_API_SQLDRIVERCONNECT = 41;
41		const SQL_API_SQLBROWSECONNECT = 55;
42		const SQL_API_SQLCOLUMNPRIVILEGES = 56;
43		const SQL_API_SQLDESCRIBEPARAM = 58;
44		const SQL_API_SQLEXTENDEDFETCH = 59;
45		const SQL_API_SQLFOREIGNKEYS = 60;
46		const SQL_API_SQLMORERESULTS = 61;
47		const SQL_API_SQLNATIVESQL = 62;
48		const SQL_API_SQLNUMPARAMS = 63;
49		const SQL_API_SQLPARAMOPTIONS = 64;
50		const SQL_API_SQLPRIMARYKEYS = 65;
51		const SQL_API_SQLPROCEDURECOLUMNS = 66;
52		const SQL_API_SQLPROCEDURES = 67;
53		const SQL_API_SQLSETPOS = 68;
54		const SQL_API_SQLSETSCROLLOPTIONS = 69;
55		const SQL_API_SQLTABLEPRIVILEGES = 70;
56		const SQL_API_SQLDRIVERS = 71;
57		const SQL_API_SQLBINDPARAMETER = 72;
58		const SQL_API_LOADBYORDINAL = 199;
	39	const SQL_API_ALL_FUNCTIONS = 0;
	40	const SQL_API_SQLCOLATTRIBUTES = 6;
	41	const SQL_API_SQLDRIVERCONNECT = 41;
	42	const SQL_API_SQLBROWSECONNECT = 55;
	43	const SQL_API_SQLCOLUMNPRIVILEGES = 56;
	44	const SQL_API_SQLDESCRIBEPARAM = 58;
	45	const SQL_API_SQLEXTENDEDFETCH = 59;
	46	const SQL_API_SQLFOREIGNKEYS = 60;
	47	const SQL_API_SQLMORERESULTS = 61;
	48	const SQL_API_SQLNATIVESQL = 62;
	49	const SQL_API_SQLNUMPARAMS = 63;
	50	const SQL_API_SQLPARAMOPTIONS = 64;
	51	const SQL_API_SQLPRIMARYKEYS = 65;
	52	const SQL_API_SQLPROCEDURECOLUMNS = 66;
	53	const SQL_API_SQLPROCEDURES = 67;
	54	const SQL_API_SQLSETPOS = 68;
	55	const SQL_API_SQLSETSCROLLOPTIONS = 69;
	56	const SQL_API_SQLTABLEPRIVILEGES = 70;
	57	const SQL_API_SQLDRIVERS = 71;
	58	const SQL_API_SQLBINDPARAMETER = 72;
	59	const SQL_API_LOADBYORDINAL = 199;
59	60
60	61	const SQL_ASYNC_ENABLE = 4;

trunk/win32/sqltypes.d

r146	r155
1	1	/***********************************************************************\
2		* ~~sqltypes.d~~ *
	2	* sqltypes.d *
3	3	* *
4	4	* Windows API header module *
…	…
8	8	* Placed into public domain *
9	9	\***********************************************************************/
	10	module win32.sqltypes;
	11
10	12	/* Conversion notes:
11	13	It's assumed that ODBC >= 0x0300.
12	14	*/
13	15
14		~~module win32.sqltypes;~~
15		~~private import win32.basetyps;~~
16	16	private import win32.windef;
	17	private import win32.basetyps; // for GUID
17	18
18		alias byte SCHAR;
19		alias int SDWORD;
20		alias short SWORD;
	19	alias byte SCHAR, SQLSCHAR;
	20	alias int SDWORD, SLONG, SQLINTEGER;
	21	alias short SWORD, SSHORT, RETCODE, SQLSMALLINT;
21	22	alias ULONG UDWORD;
22		alias USHORT UWORD;
23		alias int SLONG;
24		alias short SSHORT;
25		alias double SDOUBLE;
26		alias double LDOUBLE;
	23	alias USHORT UWORD, SQLUSMALLINT;
	24	alias double SDOUBLE, LDOUBLE;
27	25	alias float SFLOAT;
28		alias PVOID PTR;
29		alias PVOID HENV;
30		alias PVOID HDBC;
31		alias PVOID HSTMT;
32		alias short RETCODE;
	26	alias PVOID PTR, HENV, HDBC, HSTMT, SQLPOINTER;
33	27	alias UCHAR SQLCHAR;
34		alias SCHAR SQLSCHAR;
35		alias SDWORD SQLINTEGER;
36		alias SWORD SQLSMALLINT;
37		// #ifndef __WIN64
	28	// #ifndef _WIN64
38	29	alias UDWORD SQLUINTEGER;
39	30	// #endif
40		~~alias UWORD SQLUSMALLINT;~~
41		~~alias PVOID SQLPOINTER;~~
42	31
43	32	//static if (ODBCVER >= 0x0300) {
44		typedef void* SQLHANDLE;
45		alias SQLHANDLE SQLHENV;
46		alias SQLHANDLE SQLHDBC;
47		alias SQLHANDLE SQLHSTMT;
48		alias SQLHANDLE SQLHDESC;
	33	typedef HANDLE SQLHANDLE;
	34	alias SQLHANDLE SQLHENV, SQLHDBC, SQLHSTMT, SQLHDESC;
49	35	/*
50	36	} else {
…	…
58	44	alias ULONG BOOKMARK;
59	45
60		alias SQLINTEGER SQLLEN;
61		alias SQLINTEGER SQLROWOFFSET;
62		alias SQLUINTEGER SQLROWCOUNT;
63		alias SQLUINTEGER SQLULEN;
	46	alias SQLINTEGER SQLLEN, SQLROWOFFSET;
	47	alias SQLUINTEGER SQLROWCOUNT, SQLULEN;
64	48	alias DWORD SQLTRANSID;
65	49	alias SQLUSMALLINT SQLSETPOSIROW;
…	…
72	56	}
73	57	//static if (ODBCVER >= 0x0300) {
74		alias ubyte SQLDATE;
75		alias ubyte SQLDECIMAL;
76		alias double SQLDOUBLE;
77		alias double SQLFLOAT;
78		alias ubyte SQLNUMERIC;
79		alias float SQLREAL;
80		alias ubyte SQLTIME;
81		alias ubyte SQLTIMESTAMP;
82		alias ubyte SQLVARCHAR;
83		alias long ODBCINT64;
84		alias long SQLBIGINT;
85		alias ulong SQLUBIGINT;
	58	alias ubyte SQLDATE, SQLDECIMAL;
	59	alias double SQLDOUBLE, SQLFLOAT;
	60	alias ubyte SQLNUMERIC;
	61	alias float SQLREAL;
	62	alias ubyte SQLTIME, SQLTIMESTAMP, SQLVARCHAR;
	63	alias long ODBCINT64, SQLBIGINT;
	64	alias ulong SQLUBIGINT;
86	65	//}
87	66
…	…
112	91	alias TIME_STRUCT SQL_TIME_STRUCT;
113	92	alias TIMESTAMP_STRUCT SQL_TIMESTAMP_STRUCT;
	93
114	94	enum SQLINTERVAL {
115	95	SQL_IS_YEAR = 1,

trunk/win32/sqlucode.d

r146	r155
9	9	\***********************************************************************/
10	10	module win32.sqlucode;
11		private import win32.sqlext;
	11
	12	private import win32.sqlext;
12	13
13	14	const SQL_WCHAR = -8;
…	…
18	19	const SQL_SQLSTATE_SIZEW = 10;
19	20	version(Unicode) {
20		const SQL_C_TCHAR = SQL_C_WCHAR;
	21	const SQL_C_TCHAR = SQL_C_WCHAR;
21	22	} else {
22		const SQL_C_TCHAR = SQL_C_CHAR;
	23	const SQL_C_TCHAR = SQL_C_CHAR;
23	24	}
24	25
…	…
37	38
38	39	extern (Windows) {
39		~~SQLRETURN SQLBrowseConnectA(SQLHDBC,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,~~SQLSMALLINT*);
40		~~SQLRETURN SQLBrowseConnectW(SQLHDBC,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,~~SQLSMALLINT*);
41		~~SQLRETURN SQLColAttributeA(SQLHSTMT,SQLSMALLINT,SQLSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,~~SQLPOINTER);
42		~~SQLRETURN SQLColAttributeW(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT*,~~SQLPOINTER);
43		~~SQLRETURN SQLColAttributesA(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT,~~SQLLEN);
44		~~SQLRETURN SQLColAttributesW(SQLHSTMT,SQLUSMALLINT,SQLUSMALLINT,SQLPOINTER,SQLSMALLINT,SQLSMALLINT,~~SQLLEN);
45		~~SQLRETURN SQLColumnPrivilegesA( SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT ,SQLCHAR,~~SQLSMALLINT );
46		~~SQLRETURN SQLColumnPrivilegesW( SQLHSTMT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,~~SQLSMALLINT );
47		~~SQLRETURN SQLColumnsA(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT ,SQLCHAR,~~SQLSMALLINT );
48		~~SQLRETURN SQLColumnsW(SQLHSTMT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT ,SQLWCHAR,~~SQLSMALLINT );
49		~~SQLRETURN SQLConnectA(SQLHDBC,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR*,~~SQLSMALLINT);
50		~~SQLRETURN SQLConnectW(SQLHDBC,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR*,~~SQLSMALLINT);
51		~~SQLRETURN SQLDataSourcesA(SQLHENV,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,SQLCHAR,SQLSMALLINT,~~SQLSMALLINT);
52		~~SQLRETURN SQLDataSourcesW(SQLHENV,SQLUSMALLINT,SQLWCHAR,SQLSMALLINT,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,~~SQLSMALLINT);
53		~~SQLRETURN SQLDescribeColA(SQLHSTMT,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,~~SQLSMALLINT);
54		~~SQLRETURN SQLDescribeColW(SQLHSTMT,SQLUSMALLINT,SQLWCHAR,SQLSMALLINT,SQLSMALLINT,SQLSMALLINT,SQLULEN,SQLSMALLINT,~~SQLSMALLINT);
55		~~SQLRETURN SQLDriverConnectA(SQLHDBC,SQLHWND,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT*,~~SQLUSMALLINT);
56		~~SQLRETURN SQLDriverConnectW(SQLHDBC,SQLHWND,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLSMALLINT*,~~SQLUSMALLINT);
57		~~SQLRETURN SQLDriversA(SQLHENV,SQLUSMALLINT,SQLCHAR,SQLSMALLINT,SQLSMALLINT,SQLCHAR,SQLSMALLINT,~~SQLSMALLINT);
58		~~SQLRETURN SQLDriversW(SQLHENV,SQLUSMALLINT,SQLWCHAR,SQLSMALLINT,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,~~SQLSMALLINT);
59		~~SQLRETURN SQLErrorA(SQLHENV,SQLHDBC,SQLHSTMT,SQLCHAR,SQLINTEGER,SQLCHAR,SQLSMALLINT,~~SQLSMALLINT);
60		~~SQLRETURN SQLErrorW(SQLHENV,SQLHDBC,SQLHSTMT,SQLWCHAR,SQLINTEGER,SQLWCHAR,SQLSMALLINT,~~SQLSMALLINT);
61		~~SQLRETURN SQLExecDirectA(SQLHSTMT,SQLCHAR*,~~SQLINTEGER);
62		~~SQLRETURN SQLExecDirectW(SQLHSTMT,SQLWCHAR*,~~SQLINTEGER);
63		~~SQLRETURN SQLForeignKeysA(SQLHSTMT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,SQLSMALLINT,SQLCHAR,~~SQLSMALLINT);
64		~~SQLRETURN SQLForeignKeysW(SQLHSTMT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,SQLSMALLINT,SQLWCHAR,~~SQLSMALLINT);
65		~~SQLRETURN SQLGetConnectAttrA(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,~~SQLINTEGER*);
66		~~SQLRETURN SQLGetConnectAttrW(SQLHDBC,SQLINTEGER,SQLPOINTER,SQLINTEGER,~~SQLINTEGER*);
67		~~SQLRETURN SQLGetConnectOptionA(SQLHDBC,SQLUSMALLINT,~~SQLPOINTER);
68		~~SQLRETURN SQLGetConnectOptionW(SQLHDBC,SQLUSMALLINT,~~SQLPOINTER);
69		~~SQLRETURN SQLGetCursorNameA(SQLHSTMT,SQLCHAR,SQLSMALLINT,~~SQLSMALLINT);

Navigation

Legend: