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