include/oaidl.idl

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