oaidl.d

Revision 374, 15.3 kB (checked in by CyberShadow, 3 months ago)

Remove deprecated base class protection attributes from interface declarations

"interface Foo : public Bar" => "interface Foo : Bar"

Line
1	/***********************************************************************\
2	* oaidl.d *
3	* *
4	* Windows API header module *
5	* *
6	* Translated from MinGW Windows headers *
7	* *
8	* Placed into public domain *
9	\***********************************************************************/
10	module win32.oaidl;
11
12	private import win32.basetyps, win32.unknwn, win32.windef, win32.wtypes;
13
14	const DISPID_UNKNOWN = -1;
15	const DISPID_VALUE = 0;
16	const DISPID_PROPERTYPUT = -3;
17	const DISPID_NEWENUM = -4;
18	const DISPID_EVALUATE = -5;
19	const DISPID_CONSTRUCTOR = -6;
20	const DISPID_DESTRUCTOR = -7;
21	const DISPID_COLLECT = -8;
22
23	const FADF_AUTO = 1;
24	const FADF_STATIC = 2;
25	const FADF_EMBEDDED = 4;
26	const FADF_FIXEDSIZE = 16;
27	const FADF_RECORD = 32;
28	const FADF_HAVEIID = 64;
29	const FADF_HAVEVARTYPE = 128;
30	const FADF_BSTR = 256;
31	const FADF_UNKNOWN = 512;
32	const FADF_DISPATCH = 1024;
33	const FADF_VARIANT = 2048;
34	const FADF_RESERVED = 0xf0e8;
35	const FADF_DATADELETED = 0x1000;
36	const FADF_CREATEVECTOR = 0x2000;
37
38	const PARAMFLAG_NONE = 0;
39	const PARAMFLAG_FIN = 1;
40	const PARAMFLAG_FOUT = 2;
41	const PARAMFLAG_FLCID = 4;
42	const PARAMFLAG_FRETVAL = 8;
43	const PARAMFLAG_FOPT = 16;
44	const PARAMFLAG_FHASDEFAULT = 32;
45
46	const IDLFLAG_NONE = PARAMFLAG_NONE;
47	const IDLFLAG_FIN = PARAMFLAG_FIN;
48	const IDLFLAG_FOUT = PARAMFLAG_FOUT;
49	const IDLFLAG_FLCID = PARAMFLAG_FLCID;
50	const IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;
51
52	const IMPLTYPEFLAG_FDEFAULT = 1;
53	const IMPLTYPEFLAG_FSOURCE = 2;
54	const IMPLTYPEFLAG_FRESTRICTED = 4;
55	const IMPLTYPEFLAG_FDEFAULTVTABLE = 8;
56
57
58	enum SYSKIND {
59	SYS_WIN16,
60	SYS_WIN32,
61	SYS_MAC
62	}
63
64	enum LIBFLAGS {
65	LIBFLAG_FRESTRICTED = 1,
66	LIBFLAG_FCONTROL = 2,
67	LIBFLAG_FHIDDEN = 4,
68	LIBFLAG_FHASDISKIMAGE = 8
69	}
70
71	struct TLIBATTR {
72	GUID guid;
73	LCID lcid;
74	SYSKIND syskind;
75	WORD wMajorVerNum;
76	WORD wMinorVerNum;
77	WORD wLibFlags;
78	}
79	alias TLIBATTR* LPTLIBATTR;
80
81	alias CY CURRENCY;
82
83	struct SAFEARRAYBOUND {
84	ULONG cElements;
85	LONG lLbound;
86	}
87	alias SAFEARRAYBOUND* LPSAFEARRAYBOUND;
88
89	struct SAFEARR_BSTR {
90	ULONG Size;
91	wireBSTR* aBstr;
92	}
93
94	struct SAFEARR_UNKNOWN {
95	ULONG Size;
96	IUnknown** apUnknown;
97	}
98
99	struct SAFEARR_DISPATCH {
100	ULONG Size;
101	LPDISPATCH* apDispatch;
102	}
103
104	struct SAFEARR_VARIANT {
105	ULONG Size;
106	_wireVARIANT* aVariant;
107	}
108
109	enum SF_TYPE {
110	SF_ERROR=VARENUM.VT_ERROR,
111	SF_I1=VARENUM.VT_I1,
112	SF_I2=VARENUM.VT_I2,
113	SF_I4=VARENUM.VT_I4,
114	SF_I8=VARENUM.VT_I8,
115	SF_BSTR=VARENUM.VT_BSTR,
116	SF_UNKNOWN=VARENUM.VT_UNKNOWN,
117	SF_DISPATCH=VARENUM.VT_DISPATCH,
118	SF_VARIANT=VARENUM.VT_VARIANT
119	}
120
121	struct _wireBRECORD {
122	ULONG fFlags;
123	ULONG clSize;
124	LPRECORDINFO* pRecInfo;
125	byte* pRecord;
126	}
127	alias _wireBRECORD* wireBRECORD;
128
129	struct SAFEARR_BRECORD {
130	ULONG Size;
131	wireBRECORD* aRecord;
132	}
133
134	struct SAFEARR_HAVEIID {
135	ULONG Size;
136	IUnknown** apUnknown;
137	IID iid;
138	}
139
140	struct SAFEARRAYUNION {
141	ULONG sfType;
142	union _u {
143	SAFEARR_BSTR BstrStr;
144	SAFEARR_UNKNOWN UnknownStr;
145	SAFEARR_DISPATCH DispatchStr;
146	SAFEARR_VARIANT VariantStr;
147	SAFEARR_BRECORD RecordStr;
148	SAFEARR_HAVEIID HaveIidStr;
149	BYTE_SIZEDARR ByteStr;
150	WORD_SIZEDARR WordStr;
151	DWORD_SIZEDARR LongStr;
152	HYPER_SIZEDARR HyperStr;
153	}
154	_u u;
155	}
156
157	struct _wireSAFEARRAY {
158	USHORT cDims;
159	USHORT fFeatures;
160	ULONG cbElements;
161	ULONG cLocks;
162	SAFEARRAYUNION uArrayStructs;
163	SAFEARRAYBOUND rgsabound[1];
164	}
165	alias _wireSAFEARRAY* wireSAFEARRAY;
166
167	alias wireSAFEARRAY* wirePSAFEARRAY;
168
169	struct SAFEARRAY {
170	USHORT cDims;
171	USHORT fFeatures;
172	ULONG cbElements;
173	ULONG cLocks;
174	PVOID pvData;
175	SAFEARRAYBOUND rgsabound[1];
176	}
177	alias SAFEARRAY* LPSAFEARRAY;
178
179	struct VARIANT {
180	union {
181	struct {
182	VARTYPE vt;
183	WORD wReserved1;
184	WORD wReserved2;
185	WORD wReserved3;
186	union {
187	int lVal;
188	LONGLONG llVal;
189	ubyte bVal;
190	short iVal;
191	float fltVal;
192	double dblVal;
193	VARIANT_BOOL boolVal;
194	SCODE scode;
195	CY cyVal;
196	DATE date;
197	BSTR bstrVal;
198	IUnknown punkVal;
199	IDispatch pdispVal;
200	SAFEARRAY* parray;
201	ubyte* pbVal;
202	short* piVal;
203	int* plVal;
204	float* pfltVal;
205	double* pdblVal;
206	VARIANT_BOOL* pboolVal;
207	_VARIANT_BOOL* pbool;
208	SCODE* pscode;
209	CY* pcyVal;
210	DATE* pdate;
211	BSTR* pbstrVal;
212	IUnknown* ppunkVal;
213	IDispatch* ppdispVal;
214	SAFEARRAY** pparray;
215	VARIANT* pvarVal;
216	void* byref;
217	CHAR cVal;
218	USHORT uiVal;
219	ULONG ulVal;
220	ULONGLONG ullVal;
221	INT intVal;
222	UINT uintVal;
223	DECIMAL* pdecVal;
224	CHAR* pcVal;
225	USHORT* puiVal;
226	ULONG* pulVal;
227	INT* pintVal;
228	UINT* puintVal;
229	struct {
230	PVOID pvRecord;
231	IRecordInfo pRecInfo;
232	}
233	}
234	}
235	DECIMAL decVal;
236	}
237	}
238	alias VARIANT* LPVARIANT;
239
240	alias VARIANT VARIANTARG;
241	alias VARIANT* LPVARIANTARG;
242
243	struct _wireVARIANT {
244	DWORD clSize;
245	DWORD rpcReserved;
246	USHORT vt;
247	USHORT wReserved1;
248	USHORT wReserved2;
249	USHORT wReserved3;
250	union {
251	LONG lVal;
252	LONGLONG llVal;
253	BYTE bVal;
254	SHORT iVal;
255	FLOAT fltVal;
256	DOUBLE dblVal;
257	VARIANT_BOOL boolVal;
258	SCODE scode;
259	CY cyVal;
260	DATE date;
261	wireBSTR bstrVal;
262	IUnknown* punkVal;
263	LPDISPATCH pdispVal;
264	wirePSAFEARRAY parray;
265	wireBRECORD brecVal;
266	BYTE* pbVal;
267	SHORT* piVal;
268	LONG* plVal;
269	FLOAT* pfltVal;
270	DOUBLE* pdblVal;
271	VARIANT_BOOL* pboolVal;
272	SCODE* pscode;
273	CY* pcyVal;
274	DATE* pdate;
275	wireBSTR* pbstrVal;
276	IUnknown** ppunkVal;
277	LPDISPATCH* ppdispVal;
278	wirePSAFEARRAY* pparray;
279	wireVARIANT* pvarVal;
280	CHAR cVal;
281	USHORT uiVal;
282	ULONG ulVal;
283	ULONGLONG ullVal;
284	INT intVal;
285	UINT uintVal;
286	DECIMAL decVal;
287	DECIMAL* pdecVal;
288	CHAR* pcVal;
289	USHORT* puiVal;
290	ULONG* pulVal;
291	INT* pintVal;
292	UINT* puintVal;
293	}
294	}
295	alias _wireVARIANT* wireVARIANT;
296
297	alias LONG DISPID;
298	alias DISPID MEMBERID;
299	alias DWORD HREFTYPE;
300
301	enum TYPEKIND {
302	TKIND_ENUM, TKIND_RECORD, TKIND_MODULE, TKIND_INTERFACE, TKIND_DISPATCH,
303	TKIND_COCLASS, TKIND_ALIAS, TKIND_UNION, TKIND_MAX
304	}
305
306	struct TYPEDESC {
307	union {
308	TYPEDESC* lptdesc;
309	ARRAYDESC* lpadesc;
310	HREFTYPE hreftype;
311	}
312	VARTYPE vt;
313	}
314
315	struct ARRAYDESC {
316	TYPEDESC tdescElem;
317	USHORT cDims;
318	SAFEARRAYBOUND rgbounds[1];
319	}
320
321	struct PARAMDESCEX {
322	ULONG cBytes;
323	VARIANTARG varDefaultValue;
324	}
325	alias PARAMDESCEX* LPPARAMDESCEX;
326
327	struct PARAMDESC {
328	LPPARAMDESCEX pparamdescex;
329	USHORT wParamFlags;
330	}
331	alias PARAMDESC* LPPARAMDESC;
332
333	struct IDLDESC {
334	ULONG dwReserved;
335	USHORT wIDLFlags;
336	}
337	alias IDLDESC* LPIDLDESC;
338
339	struct ELEMDESC {
340	TYPEDESC tdesc;
341	union {
342	IDLDESC idldesc;
343	PARAMDESC paramdesc;
344	}
345	}
346	alias ELEMDESC* LPELEMDESC;
347
348	struct TYPEATTR {
349	GUID guid;
350	LCID lcid;
351	DWORD dwReserved;
352	MEMBERID memidConstructor;
353	MEMBERID memidDestructor;
354	LPOLESTR lpstrSchema;
355	ULONG cbSizeInstance;
356	TYPEKIND typekind;
357	WORD cFuncs;
358	WORD cVars;
359	WORD cImplTypes;
360	WORD cbSizeVft;
361	WORD cbAlignment;
362	WORD wTypeFlags;
363	WORD wMajorVerNum;
364	WORD wMinorVerNum;
365	TYPEDESC tdescAlias;
366	IDLDESC idldescType;
367	}
368	alias TYPEATTR* LPTYPEATTR;
369
370	struct DISPPARAMS {
371	VARIANTARG* rgvarg;
372	DISPID* rgdispidNamedArgs;
373	UINT cArgs;
374	UINT cNamedArgs;
375	}
376
377	struct EXCEPINFO {
378	WORD wCode;
379	WORD wReserved;
380	BSTR bstrSource;
381	BSTR bstrDescription;
382	BSTR bstrHelpFile;
383	DWORD dwHelpContext;
384	PVOID pvReserved;
385	extern (Windows) {
386	HRESULT function (EXCEPINFO* ) pfnDeferredFillIn;
387	}
388	SCODE scode;
389	}
390	alias EXCEPINFO* LPEXCEPINFO;
391
392	enum CALLCONV {
393	CC_FASTCALL,
394	CC_CDECL,
395	CC_MSCPASCAL,
396	CC_PASCAL=CC_MSCPASCAL,
397	CC_MACPASCAL,
398	CC_STDCALL,
399	CC_FPFASTCALL,
400	CC_SYSCALL,
401	CC_MPWCDECL,
402	CC_MPWPASCAL,
403	CC_MAX=CC_MPWPASCAL
404	}
405
406	enum FUNCKIND {
407	FUNC_VIRTUAL,
408	FUNC_PUREVIRTUAL,
409	FUNC_NONVIRTUAL,
410	FUNC_STATIC,
411	FUNC_DISPATCH
412	}
413
414	enum INVOKEKIND {
415	INVOKE_FUNC = 1,
416	INVOKE_PROPERTYGET = 2,
417	INVOKE_PROPERTYPUT = 4,
418	INVOKE_PROPERTYPUTREF = 8
419	}
420
421	struct FUNCDESC {
422	MEMBERID memid;
423	SCODE* lprgscode;
424	ELEMDESC* lprgelemdescParam;
425	FUNCKIND funckind;
426	INVOKEKIND invkind;
427	CALLCONV callconv;
428	SHORT cParams;
429	SHORT cParamsOpt;
430	SHORT oVft;
431	SHORT cScodes;
432	ELEMDESC elemdescFunc;
433	WORD wFuncFlags;
434	}
435	alias FUNCDESC* LPFUNCDESC;
436
437	enum VARKIND {
438	VAR_PERINSTANCE, VAR_STATIC, VAR_CONST, VAR_DISPATCH
439	}
440
441	struct VARDESC {
442	MEMBERID memid;
443	LPOLESTR lpstrSchema;
444	union {
445	ULONG oInst;
446	VARIANT* lpvarValue;
447	}
448	ELEMDESC elemdescVar;
449	WORD wVarFlags;
450	VARKIND varkind;
451	}
452	alias VARDESC* LPVARDESC;
453
454	enum TYPEFLAGS {
455	TYPEFLAG_FAPPOBJECT = 1,
456	TYPEFLAG_FCANCREATE = 2,
457	TYPEFLAG_FLICENSED = 4,
458	TYPEFLAG_FPREDECLID = 8,
459	TYPEFLAG_FHIDDEN = 16,
460	TYPEFLAG_FCONTROL = 32,
461	TYPEFLAG_FDUAL = 64,
462	TYPEFLAG_FNONEXTENSIBLE = 128,
463	TYPEFLAG_FOLEAUTOMATION = 256,
464	TYPEFLAG_FRESTRICTED = 512,
465	TYPEFLAG_FAGGREGATABLE = 1024,
466	TYPEFLAG_FREPLACEABLE = 2048,
467	TYPEFLAG_FDISPATCHABLE = 4096,
468	TYPEFLAG_FREVERSEBIND = 8192
469	}
470
471	enum FUNCFLAGS {
472	FUNCFLAG_FRESTRICTED = 1,
473	FUNCFLAG_FSOURCE = 2,
474	FUNCFLAG_FBINDABLE = 4,
475	FUNCFLAG_FREQUESTEDIT = 8,
476	FUNCFLAG_FDISPLAYBIND = 16,
477	FUNCFLAG_FDEFAULTBIND = 32,
478	FUNCFLAG_FHIDDEN = 64,
479	FUNCFLAG_FUSESGETLASTERROR = 128,
480	FUNCFLAG_FDEFAULTCOLLELEM = 256,
481	FUNCFLAG_FUIDEFAULT = 512,
482	FUNCFLAG_FNONBROWSABLE = 1024,
483	FUNCFLAG_FREPLACEABLE = 2048,
484	FUNCFLAG_FIMMEDIATEBIND = 4096
485	}
486
487	enum VARFLAGS {
488	VARFLAG_FREADONLY = 1,
489	VARFLAG_FSOURCE = 2,
490	VARFLAG_FBINDABLE = 4,
491	VARFLAG_FREQUESTEDIT = 8,
492	VARFLAG_FDISPLAYBIND = 16,
493	VARFLAG_FDEFAULTBIND = 32,
494	VARFLAG_FHIDDEN = 64,
495	VARFLAG_FRESTRICTED = 128,
496	VARFLAG_FDEFAULTCOLLELEM = 256,
497	VARFLAG_FUIDEFAULT = 512,
498	VARFLAG_FNONBROWSABLE = 1024,
499	VARFLAG_FREPLACEABLE = 2048,
500	VARFLAG_FIMMEDIATEBIND = 4096
501	}
502
503	struct CLEANLOCALSTORAGE {
504	IUnknown* pInterface;
505	PVOID pStorage;
506	DWORD flags;
507	}
508
509	struct CUSTDATAITEM {
510	GUID guid;
511	VARIANTARG varValue;
512	}
513	alias CUSTDATAITEM* LPCUSTDATAITEM;
514
515	struct CUSTDATA {
516	DWORD cCustData;
517	LPCUSTDATAITEM prgCustData;
518	}
519	alias CUSTDATA* LPCUSTDATA;
520
521	enum DESCKIND {
522	DESCKIND_NONE = 0,
523	DESCKIND_FUNCDESC = DESCKIND_NONE+1,
524	DESCKIND_VARDESC = DESCKIND_FUNCDESC+1,
525	DESCKIND_TYPECOMP = DESCKIND_VARDESC+1,
526	DESCKIND_IMPLICITAPPOBJ = DESCKIND_TYPECOMP+1,
527	DESCKIND_MAX = DESCKIND_IMPLICITAPPOBJ+1
528	}
529
530	union BINDPTR {
531	LPFUNCDESC lpfuncdesc;
532	LPVARDESC lpvardesc;
533	LPTYPECOMP lptcomp;
534	}
535	alias BINDPTR* LPBINDPTR;
536
537	interface IDispatch : IUnknown {
538	HRESULT GetTypeInfoCount(UINT*);
539	HRESULT GetTypeInfo(UINT, LCID, LPTYPEINFO*);
540	HRESULT GetIDsOfNames(REFIID, LPOLESTR, UINT, LCID, DISPID);
541	HRESULT Invoke(DISPID, REFIID, LCID, WORD, DISPPARAMS, VARIANT, EXCEPINFO, UINT);
542	}
543	alias IDispatch LPDISPATCH;
544
545	interface IEnumVARIANT : IUnknown {
546	HRESULT Next(ULONG, VARIANT, ULONG);
547	HRESULT Skip(ULONG);
548	HRESULT Reset();
549	HRESULT Clone(IEnumVARIANT**);
550	}
551	alias IEnumVARIANT LPENUMVARIANT;
552
553	interface ITypeComp : IUnknown {
554	HRESULT Bind(LPOLESTR, ULONG, WORD, LPTYPEINFO, DESCKIND, LPBINDPTR);
555	HRESULT BindType(LPOLESTR, ULONG, LPTYPEINFO, LPTYPECOMP);
556	}
557	alias ITypeComp LPTYPECOMP;
558
559	interface ITypeInfo : IUnknown {
560	HRESULT GetTypeAttr(LPTYPEATTR*);
561	HRESULT GetTypeComp(LPTYPECOMP*);
562	HRESULT GetFuncDesc(UINT, LPFUNCDESC*);
563	HRESULT GetVarDesc(UINT, LPVARDESC*);
564	HRESULT GetNames(MEMBERID, BSTR, UINT, UINT);
565	HRESULT GetRefTypeOfImplType(UINT, HREFTYPE*);
566	HRESULT GetImplTypeFlags(UINT, INT*);
567	HRESULT GetIDsOfNames(LPOLESTR, UINT, MEMBERID);
568	HRESULT Invoke(PVOID, MEMBERID, WORD, DISPPARAMS, VARIANT, EXCEPINFO*,
569	UINT*);
570	HRESULT GetDocumentation(MEMBERID, BSTR, BSTR, DWORD, BSTR);
571	HRESULT GetDllEntry(MEMBERID, INVOKEKIND, BSTR, BSTR, WORD*);
572	HRESULT GetRefTypeInfo(HREFTYPE, LPTYPEINFO*);
573	HRESULT AddressOfMember(MEMBERID, INVOKEKIND, PVOID*);
574	HRESULT CreateInstance(LPUNKNOWN, REFIID, PVOID*);
575	HRESULT GetMops(MEMBERID, BSTR*);
576	HRESULT GetContainingTypeLib(LPTYPELIB, UINT);
577	void ReleaseTypeAttr(LPTYPEATTR);
578	void ReleaseFuncDesc(LPFUNCDESC);
579	void ReleaseVarDesc(LPVARDESC);
580	}
581	alias ITypeInfo LPTYPEINFO;
582
583	interface ITypeInfo2 : ITypeInfo {
584	HRESULT GetTypeKind(TYPEKIND*);
585	HRESULT GetTypeFlags(ULONG*);
586	HRESULT GetFuncIndexOfMemId(MEMBERID, INVOKEKIND, UINT*);
587	HRESULT GetVarIndexOfMemId(MEMBERID, UINT*);
588	HRESULT GetCustData(REFGUID, VARIANT*);
589	HRESULT GetFuncCustData(UINT, REFGUID, VARIANT*);
590	HRESULT GetParamCustData(UINT, UINT, REFGUID, VARIANT*);
591	HRESULT GetVarCustData(UINT, REFGUID, VARIANT*);
592	HRESULT GetImplTypeCustData(UINT, REFGUID, VARIANT*);
593	HRESULT GetDocumentation2(MEMBERID, LCID, BSTR, DWORD, BSTR*);
594	HRESULT GetAllCustData(CUSTDATA*);
595	HRESULT GetAllFuncCustData(UINT, CUSTDATA*);
596	HRESULT GetAllParamCustData(UINT, UINT, CUSTDATA*);
597	HRESULT GetAllVarCustData(UINT, CUSTDATA*);
598	HRESULT GetAllImplTypeCustData(UINT, CUSTDATA*);
599	}
600	alias ITypeInfo2 LPTYPEINFO2;
601
602	interface ITypeLib : IUnknown {
603	UINT GetTypeInfoCount();
604	HRESULT GetTypeInfo(UINT, ITypeInfo**);
605	HRESULT GetTypeInfoType(UINT, TYPEKIND*);
606	HRESULT GetTypeInfoOfGuid(REFGUID, ITypeInfo**);
607	HRESULT GetLibAttr(TLIBATTR**);
608	HRESULT GetTypeComp(ITypeComp*);
609	HRESULT GetDocumentation(INT, BSTR, BSTR, DWORD, BSTR);
610	HRESULT IsName(LPOLESTR, ULONG, BOOL*);
611	HRESULT FindName(LPOLESTR, ULONG, ITypeInfo*, MEMBERID, USHORT*);
612	void ReleaseTLibAttr(TLIBATTR*);
613	}
614	alias ITypeLib LPTYPELIB;
615
616	interface ITypeLib2 : ITypeLib {
617	HRESULT GetCustData(REFGUID, VARIANT*);
618	HRESULT GetLibStatistics(ULONG, ULONG);
619	HRESULT GetDocumentation2(INT, LCID, BSTR, DWORD, BSTR*);
620	HRESULT GetAllCustData(CUSTDATA*);
621	}
622	alias ITypeLib2 LPTYPELIB2;
623
624	interface IErrorInfo : IUnknown {
625	HRESULT GetGUID(GUID*);
626	HRESULT GetSource(BSTR*);
627	HRESULT GetDescription(BSTR*);
628	HRESULT GetHelpFile(BSTR*);
629	HRESULT GetHelpContext(DWORD*);
630	}
631	alias IErrorInfo LPERRORINFO;
632
633	interface ICreateErrorInfo : IUnknown {
634	HRESULT SetGUID(REFGUID);
635	HRESULT SetSource(LPOLESTR);
636	HRESULT SetDescription(LPOLESTR);
637	HRESULT SetHelpFile(LPOLESTR);
638	HRESULT SetHelpContext(DWORD);
639	}
640	alias ICreateErrorInfo* LPCREATEERRORINFO;
641
642	interface ISupportErrorInfo : IUnknown {
643	HRESULT InterfaceSupportsErrorInfo(REFIID);
644	}
645	alias ISupportErrorInfo LPSUPPORTERRORINFO;
646
647	interface IRecordInfo : IUnknown {
648	HRESULT RecordInit(PVOID);
649	HRESULT RecordClear(PVOID);
650	HRESULT RecordCopy(PVOID, PVOID);
651	HRESULT GetGuid(GUID*);
652	HRESULT GetName(BSTR*);
653	HRESULT GetSize(ULONG*);
654	HRESULT GetTypeInfo(ITypeInfo**);
655	HRESULT GetField(PVOID, LPCOLESTR, VARIANT*);
656	HRESULT GetFieldNoCopy(PVOID, LPCOLESTR, VARIANT, PVOID);
657	HRESULT PutField (ULONG, PVOID, LPCOLESTR, VARIANT*);
658	HRESULT PutFieldNoCopy(ULONG, PVOID, LPCOLESTR, VARIANT*);
659	HRESULT GetFieldNames(ULONG, BSTR);
660	BOOL IsMatchingType();
661	PVOID RecordCreate();
662	HRESULT RecordCreateCopy(PVOID, PVOID*);
663	HRESULT RecordDestroy (PVOID);
664	}
665	alias IRecordInfo LPRECORDINFO;
666
667	interface ITypeMarshal : IUnknown {
668	HRESULT Size(PVOID, DWORD, PVOID, ULONG*);
669	HRESULT Marshal(PVOID, DWORD, PVOID, ULONG, BYTE, ULONG);
670	HRESULT Unmarshal(PVOID, DWORD, ULONG, BYTE, ULONG);
671	HRESULT Free(PVOID);
672	}

Note: See TracBrowser for help on using the browser.

bindings

root/trunk/win32/oaidl.d

Download in other formats: