VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/include/oaidl.idl@ 33252

Last change on this file since 33252 was 28475, checked in by vboxsync, 15 years ago

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