VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/shaderlib/wine/include/oaidl.idl@ 69505

Last change on this file since 69505 was 53206, checked in by vboxsync, 10 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette