oaidl.idl: Added REFVARIANT declaration.
[wine] / include / oaidl.idl
1 /*
2  * Copyright 2002 Ove Kaaven
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #ifndef DO_NO_IMPORTS
20 import "objidl.idl";
21 #endif
22
23 interface IDispatch;
24 interface ITypeInfo;
25 interface ITypeLib;
26 interface IRecordInfo;
27
28 [
29   version(1.0),
30   pointer_default(unique)
31 ]
32 interface IOleAutomationTypes
33 {
34
35 typedef CY CURRENCY;
36
37 /* Safe Array */
38
39 typedef struct tagSAFEARRAYBOUND {
40   ULONG cElements;
41   LONG lLbound;
42 } SAFEARRAYBOUND, *LPSAFEARRAYBOUND;
43
44 typedef [unique] struct _wireVARIANT *wireVARIANT;
45 typedef [unique] struct _wireBRECORD *wireBRECORD;
46
47 typedef struct _wireSAFEARR_BSTR {
48   ULONG Size;
49   [size_is(Size), ref] wireBSTR *aBstr;
50 } SAFEARR_BSTR;
51
52 typedef struct _wireSAFEARR_UNKNOWN {
53   ULONG Size;
54   [size_is(Size), ref] IUnknown **apUnknown;
55 } SAFEARR_UNKNOWN;
56
57 typedef struct _wireSAFEARR_DISPATCH {
58   ULONG Size;
59   [size_is(Size), ref] IDispatch **apDispatch;
60 } SAFEARR_DISPATCH;
61
62 typedef struct _wireSAFEARR_VARIANT {
63   ULONG Size;
64   [size_is(Size), ref] wireVARIANT *aVariant;
65 } SAFEARR_VARIANT;
66
67 typedef struct _wireSAFEARR_BRECORD {
68   ULONG Size;
69   [size_is(Size), ref] wireBRECORD *aRecord;
70 } SAFEARR_BRECORD;
71
72 typedef struct _wireSAFEARR_HAVEIID {
73   ULONG Size;
74   [size_is(Size), ref] IUnknown **apUnknown;
75   IID iid;
76 } SAFEARR_HAVEIID;
77
78 typedef [v1_enum] enum tagSF_TYPE {
79   SF_ERROR    = VT_ERROR,
80   SF_I1       = VT_I1,
81   SF_I2       = VT_I2,
82   SF_I4       = VT_I4,
83   SF_I8       = VT_I8,
84   SF_BSTR     = VT_BSTR,
85   SF_UNKNOWN  = VT_UNKNOWN,
86   SF_DISPATCH = VT_DISPATCH,
87   SF_VARIANT  = VT_VARIANT,
88   SF_RECORD   = VT_RECORD,
89   SF_HAVEIID  = VT_UNKNOWN|VT_RESERVED,
90 } SF_TYPE;
91
92 typedef union _wireSAFEARRAY_UNION switch(ULONG sfType) u {
93   case SF_BSTR:     SAFEARR_BSTR BstrStr;
94   case SF_UNKNOWN:  SAFEARR_UNKNOWN UnknownStr;
95   case SF_DISPATCH: SAFEARR_DISPATCH DispatchStr;
96   case SF_VARIANT:  SAFEARR_VARIANT VariantStr;
97   case SF_RECORD:   SAFEARR_BRECORD RecordStr;
98   case SF_HAVEIID:  SAFEARR_HAVEIID HaveIidStr;
99   case SF_I1:       BYTE_SIZEDARR ByteStr;
100   case SF_I2:       WORD_SIZEDARR WordStr;
101   case SF_I4:       DWORD_SIZEDARR LongStr;
102   case SF_I8:       HYPER_SIZEDARR HyperStr;
103 } SAFEARRAYUNION;
104
105 typedef [unique] struct _wireSAFEARRAY {
106   USHORT cDims;
107   USHORT fFeatures;
108   ULONG cbElements;
109   ULONG cLocks;
110   SAFEARRAYUNION uArrayStructs;
111   [size_is(cDims)] SAFEARRAYBOUND rgsabound[];
112 } *wireSAFEARRAY;
113
114 typedef [unique] wireSAFEARRAY *wirePSAFEARRAY;
115
116 typedef struct tagSAFEARRAY {
117   USHORT cDims;
118   USHORT fFeatures;
119   ULONG cbElements;
120   ULONG cLocks;
121   PVOID pvData;
122   SAFEARRAYBOUND rgsabound[];
123 } SAFEARRAY;
124
125 typedef [wire_marshal(wirePSAFEARRAY)] SAFEARRAY *LPSAFEARRAY;
126
127 const USHORT FADF_AUTO        = 0x0001;
128 const USHORT FADF_STATIC      = 0x0002;
129 const USHORT FADF_EMBEDDED    = 0x0004;
130 const USHORT FADF_FIXEDSIZE   = 0x0010;
131 const USHORT FADF_RECORD      = 0x0020;
132 const USHORT FADF_HAVEIID     = 0x0040;
133 const USHORT FADF_HAVEVARTYPE = 0x0080;
134 const USHORT FADF_BSTR        = 0x0100;
135 const USHORT FADF_UNKNOWN     = 0x0200;
136 const USHORT FADF_DISPATCH    = 0x0400;
137 const USHORT FADF_VARIANT     = 0x0800;
138 const USHORT FADF_RESERVED    = 0xF008;
139 /* Undocumented flags */
140 const USHORT FADF_DATADELETED  = 0x1000; /* Data in a vector has been deleted */
141 const USHORT FADF_CREATEVECTOR = 0x2000; /* This array is a vector */
142
143 /* Variant */
144
145 cpp_quote("#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)")
146 cpp_quote("#define __VARIANT_NAME_1 n1")
147 cpp_quote("#define __VARIANT_NAME_2 n2")
148 cpp_quote("#define __VARIANT_NAME_3 n3")
149 cpp_quote("#define __VARIANT_NAME_4 brecVal")
150 cpp_quote("#else")
151 cpp_quote("#define __tagVARIANT")
152 cpp_quote("#define __VARIANT_NAME_1")
153 cpp_quote("#define __VARIANT_NAME_2")
154 cpp_quote("#define __VARIANT_NAME_3")
155 cpp_quote("#define __tagBRECORD")
156 cpp_quote("#define __VARIANT_NAME_4")
157 cpp_quote("#endif")
158
159 typedef [wire_marshal(wireVARIANT)] struct tagVARIANT VARIANT;
160
161 struct tagVARIANT {
162   union {
163     struct __tagVARIANT {
164       VARTYPE vt;
165       WORD wReserved1;
166       WORD wReserved2;
167       WORD wReserved3;
168       union {
169         signed char cVal;
170         USHORT uiVal;
171         ULONG ulVal;
172         INT intVal;
173         UINT uintVal;
174         BYTE bVal;
175         SHORT iVal;
176         LONG lVal;
177         FLOAT fltVal;
178         DOUBLE dblVal;
179         VARIANT_BOOL boolVal;
180 #if 0 /* illegal in C++ */
181         _VARIANT_BOOL bool;
182 #endif
183         SCODE scode;
184         DATE date;
185         BSTR bstrVal;
186         CY cyVal;
187         IUnknown *punkVal;
188         IDispatch *pdispVal;
189         SAFEARRAY *parray;
190         LONGLONG llVal;
191         ULONGLONG ullVal;
192         signed char *pcVal;
193         USHORT *puiVal;
194         ULONG *pulVal;
195         INT *pintVal;
196         UINT *puintVal;
197         BYTE *pbVal;
198         SHORT *piVal;
199         LONG *plVal;
200         FLOAT *pfltVal;
201         DOUBLE *pdblVal;
202         VARIANT_BOOL *pboolVal;
203 #if 0
204         _VARIANT_BOOL *pbool;
205 #endif
206         SCODE *pscode;
207         DATE *pdate;
208         BSTR *pbstrVal;
209         VARIANT *pvarVal;
210         PVOID byref;
211         CY *pcyVal;
212         DECIMAL *pdecVal;
213         IUnknown **ppunkVal;
214         IDispatch **ppdispVal;
215         SAFEARRAY **pparray;
216         LONGLONG *pllVal;
217         ULONGLONG *pullVal;
218         struct __tagBRECORD {
219           PVOID pvRecord;
220           IRecordInfo *pRecInfo;
221         } __VARIANT_NAME_4;
222       } __VARIANT_NAME_3;
223     } __VARIANT_NAME_2;
224
225     DECIMAL decVal;
226   } __VARIANT_NAME_1;
227 };
228
229 typedef VARIANT *LPVARIANT;
230 typedef VARIANT VARIANTARG;
231 typedef VARIANTARG *LPVARIANTARG;
232
233 cpp_quote("#if 0")
234 typedef const VARIANT *REFVARIANT;
235 cpp_quote("#elif !defined(_REFVARIANT_DEFINED)")
236 cpp_quote("#define _REFVARIANT_DEFINED")
237 cpp_quote("#ifdef __cplusplus")
238 cpp_quote("#define REFVARIANT const VARIANT &")
239 cpp_quote("#else")
240 cpp_quote("#define REFVARIANT const VARIANT *__MIDL_CONST")
241 cpp_quote("#endif")
242 cpp_quote("#endif")
243
244 struct _wireBRECORD {
245   ULONG fFlags;
246   ULONG clSize;
247   IRecordInfo *pRecInfo;
248   [size_is(clSize)] byte *pRecord;
249 };
250
251 struct _wireVARIANT {
252   DWORD clSize;
253   DWORD rpcReserved;
254   USHORT vt;
255   USHORT wReserved1;
256   USHORT wReserved2;
257   USHORT wReserved3;
258   [switch_is(vt)] union {
259   [case(VT_EMPTY, VT_NULL)]    ;
260   [case(VT_I1)]                signed char cVal;
261   [case(VT_UI2)]               USHORT uiVal;
262   [case(VT_UI4)]               ULONG ulVal;
263   [case(VT_INT)]               INT intVal;
264   [case(VT_UINT)]              UINT uintVal;
265   [case(VT_UI1)]               BYTE bVal;
266   [case(VT_I2)]                SHORT iVal;
267   [case(VT_I4)]                LONG lVal;
268   [case(VT_R4)]                FLOAT fltVal;
269   [case(VT_R8)]                DOUBLE dblVal;
270   [case(VT_BOOL)]              VARIANT_BOOL boolVal;
271   [case(VT_ERROR)]             SCODE scode;
272   [case(VT_DATE)]              DATE date;
273   [case(VT_BSTR)]              wireBSTR bstrVal;
274   [case(VT_CY)]                CY cyVal;
275   [case(VT_DECIMAL)]           DECIMAL decVal;
276   [case(VT_UNKNOWN)]           IUnknown *punkVal;
277   [case(VT_DISPATCH)]          IDispatch *pdispVal;
278   [case(VT_ARRAY)]             wireSAFEARRAY parray;
279   [case(VT_I1|VT_BYREF)]       signed char *pcVal;
280   [case(VT_UI2|VT_BYREF)]      USHORT *puiVal;
281   [case(VT_UI4|VT_BYREF)]      ULONG *pulVal;
282   [case(VT_INT|VT_BYREF)]      INT *pintVal;
283   [case(VT_UINT|VT_BYREF)]     UINT *puintVal;
284   [case(VT_UI1|VT_BYREF)]      BYTE *pbVal;
285   [case(VT_I2|VT_BYREF)]       SHORT *piVal;
286   [case(VT_I4|VT_BYREF)]       LONG *plVal;
287   [case(VT_R4|VT_BYREF)]       FLOAT *pfltVal;
288   [case(VT_R8|VT_BYREF)]       DOUBLE *pdblVal;
289   [case(VT_BOOL|VT_BYREF)]     VARIANT_BOOL *pboolVal;
290   [case(VT_ERROR|VT_BYREF)]    SCODE *pscode;
291   [case(VT_DATE|VT_BYREF)]     DATE *pdate;
292   [case(VT_BSTR|VT_BYREF)]     wireBSTR *pbstrVal;
293   [case(VT_VARIANT|VT_BYREF)]  wireVARIANT *pvarVal;
294   [case(VT_CY|VT_BYREF)]       CY *pcyVal;
295   [case(VT_DECIMAL|VT_BYREF)]  DECIMAL *pdecVal;
296   [case(VT_UNKNOWN|VT_BYREF)]  IUnknown **ppunkVal;
297   [case(VT_DISPATCH|VT_BYREF)] IDispatch **ppdispVal;
298   [case(VT_ARRAY|VT_BYREF)]    wireSAFEARRAY *pparray;
299   [case(VT_RECORD, VT_RECORD|VT_BYREF)] wireBRECORD brecVal;
300   } DUMMYUNIONNAME;
301 };
302
303 /* Dispatch */
304
305 typedef LONG DISPID;
306 typedef DWORD HREFTYPE;
307 typedef DISPID MEMBERID;
308
309 typedef [v1_enum] enum tagTYPEKIND {
310   TKIND_ENUM = 0,
311   TKIND_RECORD,
312   TKIND_MODULE,
313   TKIND_INTERFACE,
314   TKIND_DISPATCH,
315   TKIND_COCLASS,
316   TKIND_ALIAS,
317   TKIND_UNION,
318   TKIND_MAX
319 } TYPEKIND;
320
321 typedef struct tagTYPEDESC {
322   [switch_is(vt)] union {
323   [case(VT_PTR, VT_SAFEARRAY)] struct tagTYPEDESC *lptdesc;
324   [case(VT_CARRAY)]            struct tagARRAYDESC *lpadesc;
325   [case(VT_USERDEFINED)]       HREFTYPE hreftype;
326   [default]                    ;
327   } DUMMYUNIONNAME;
328   VARTYPE vt;
329 } TYPEDESC;
330
331 typedef struct tagARRAYDESC {
332   TYPEDESC tdescElem;
333   USHORT cDims;
334   [size_is(cDims)] SAFEARRAYBOUND rgbounds[];
335 } ARRAYDESC;
336
337 typedef struct tagPARAMDESCEX {
338   ULONG cBytes;
339   VARIANTARG varDefaultValue;
340 } PARAMDESCEX, *LPPARAMDESCEX;
341
342 typedef struct tagPARAMDESC {
343   LPPARAMDESCEX pparamdescex;
344   USHORT wParamFlags;
345 } PARAMDESC, *LPPARAMDESC;
346
347 const USHORT PARAMFLAG_NONE         = 0x00;
348 const USHORT PARAMFLAG_FIN          = 0x01;
349 const USHORT PARAMFLAG_FOUT         = 0x02;
350 const USHORT PARAMFLAG_FLCID        = 0x04;
351 const USHORT PARAMFLAG_FRETVAL      = 0x08;
352 const USHORT PARAMFLAG_FOPT         = 0x10;
353 const USHORT PARAMFLAG_FHASDEFAULT  = 0x20;
354 const USHORT PARAMFLAG_FHASCUSTDATA = 0x40;
355
356 typedef struct tagIDLDESC {
357   ULONG_PTR dwReserved;
358   USHORT wIDLFlags;
359 } IDLDESC, *LPIDLDESC;
360
361 const USHORT IDLFLAG_NONE    = PARAMFLAG_NONE;
362 const USHORT IDLFLAG_FIN     = PARAMFLAG_FIN;
363 const USHORT IDLFLAG_FOUT    = PARAMFLAG_FOUT;
364 const USHORT IDLFLAG_FLCID   = PARAMFLAG_FLCID;
365 const USHORT IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;
366
367 cpp_quote("#if 0") /* for IDL only */
368 typedef struct tagELEMDESC {
369   TYPEDESC tdesc;
370   PARAMDESC paramdesc;
371 } ELEMDESC;
372 cpp_quote("#else") /* C/C++ defs */
373 cpp_quote("typedef struct tagELEMDESC {")
374 cpp_quote("  TYPEDESC tdesc;")
375 cpp_quote("  union {")
376 cpp_quote("    IDLDESC idldesc;")
377 cpp_quote("    PARAMDESC paramdesc;")
378 cpp_quote("  } DUMMYUNIONNAME;")
379 cpp_quote("} ELEMDESC, *LPELEMDESC;")
380 cpp_quote("#endif")
381
382 typedef struct tagTYPEATTR {
383   GUID guid;
384   LCID lcid;
385   DWORD dwReserved;
386   MEMBERID memidConstructor;
387   MEMBERID memidDestructor;
388   LPOLESTR lpstrSchema;
389   ULONG cbSizeInstance;
390   TYPEKIND typekind;
391   WORD cFuncs;
392   WORD cVars;
393   WORD cImplTypes;
394   WORD cbSizeVft;
395   WORD cbAlignment;
396   WORD wTypeFlags;
397   WORD wMajorVerNum;
398   WORD wMinorVerNum;
399   TYPEDESC tdescAlias;
400   IDLDESC idldescType;
401 } TYPEATTR, *LPTYPEATTR;
402
403 typedef struct tagDISPPARAMS {
404   [size_is(cArgs)] VARIANTARG *rgvarg;
405   [size_is(cNamedArgs)] DISPID *rgdispidNamedArgs;
406   UINT cArgs;
407   UINT cNamedArgs;
408 } DISPPARAMS;
409
410 cpp_quote("#if 0") /* for IDL only */
411 typedef struct tagEXCEPINFO {
412   WORD wCode;
413   WORD wReserved;
414   BSTR bstrSource;
415   BSTR bstrDescription;
416   BSTR bstrHelpFile;
417   DWORD dwHelpContext;
418   ULONG_PTR pvReserved;
419   ULONG_PTR pfnDeferredFillIn;
420   SCODE scode;
421 } EXCEPINFO;
422 cpp_quote("#else")
423 cpp_quote("typedef struct tagEXCEPINFO {")
424 cpp_quote("  WORD wCode;")
425 cpp_quote("  WORD wReserved;")
426 cpp_quote("  BSTR bstrSource;")
427 cpp_quote("  BSTR bstrDescription;")
428 cpp_quote("  BSTR bstrHelpFile;")
429 cpp_quote("  DWORD dwHelpContext;")
430 cpp_quote("  PVOID pvReserved;")
431 cpp_quote("  HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);")
432 cpp_quote("  SCODE scode;")
433 cpp_quote("} EXCEPINFO, *LPEXCEPINFO;")
434 cpp_quote("#endif")
435
436 typedef [v1_enum] enum tagCALLCONV {
437   CC_FASTCALL = 0,
438   CC_CDECL = 1,
439   CC_MSCPASCAL,
440   CC_PASCAL = CC_MSCPASCAL,
441   CC_MACPASCAL,
442   CC_STDCALL,
443   CC_FPFASTCALL,
444   CC_SYSCALL,
445   CC_MPWCDECL,
446   CC_MPWPASCAL,
447   CC_MAX
448 } CALLCONV;
449
450 typedef [v1_enum] enum tagFUNCKIND {
451   FUNC_VIRTUAL,
452   FUNC_PUREVIRTUAL,
453   FUNC_NONVIRTUAL,
454   FUNC_STATIC,
455   FUNC_DISPATCH
456 } FUNCKIND;
457
458 typedef [v1_enum] enum tagINVOKEKIND {
459   INVOKE_FUNC = 1,
460   INVOKE_PROPERTYGET = 2,
461   INVOKE_PROPERTYPUT = 4,
462   INVOKE_PROPERTYPUTREF = 8
463 } INVOKEKIND;
464
465 typedef struct tagFUNCDESC {
466   MEMBERID memid;
467   [size_is(cScodes)] SCODE *lprgscode;
468   [size_is(cParams)] ELEMDESC *lprgelemdescParam;
469   FUNCKIND funckind;
470   INVOKEKIND invkind;
471   CALLCONV callconv;
472   SHORT cParams;
473   SHORT cParamsOpt;
474   SHORT oVft;
475   SHORT cScodes;
476   ELEMDESC elemdescFunc;
477   WORD wFuncFlags;
478 } FUNCDESC, *LPFUNCDESC;
479
480 typedef [v1_enum] enum tagVARKIND {
481   VAR_PERINSTANCE,
482   VAR_STATIC,
483   VAR_CONST,
484   VAR_DISPATCH
485 } VARKIND;
486
487 const USHORT IMPLTYPEFLAG_FDEFAULT       = 0x1;
488 const USHORT IMPLTYPEFLAG_FSOURCE        = 0x2;
489 const USHORT IMPLTYPEFLAG_FRESTRICTED    = 0x4;
490 const USHORT IMPLTYPEFLAG_FDEFAULTVTABLE = 0x8;
491
492 typedef struct tagVARDESC {
493   MEMBERID memid;
494   LPOLESTR lpstrSchema;
495   [switch_is(varkind)] union {
496   [case(VAR_PERINSTANCE, VAR_DISPATCH, VAR_STATIC)] ULONG oInst;
497   [case(VAR_CONST)] VARIANT *lpvarValue;
498   } DUMMYUNIONNAME;
499   ELEMDESC elemdescVar;
500   WORD wVarFlags;
501   VARKIND varkind;
502 } VARDESC, *LPVARDESC;
503
504 typedef enum tagTYPEFLAGS {
505   TYPEFLAG_FAPPOBJECT     = 0x0001,
506   TYPEFLAG_FCANCREATE     = 0x0002,
507   TYPEFLAG_FLICENSED      = 0x0004,
508   TYPEFLAG_FPREDECLID     = 0x0008,
509   TYPEFLAG_FHIDDEN        = 0x0010,
510   TYPEFLAG_FCONTROL       = 0x0020,
511   TYPEFLAG_FDUAL          = 0x0040,
512   TYPEFLAG_FNONEXTENSIBLE = 0x0080,
513   TYPEFLAG_FOLEAUTOMATION = 0x0100,
514   TYPEFLAG_FRESTRICTED    = 0x0200,
515   TYPEFLAG_FAGGREGATABLE  = 0x0400,
516   TYPEFLAG_FREPLACEABLE   = 0x0800,
517   TYPEFLAG_FDISPATCHABLE  = 0x1000,
518   TYPEFLAG_FREVERSEBIND   = 0x2000,
519   TYPEFLAG_FPROXY         = 0x4000
520 } TYPEFLAGS;
521
522 typedef enum tagFUNCFLAGS {
523   FUNCFLAG_FRESTRICTED       = 0x0001,
524   FUNCFLAG_FSOURCE           = 0x0002,
525   FUNCFLAG_FBINDABLE         = 0x0004,
526   FUNCFLAG_FREQUESTEDIT      = 0x0008,
527   FUNCFLAG_FDISPLAYBIND      = 0x0010,
528   FUNCFLAG_FDEFAULTBIND      = 0x0020,
529   FUNCFLAG_FHIDDEN           = 0x0040,
530   FUNCFLAG_FUSESGETLASTERROR = 0x0080,
531   FUNCFLAG_FDEFAULTCOLLELEM  = 0x0100,
532   FUNCFLAG_FUIDEFAULT        = 0x0200,
533   FUNCFLAG_FNONBROWSABLE     = 0x0400,
534   FUNCFLAG_FREPLACEABLE      = 0x0800,
535   FUNCFLAG_FIMMEDIATEBIND    = 0x1000
536 } FUNCFLAGS;
537
538 typedef enum tagVARFLAGS {
539   VARFLAG_FREADONLY        = 0x0001,
540   VARFLAG_FSOURCE          = 0x0002,
541   VARFLAG_FBINDABLE        = 0x0004,
542   VARFLAG_FREQUESTEDIT     = 0x0008,
543   VARFLAG_FDISPLAYBIND     = 0x0010,
544   VARFLAG_FDEFAULTBIND     = 0x0020,
545   VARFLAG_FHIDDEN          = 0x0040,
546   VARFLAG_FRESTRICTED      = 0x0080,
547   VARFLAG_FDEFAULTCOLLELEM = 0x0100,
548   VARFLAG_FUIDEFAULT       = 0x0200,
549   VARFLAG_FNONBROWSABLE    = 0x0400,
550   VARFLAG_FREPLACEABLE     = 0x0800,
551   VARFLAG_FIMMEDIATEBIND   = 0x1000
552 } VARFLAGS;
553
554 typedef [wire_marshal(DWORD)] struct tagCLEANLOCALSTORAGE {
555   IUnknown *pInterface;
556   PVOID pStorage;
557   DWORD flags;
558 } CLEANLOCALSTORAGE;
559
560 typedef struct tagCUSTDATAITEM {
561   GUID guid;
562   VARIANTARG varValue;
563 } CUSTDATAITEM, *LPCUSTDATAITEM;
564
565 typedef struct tagCUSTDATA {
566   DWORD cCustData;
567   [size_is(cCustData)] LPCUSTDATAITEM prgCustData;
568 } CUSTDATA, *LPCUSTDATA;
569
570 } /* interface IOleAutomationTypes */
571
572 /******************** INTERFACES ********************/
573
574 [
575   object,
576   uuid(00020400-0000-0000-C000-000000000046),
577   pointer_default(unique)
578 ]
579 interface IDispatch : IUnknown
580 {
581   typedef [unique] IDispatch *LPDISPATCH;
582
583   const DISPID DISPID_UNKNOWN     = -1;
584   const DISPID DISPID_VALUE       =  0;
585   const DISPID DISPID_PROPERTYPUT = -3;
586   const DISPID DISPID_NEWENUM     = -4;
587   const DISPID DISPID_EVALUATE    = -5;
588   const DISPID DISPID_CONSTRUCTOR = -6;
589   const DISPID DISPID_DESTRUCTOR  = -7;
590   const DISPID DISPID_COLLECT     = -8;
591
592   HRESULT GetTypeInfoCount(
593     [out] UINT *pctinfo);
594
595   HRESULT GetTypeInfo(
596     [in] UINT iTInfo,
597     [in] LCID lcid,
598     [out] ITypeInfo **ppTInfo);
599
600   HRESULT GetIDsOfNames(
601     [in] REFIID riid,
602     [in, size_is(cNames)] LPOLESTR *rgszNames,
603     [in] UINT cNames,
604     [in] LCID lcid,
605     [out, size_is(cNames)] DISPID *rgDispId);
606
607   [local]
608   HRESULT Invoke(
609     [in] DISPID dispIdMember,
610     [in] REFIID riid,
611     [in] LCID lcid,
612     [in] WORD wFlags,
613     [in, out] DISPPARAMS *pDispParams,
614     [out] VARIANT *pVarResult,
615     [out] EXCEPINFO *pExcepInfo,
616     [out] UINT *puArgErr);
617
618   [call_as(Invoke)]
619   HRESULT RemoteInvoke(
620     [in] DISPID dispIdMember,
621     [in] REFIID riid,
622     [in] LCID lcid,
623     [in] DWORD dwFlags,
624     [in] DISPPARAMS *pDispParams,
625     [out] VARIANT *pVarResult,
626     [out] EXCEPINFO *pExcepInfo,
627     [out] UINT *pArgErr,
628     [in] UINT cVarRef,
629     [in, size_is(cVarRef)] UINT *rgVarRefIdx,
630     [in, out, size_is(cVarRef)] VARIANTARG *rgVarRef);
631 }
632
633 [
634   object,
635   uuid(00020404-0000-0000-C000-000000000046),
636   pointer_default(unique)
637 ]
638 interface IEnumVARIANT : IUnknown
639 {
640   typedef [unique] IEnumVARIANT *LPENUMVARIANT;
641
642   [local]
643   HRESULT Next(
644     [in] ULONG celt,
645     [out] VARIANT *rgVar,
646     [out] ULONG *pCeltFetched);
647
648   [call_as(Next)]
649   HRESULT RemoteNext(
650     [in] ULONG celt,
651     [out, size_is(celt), length_is(*pCeltFetched)]
652     VARIANT *rgVar,
653     [out] ULONG *pCeltFetched);
654
655   HRESULT Skip(
656     [in] ULONG celt);
657
658   HRESULT Reset();
659
660   HRESULT Clone(
661     [out] IEnumVARIANT **ppEnum);
662 }
663
664 [
665   object,
666   uuid(00020403-0000-0000-C000-000000000046),
667   pointer_default(unique)
668 ]
669 interface ITypeComp : IUnknown
670 {
671   typedef [unique] ITypeComp *LPTYPECOMP;
672
673   typedef [v1_enum] enum tagDESCKIND {
674     DESCKIND_NONE = 0,
675     DESCKIND_FUNCDESC,
676     DESCKIND_VARDESC,
677     DESCKIND_TYPECOMP,
678     DESCKIND_IMPLICITAPPOBJ,
679     DESCKIND_MAX
680   } DESCKIND;
681
682   typedef union tagBINDPTR {
683     FUNCDESC *lpfuncdesc;
684     VARDESC *lpvardesc;
685     ITypeComp *lptcomp;
686   } BINDPTR, *LPBINDPTR;
687
688   [local]
689   HRESULT Bind(
690     [in] LPOLESTR szName,
691     [in] ULONG lHashVal,
692     [in] WORD wFlags,
693     [out] ITypeInfo **ppTInfo,
694     [out] DESCKIND *pDescKind,
695     [out] BINDPTR *pBindPtr);
696
697   [call_as(Bind)]
698   HRESULT RemoteBind(
699     [in] LPOLESTR szName,
700     [in] ULONG lHashVal,
701     [in] WORD wFlags,
702     [out] ITypeInfo **ppTInfo,
703     [out] DESCKIND *pDescKind,
704     [out] LPFUNCDESC *ppFuncDesc,
705     [out] LPVARDESC *ppVarDesc,
706     [out] ITypeComp **ppTypeComp,
707     [out] CLEANLOCALSTORAGE *pDummy);
708
709   [local]
710   HRESULT BindType(
711     [in] LPOLESTR szName,
712     [in] ULONG lHashVal,
713     [out] ITypeInfo **ppTInfo,
714     [out] ITypeComp **ppTComp);
715
716   [call_as(BindType)]
717   HRESULT RemoteBindType(
718     [in] LPOLESTR szName,
719     [in] ULONG lHashVal,
720     [out] ITypeInfo **ppTInfo);
721 }
722
723 [
724   object,
725   uuid(00020401-0000-0000-C000-000000000046),
726   pointer_default(unique)
727 ]
728 interface ITypeInfo : IUnknown
729 {
730   typedef [unique] ITypeInfo *LPTYPEINFO;
731
732   [local]
733   HRESULT GetTypeAttr(
734     [out] TYPEATTR **ppTypeAttr);
735
736   [call_as(GetTypeAttr)]
737   HRESULT RemoteGetTypeAttr(
738     [out] LPTYPEATTR *ppTypeAttr,
739     [out] CLEANLOCALSTORAGE *pDummy);
740
741   HRESULT GetTypeComp(
742     [out] ITypeComp **ppTComp);
743
744   [local]
745   HRESULT GetFuncDesc(
746     [in] UINT index,
747     [out] FUNCDESC **ppFuncDesc);
748
749   [call_as(GetFuncDesc)]
750   HRESULT RemoteGetFuncDesc(
751     [in] UINT index,
752     [out] LPFUNCDESC *ppFuncDesc,
753     [out] CLEANLOCALSTORAGE *pDummy);
754
755   [local]
756   HRESULT GetVarDesc(
757     [in] UINT index,
758     [out] VARDESC **ppVarDesc);
759
760   [call_as(GetVarDesc)]
761   HRESULT RemoteGetVarDesc(
762     [in] UINT index,
763     [out] LPVARDESC *ppVarDesc,
764     [out] CLEANLOCALSTORAGE *pDummy);
765
766   [local]
767   HRESULT GetNames(
768     [in] MEMBERID memid,
769     [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames,
770     [in] UINT cMaxNames,
771     [out] UINT *pcNames);
772
773   [call_as(GetNames)]
774   HRESULT RemoteGetNames(
775     [in] MEMBERID memid,
776     [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames,
777     [in] UINT cMaxNames,
778     [out] UINT *pcNames);
779
780   HRESULT GetRefTypeOfImplType(
781     [in] UINT index,
782     [out] HREFTYPE *pRefType);
783
784   HRESULT GetImplTypeFlags(
785     [in] UINT index,
786     [out] INT *pImplTypeFlags);
787
788   [local]
789   HRESULT GetIDsOfNames(
790     [in, size_is(cNames)] LPOLESTR *rgszNames,
791     [in] UINT cNames,
792     [out, size_is(cNames)] MEMBERID *pMemId);
793
794   [call_as(GetIDsOfNames)]
795   HRESULT LocalGetIDsOfNames();
796
797   [local]
798   HRESULT Invoke(
799     [in] PVOID pvInstance,
800     [in] MEMBERID memid,
801     [in] WORD wFlags,
802     [in, out] DISPPARAMS *pDispParams,
803     [out] VARIANT *pVarResult,
804     [out] EXCEPINFO *pExcepInfo,
805     [out] UINT *puArgErr);
806
807   [call_as(Invoke)]
808   HRESULT LocalInvoke();
809
810   [local]
811   HRESULT GetDocumentation(
812     [in] MEMBERID memid,
813     [out] BSTR *pBstrName,
814     [out] BSTR *pBstrDocString,
815     [out] DWORD *pdwHelpContext,
816     [out] BSTR *pBstrHelpFile);
817
818   [call_as(GetDocumentation)]
819   HRESULT RemoteGetDocumentation(
820     [in] MEMBERID memid,
821     [in] DWORD refPtrFlags,
822     [out] BSTR *pBstrName,
823     [out] BSTR *pBstrDocString,
824     [out] DWORD *pdwHelpContext,
825     [out] BSTR *pBstrHelpFile);
826
827   [local]
828   HRESULT GetDllEntry(
829     [in] MEMBERID memid,
830     [in] INVOKEKIND invKind,
831     [out] BSTR *pBstrDllName,
832     [out] BSTR *pBstrName,
833     [out] WORD *pwOrdinal);
834
835   [call_as(GetDllEntry)]
836   HRESULT RemoteGetDllEntry(
837     [in] MEMBERID memid,
838     [in] INVOKEKIND invKind,
839     [in] DWORD refPtrFlags,
840     [out] BSTR *pBstrDllName,
841     [out] BSTR *pBstrName,
842     [out] WORD *pwOrdinal);
843
844   HRESULT GetRefTypeInfo(
845     [in] HREFTYPE hRefType,
846     [out] ITypeInfo **ppTInfo);
847
848   [local]
849   HRESULT AddressOfMember(
850     [in] MEMBERID memid,
851     [in] INVOKEKIND invKind,
852     [out] PVOID *ppv);
853
854   [call_as(AddressOfMember)]
855   HRESULT LocalAddressOfMember();
856
857   [local]
858   HRESULT CreateInstance(
859     [in] IUnknown *pUnkOuter,
860     [in] REFIID riid,
861     [out, iid_is(riid)] PVOID *ppvObj);
862
863   [call_as(CreateInstance)]
864   HRESULT RemoteCreateInstance(
865     [in] REFIID riid,
866     [out, iid_is(riid)] IUnknown **ppvObj);
867
868   HRESULT GetMops(
869     [in] MEMBERID memid,
870     [out] BSTR *pBstrMops);
871
872   [local]
873   HRESULT GetContainingTypeLib(
874     [out] ITypeLib **ppTLib,
875     [out] UINT *pIndex);
876
877   [call_as(GetContainingTypeLib)]
878   HRESULT RemoteGetContainingTypeLib(
879     [out] ITypeLib **ppTLib,
880     [out] UINT *pIndex);
881
882   [local]
883   void ReleaseTypeAttr(
884     [in] TYPEATTR *pTypeAttr);
885
886   [call_as(ReleaseTypeAttr)]
887   HRESULT LocalReleaseTypeAttr();
888
889   [local]
890   void ReleaseFuncDesc(
891     [in] FUNCDESC *pFuncDesc);
892
893   [call_as(ReleaseFuncDesc)]
894   HRESULT LocalReleaseFuncDesc();
895
896   [local]
897   void ReleaseVarDesc(
898     [in] VARDESC *pVarDesc);
899
900   [call_as(ReleaseVarDesc)]
901   HRESULT LocalReleaseVarDesc();
902 }
903
904 [
905   object,
906   uuid(00020412-0000-0000-C000-000000000046),
907   pointer_default(unique)
908 ]
909 interface ITypeInfo2 : ITypeInfo
910 {
911   typedef [unique] ITypeInfo2 *LPTYPEINFO2;
912
913   HRESULT GetTypeKind(
914     [out] TYPEKIND *pTypeKind);
915
916   HRESULT GetTypeFlags(
917     [out] ULONG *pTypeFlags);
918
919   HRESULT GetFuncIndexOfMemId(
920     [in] MEMBERID memid,
921     [in] INVOKEKIND invKind,
922     [out] UINT *pFuncIndex);
923
924   HRESULT GetVarIndexOfMemId(
925     [in] MEMBERID memid,
926     [out] UINT *pVarIndex);
927
928   HRESULT GetCustData(
929     [in] REFGUID guid,
930     [out] VARIANT *pVarVal);
931
932   HRESULT GetFuncCustData(
933     [in] UINT index,
934     [in] REFGUID guid,
935     [out] VARIANT *pVarVal);
936
937   HRESULT GetParamCustData(
938     [in] UINT indexFunc,
939     [in] UINT indexParam,
940     [in] REFGUID guid,
941     [out] VARIANT *pVarVal);
942
943   HRESULT GetVarCustData(
944     [in] UINT index,
945     [in] REFGUID guid,
946     [out] VARIANT *pVarVal);
947
948   HRESULT GetImplTypeCustData(
949     [in] UINT index,
950     [in] REFGUID guid,
951     [out] VARIANT *pVarVal);
952
953   [local]
954   HRESULT GetDocumentation2(
955     [in] MEMBERID memid,
956     [in] LCID lcid,
957     [out] BSTR *pbstrHelpString,
958     [out] DWORD *pdwHelpStringContext,
959     [out] BSTR *pbstrHelpStringDll);
960
961   [call_as(GetDocumentation2)]
962   HRESULT RemoteGetDocumentation2(
963     [in] MEMBERID memid,
964     [in] LCID lcid,
965     [in] DWORD refPtrFlags,
966     [out] BSTR *pbstrHelpString,
967     [out] DWORD *pdwHelpStringContext,
968     [out] BSTR *pbstrHelpStringDll);
969
970   HRESULT GetAllCustData(
971     [out] CUSTDATA *pCustData);
972
973   HRESULT GetAllFuncCustData(
974     [in] UINT index,
975     [out] CUSTDATA *pCustData);
976
977   HRESULT GetAllParamCustData(
978     [in] UINT indexFunc,
979     [in] UINT indexParam,
980     [out] CUSTDATA *pCustData);
981
982   HRESULT GetAllVarCustData(
983     [in] UINT index,
984     [out] CUSTDATA *pCustData);
985
986   HRESULT GetAllImplTypeCustData(
987     [in] UINT index,
988     [out] CUSTDATA *pCustData);
989 }
990
991 [
992   object,
993   uuid(00020402-0000-0000-C000-000000000046),
994   pointer_default(unique)
995 ]
996 interface ITypeLib : IUnknown
997 {
998   typedef [unique] ITypeLib *LPTYPELIB;
999
1000   typedef [v1_enum] enum tagSYSKIND {
1001     SYS_WIN16 = 0,
1002     SYS_WIN32,
1003     SYS_MAC,
1004     SYS_WIN64
1005   } SYSKIND;
1006
1007   typedef [v1_enum] enum tagLIBFLAGS {
1008     LIBFLAG_FRESTRICTED   = 0x01,
1009     LIBFLAG_FCONTROL      = 0x02,
1010     LIBFLAG_FHIDDEN       = 0x04,
1011     LIBFLAG_FHASDISKIMAGE = 0x08
1012   } LIBFLAGS;
1013
1014   typedef struct tagTLIBATTR {
1015     GUID guid;
1016     LCID lcid;
1017     SYSKIND syskind;
1018     WORD wMajorVerNum;
1019     WORD wMinorVerNum;
1020     WORD wLibFlags;
1021   } TLIBATTR, *LPTLIBATTR;
1022
1023   [local]
1024   UINT GetTypeInfoCount();
1025
1026   [call_as(GetTypeInfoCount)]
1027   HRESULT RemoteGetTypeInfoCount(
1028     [out] UINT *pcTInfo);
1029
1030   HRESULT GetTypeInfo(
1031     [in] UINT index,
1032     [out] ITypeInfo **ppTInfo);
1033
1034   HRESULT GetTypeInfoType(
1035     [in] UINT index,
1036     [out] TYPEKIND *pTKind);
1037
1038   HRESULT GetTypeInfoOfGuid(
1039     [in] REFGUID guid,
1040     [out] ITypeInfo **ppTinfo);
1041
1042   [local]
1043   HRESULT GetLibAttr(
1044     [out] TLIBATTR **ppTLibAttr);
1045
1046   [call_as(GetLibAttr)]
1047   HRESULT RemoteGetLibAttr(
1048     [out] LPTLIBATTR *ppTLibAttr,
1049     [out] CLEANLOCALSTORAGE *pDummy);
1050
1051   HRESULT GetTypeComp(
1052     [out] ITypeComp **ppTComp);
1053
1054   [local]
1055   HRESULT GetDocumentation(
1056     [in] INT index,
1057     [out] BSTR *pBstrName,
1058     [out] BSTR *pBstrDocString,
1059     [out] DWORD *pdwHelpContext,
1060     [out] BSTR *pBstrHelpFile);
1061
1062   [call_as(GetDocumentation)]
1063   HRESULT RemoteGetDocumentation(
1064     [in] INT index,
1065     [in] DWORD refPtrFlags,
1066     [out] BSTR *pBstrName,
1067     [out] BSTR *pBstrDocString,
1068     [out] DWORD *pdwHelpContext,
1069     [out] BSTR *pBstrHelpFile);
1070
1071   [local]
1072   HRESULT IsName(
1073     [in, out] LPOLESTR szNameBuf,
1074     [in] ULONG lHashVal,
1075     [out] BOOL *pfName);
1076
1077   [call_as(IsName)]
1078   HRESULT RemoteIsName(
1079     [in] LPOLESTR szNameBuf,
1080     [in] ULONG lHashVal,
1081     [out] BOOL *pfName,
1082     [out] BSTR *pBstrLibName);
1083
1084   [local]
1085   HRESULT FindName(
1086     [in, out] LPOLESTR szNameBuf,
1087     [in] ULONG lHashVal,
1088     [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
1089     [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
1090     [in, out] USHORT *pcFound);
1091
1092   [call_as(FindName)]
1093   HRESULT RemoteFindName(
1094     [in] LPOLESTR szNameBuf,
1095     [in] ULONG lHashVal,
1096     [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
1097     [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
1098     [in, out] USHORT *pcFound,
1099     [out] BSTR *pBstrLibName);
1100
1101   [local]
1102   void ReleaseTLibAttr(
1103     [in] TLIBATTR *pTLibAttr);
1104
1105   [call_as(ReleaseTLibAttr)]
1106   HRESULT LocalReleaseTLibAttr();
1107 }
1108
1109 [
1110   object,
1111   uuid(00020411-0000-0000-C000-000000000046),
1112   pointer_default(unique)
1113 ]
1114 interface ITypeLib2 : ITypeLib
1115 {
1116   typedef [unique] ITypeLib2 *LPTYPELIB2;
1117
1118   HRESULT GetCustData(
1119     [in] REFGUID guid,
1120     [out] VARIANT *pVarVal);
1121
1122   [local]
1123   HRESULT GetLibStatistics(
1124     [out] ULONG *pcUniqueNames,
1125     [out] ULONG *pcchUniqueNames);
1126
1127   [call_as(GetLibStatistics)]
1128   HRESULT RemoteGetLibStatistics(
1129     [out] ULONG *pcUniqueNames,
1130     [out] ULONG *pcchUniqueNames);
1131
1132   [local]
1133   HRESULT GetDocumentation2(
1134     [in] INT index,
1135     [in] LCID lcid,
1136     [out] BSTR *pbstrHelpString,
1137     [out] DWORD *pdwHelpStringContext,
1138     [out] BSTR *pbstrHelpStringDll);
1139
1140   [call_as(GetDocumentation2)]
1141   HRESULT RemoteGetDocumentation2(
1142     [in] INT index,
1143     [in] LCID lcid,
1144     [in] DWORD refPtrFlags,
1145     [out] BSTR *pbstrHelpString,
1146     [out] DWORD *pdwHelpStringContext,
1147     [out] BSTR *pbstrHelpStringDll);
1148
1149   HRESULT GetAllCustData(
1150     [out] CUSTDATA *pCustData);
1151 }
1152
1153 [
1154   local,
1155   object,
1156   uuid(00020410-0000-0000-C000-000000000046),
1157   pointer_default(unique)
1158 ]
1159 interface ITypeChangeEvents : IUnknown
1160 {
1161   typedef [unique] ITypeChangeEvents *LPTYPECHANGEEVENTS;
1162
1163   typedef enum tagCHANGEKIND {
1164     CHANGEKIND_ADDMEMBER,
1165     CHANGEKIND_DELETEMEMBER,
1166     CHANGEKIND_SETNAMES,
1167     CHANGEKIND_SETDOCUMENTATION,
1168     CHANGEKIND_GENERAL,
1169     CHANGEKIND_INVALIDATE,
1170     CHANGEKIND_CHANGEFAILED,
1171     CHANGEKIND_MAX
1172   } CHANGEKIND;
1173
1174   HRESULT RequestTypeChange(
1175     [in] CHANGEKIND changeKind,
1176     [in] ITypeInfo *pTInfoBefore,
1177     [in] LPOLESTR pStrName,
1178     [out] INT *pfCancel);
1179   
1180   HRESULT AfterTypeChange(
1181     [in] CHANGEKIND changeKind,
1182     [in] ITypeInfo *pTInfoAfter,
1183     [in] LPOLESTR pStrName);
1184 }
1185
1186 [
1187   object,
1188   uuid(1CF2B120-547D-101B-8E65-08002B2BD119),
1189   pointer_default(unique)
1190 ]
1191 interface IErrorInfo : IUnknown
1192 {
1193   typedef [unique] IErrorInfo *LPERRORINFO;
1194
1195   HRESULT GetGUID(
1196     [out] GUID *pGUID);
1197
1198   HRESULT GetSource(
1199     [out] BSTR *pBstrSource);
1200
1201   HRESULT GetDescription(
1202     [out] BSTR *pBstrDescription);
1203
1204   HRESULT GetHelpFile(
1205     [out] BSTR *pBstrHelpFile);
1206
1207   HRESULT GetHelpContext(
1208     [out] DWORD *pdwHelpContext);
1209 }
1210
1211 [
1212   object,
1213   uuid(22F03340-547D-101B-8E65-08002B2BD119),
1214   pointer_default(unique)
1215 ]
1216 interface ICreateErrorInfo : IUnknown
1217 {
1218   typedef [unique] ICreateErrorInfo *LPCREATEERRORINFO;
1219
1220   HRESULT SetGUID(
1221     [in] REFGUID rguid);
1222
1223   HRESULT SetSource(
1224     [in] LPOLESTR szSource);
1225
1226   HRESULT SetDescription(
1227     [in] LPOLESTR szDescription);
1228
1229   HRESULT SetHelpFile(
1230     [in] LPOLESTR szHelpFile);
1231
1232   HRESULT SetHelpContext(
1233     [in] DWORD dwHelpContext);
1234 }
1235
1236 [
1237   object,
1238   uuid(DF0B3D60-548F-101B-8E65-08002B2BD119),
1239   pointer_default(unique)
1240 ]
1241 interface ISupportErrorInfo : IUnknown
1242 {
1243   typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO;
1244
1245   HRESULT InterfaceSupportsErrorInfo(
1246     [in] REFIID riid);
1247 }
1248
1249 [
1250   object,
1251   uuid(0000002E-0000-0000-C000-000000000046)
1252 ]
1253 interface ITypeFactory : IUnknown
1254 {
1255   HRESULT CreateFromTypeInfo(
1256     [in] ITypeInfo *pTypeInfo,
1257     [in] REFIID riid,
1258     [out, iid_is(riid)] IUnknown **ppv);
1259 }
1260
1261 [
1262   local,
1263   object,
1264   uuid(0000002D-0000-0000-C000-000000000046)
1265 ]
1266 interface ITypeMarshal : IUnknown
1267 {
1268   HRESULT Size(
1269     [in] PVOID pvType,
1270     [in] DWORD dwDestContext,
1271     [in] PVOID pvDestContext,
1272     [out] ULONG *pSize);
1273
1274   HRESULT Marshal(
1275     [in] PVOID pvType,
1276     [in] DWORD dwDestContext,
1277     [in] PVOID pvDestContext,
1278     [in] ULONG cbBufferLength,
1279     [out] BYTE *pBuffer,
1280     [out] ULONG *pcbWritten);
1281
1282   HRESULT Unmarshal(
1283     [out] PVOID pvType,
1284     [in] DWORD dwFlags,
1285     [in] ULONG cbBufferLength,
1286     [in] BYTE *pBuffer,
1287     [out] ULONG *pcbRead);
1288
1289   HRESULT Free(
1290     [in] PVOID pvType);
1291 }
1292
1293 [
1294   local,
1295   object,
1296   uuid(0000002F-0000-0000-C000-000000000046)
1297 ]
1298 interface IRecordInfo : IUnknown
1299 {
1300   typedef [unique] IRecordInfo *LPRECORDINFO;
1301
1302   HRESULT RecordInit(
1303     [out] PVOID pvNew);
1304
1305   HRESULT RecordClear(
1306     [in] PVOID pvExisting);
1307
1308   HRESULT RecordCopy(
1309     [in] PVOID pvExisting,
1310     [out] PVOID pvNew);
1311
1312   HRESULT GetGuid(
1313     [out] GUID *pguid);
1314
1315   HRESULT GetName(
1316     [out] BSTR *pbstrName);
1317
1318   HRESULT GetSize(
1319     [out] ULONG *pcbSize);
1320
1321   HRESULT GetTypeInfo(
1322     [out] ITypeInfo **ppTypeInfo);
1323
1324   HRESULT GetField(
1325     [in] PVOID pvData,
1326     [in] LPCOLESTR szFieldName,
1327     [out] VARIANT *pvarField);
1328
1329   HRESULT GetFieldNoCopy(
1330     [in] PVOID pvData,
1331     [in] LPCOLESTR szFieldName,
1332     [out] VARIANT *pvarField,
1333     [out] PVOID *ppvDataCArray);
1334
1335   HRESULT PutField(
1336     [in] ULONG wFlags,
1337     [in, out] PVOID pvData,
1338     [in] LPCOLESTR szFieldName,
1339     [in] VARIANT *pvarField);
1340
1341   HRESULT PutFieldNoCopy(
1342     [in] ULONG wFlags,
1343     [in, out] PVOID pvData,
1344     [in] LPCOLESTR szFieldName,
1345     [in] VARIANT *pvarField);
1346
1347   HRESULT GetFieldNames(
1348     [in, out] ULONG *pcNames,
1349     [out, size_is(*pcNames), length_is(*pcNames)] BSTR *rgBstrNames);
1350
1351   BOOL IsMatchingType(
1352     [in] IRecordInfo *pRecordInfo);
1353
1354   PVOID RecordCreate();
1355
1356   HRESULT RecordCreateCopy(
1357     [in] PVOID pvSource,
1358     [out] PVOID *ppvDest);
1359
1360   HRESULT RecordDestroy(
1361     [in] PVOID pvRecord);
1362 }
1363
1364 [
1365   local,
1366   object,
1367   uuid(00020405-0000-0000-C000-000000000046),
1368   pointer_default(unique)
1369 ]
1370 interface ICreateTypeInfo : IUnknown
1371 {
1372   typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO;
1373
1374   HRESULT SetGuid(
1375     [in] REFGUID guid);
1376
1377   HRESULT SetTypeFlags(
1378     [in] UINT uTypeFlags);
1379
1380   HRESULT SetDocString(
1381     [in] LPOLESTR pStrDoc);
1382
1383   HRESULT SetHelpContext(
1384     [in] DWORD dwHelpContext);
1385
1386   HRESULT SetVersion(
1387     [in] WORD wMajorVerNum,
1388     [in] WORD wMinorVerNum);
1389
1390   HRESULT AddRefTypeInfo(
1391     [in] ITypeInfo *pTInfo,
1392     [in] HREFTYPE *phRefType);
1393
1394   HRESULT AddFuncDesc(
1395     [in] UINT index,
1396     [in] FUNCDESC *pFuncDesc);
1397
1398   HRESULT AddImplType(
1399     [in] UINT index,
1400     [in] HREFTYPE hRefType);
1401
1402   HRESULT SetImplTypeFlags(
1403     [in] UINT index,
1404     [in] INT implTypeFlags);
1405
1406   HRESULT SetAlignment(
1407     [in] WORD cbAlignment);
1408
1409   HRESULT SetSchema(
1410     [in] LPOLESTR pStrSchema);
1411
1412   HRESULT AddVarDesc(
1413     [in] UINT index,
1414     [in] VARDESC *pVarDesc);
1415
1416   HRESULT SetFuncAndParamNames(
1417     [in] UINT index,
1418     [in, size_is(cNames)] LPOLESTR *rgszNames,
1419     [in] UINT cNames);
1420
1421   HRESULT SetVarName(
1422     [in] UINT index,
1423     [in] LPOLESTR szName);
1424
1425   HRESULT SetTypeDescAlias(
1426     [in] TYPEDESC *pTDescAlias);
1427
1428   HRESULT DefineFuncAsDllEntry(
1429     [in] UINT index,
1430     [in] LPOLESTR szDllName,
1431     [in] LPOLESTR szProcName);
1432
1433   HRESULT SetFuncDocString(
1434     [in] UINT index,
1435     [in] LPOLESTR szDocString);
1436
1437   HRESULT SetVarDocString(
1438     [in] UINT index,
1439     [in] LPOLESTR szDocString);
1440
1441   HRESULT SetFuncHelpContext(
1442     [in] UINT index,
1443     [in] DWORD dwHelpContext);
1444
1445   HRESULT SetVarHelpContext(
1446     [in] UINT index,
1447     [in] DWORD dwHelpContext);
1448
1449   HRESULT SetMops(
1450     [in] UINT index,
1451     [in] BSTR bstrMops);
1452
1453   HRESULT SetTypeIdldesc(
1454     [in] IDLDESC * pIdlDesc);
1455
1456   HRESULT LayOut();
1457 }
1458
1459 [
1460   local,
1461   object,
1462   uuid(0002040E-0000-0000-C000-000000000046),
1463   pointer_default(unique)
1464 ]
1465 interface ICreateTypeInfo2 : ICreateTypeInfo
1466 {
1467   typedef [unique] ICreateTypeInfo2 *LPCREATETYPEINFO2;
1468
1469   HRESULT DeleteFuncDesc(
1470     [in] UINT index);
1471
1472   HRESULT DeleteFuncDescByMemId(
1473     [in] MEMBERID memid,
1474     [in] INVOKEKIND invKind);
1475
1476   HRESULT DeleteVarDesc(
1477     [in] UINT index);
1478
1479   HRESULT DeleteVarDescByMemId(
1480     [in] MEMBERID memid);
1481
1482   HRESULT DeleteImplType(
1483     [in] UINT index);
1484
1485   HRESULT SetCustData(
1486     [in] REFGUID guid,
1487     [in] VARIANT *pVarVal);
1488
1489   HRESULT SetFuncCustData( 
1490     [in] UINT index, 
1491     [in] REFGUID guid, 
1492     [in] VARIANT *pVarVal);
1493   
1494   HRESULT SetParamCustData( 
1495     [in] UINT indexFunc, 
1496     [in] UINT indexParam, 
1497     [in] REFGUID guid, 
1498     [in] VARIANT *pVarVal);
1499
1500   HRESULT SetVarCustData( 
1501     [in] UINT index, 
1502     [in] REFGUID guid, 
1503     [in] VARIANT *pVarVal);
1504
1505   HRESULT SetImplTypeCustData( 
1506     [in] UINT index, 
1507     [in] REFGUID guid, 
1508     [in] VARIANT *pVarVal);
1509
1510   HRESULT SetHelpStringContext(
1511     [in] ULONG dwHelpStringContext);
1512
1513   HRESULT SetFuncHelpStringContext(
1514     [in] UINT index,
1515     [in] ULONG dwHelpStringContext);
1516
1517   HRESULT SetVarHelpStringContext(
1518     [in] UINT index,
1519     [in] ULONG dwHelpStringContext);
1520
1521   HRESULT Invalidate();
1522
1523   HRESULT SetName(
1524     [in] LPOLESTR szName);
1525 }
1526
1527 [
1528   local,
1529   object,
1530   uuid(00020406-0000-0000-C000-000000000046),
1531   pointer_default(unique)
1532 ]
1533 interface ICreateTypeLib : IUnknown
1534 {
1535   typedef [unique] ICreateTypeLib *LPCREATETYPELIB;
1536
1537   HRESULT CreateTypeInfo(
1538     [in] LPOLESTR szName,
1539     [in] TYPEKIND tkind,
1540     [out] ICreateTypeInfo **ppCTInfo);
1541
1542   HRESULT SetName(
1543     [in] LPOLESTR szName);
1544
1545   HRESULT SetVersion(
1546     [in] WORD wMajorVerNum,
1547     [in] WORD wMinorVerNum);
1548
1549   HRESULT SetGuid(
1550     [in] REFGUID guid);
1551
1552   HRESULT SetDocString(
1553     [in] LPOLESTR szDoc);
1554
1555   HRESULT SetHelpFileName(
1556     [in] LPOLESTR szHelpFileName);
1557
1558   HRESULT SetHelpContext(
1559     [in] DWORD dwHelpContext);
1560
1561   HRESULT SetLcid(
1562     [in] LCID lcid);
1563
1564   HRESULT SetLibFlags(
1565     [in] UINT uLibFlags);
1566
1567   HRESULT SaveAllChanges();
1568 }
1569
1570 [
1571   local,
1572   object,
1573   uuid(0002040F-0000-0000-C000-000000000046),
1574   pointer_default(unique)
1575 ]
1576 interface ICreateTypeLib2 : ICreateTypeLib
1577 {
1578   typedef [unique] ICreateTypeLib2 *LPCREATETYPELIB2;
1579
1580   HRESULT DeleteTypeInfo(
1581     [in] LPOLESTR szName);
1582
1583   HRESULT SetCustData(
1584     [in] REFGUID guid,
1585     [in] VARIANT *pVarVal);
1586
1587   HRESULT SetHelpStringContext(
1588     [in] ULONG dwHelpStringContext);
1589
1590   HRESULT SetHelpStringDll(
1591     [in] LPOLESTR szFileName);
1592 }
1593
1594
1595 /*****************************************************************************
1596  * IErrorLog interface
1597  */
1598 [
1599   object,
1600   uuid(3127ca40-446e-11ce-8135-00aa004bb851),
1601   pointer_default(unique)
1602 ]
1603 interface IErrorLog : IUnknown
1604 {
1605   typedef IErrorLog *LPERRORLOG;
1606
1607   HRESULT AddError(
1608     [in] LPCOLESTR pszPropName,
1609     [in] EXCEPINFO *pExcepInfo);
1610 }
1611
1612
1613 /*****************************************************************************
1614  * IPropertyBag interface
1615  */
1616 [
1617   object,
1618   uuid(55272a00-42cb-11ce-8135-00aa004bb851),
1619   pointer_default(unique)
1620 ]
1621 interface IPropertyBag : IUnknown
1622 {
1623   typedef IPropertyBag *LPPROPERTYBAG;
1624
1625   [local]
1626   HRESULT Read(
1627     [in] LPCOLESTR pszPropName,
1628     [in, out] VARIANT *pVar,
1629     [in] IErrorLog *pErrorLog);
1630
1631   [call_as(Read)]
1632   HRESULT RemoteRead(
1633     [in] LPCOLESTR pszPropName,
1634     [out] VARIANT *pVar,
1635     [in] IErrorLog *pErrorLog,
1636     [in] DWORD varType,
1637     [in] IUnknown *pUnkObj);
1638
1639   HRESULT Write(
1640     [in] LPCOLESTR pszPropName,
1641     [in] VARIANT *pVar);
1642 }