//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1995.
//
//  File: oaidl.idl
//
//----------------------------------------------------------------------------

#ifndef DO_NO_IMPORTS
import "objidl.idl";
#endif

interface ITypeInfo;
interface ITypeLib;
interface IErrorInfo;
interface ICreateErrorInfo;
interface ISupportErrorInfo;

[
  version(0.1), pointer_default(unique),
  local  /* marshalling supplied by oleaut32.dll */
]
interface RemVariant
{

cpp_quote("//+-------------------------------------------------------------------------")
cpp_quote("//")
cpp_quote("//  Microsoft Windows")
cpp_quote("//  Copyright (C) Microsoft Corporation, 1992 - 1995.")
cpp_quote("//")
cpp_quote("//--------------------------------------------------------------------------")

#ifndef HUGEP
# ifdef WIN16
#  define HUGEP _huge
# else
#  define HUGEP
#  define FAR
#  define FARSTRUCT
# endif
#endif

/* Forward Declarations */
#ifdef HPP
interface IDispatch;
interface IStream;
interface IStorage;
interface IUnknown;
#endif

/* IDL declarations for BSTR how to transmit them */

cpp_quote("/* XBSTR is for internal use only, it is subject to change */")
typedef struct tagXBSTR {
    ULONG cbSize;
    [size_is(cbSize)]
    OLECHAR  rgBstrData[];
    } XBSTR;

typedef OLECHAR FAR* BSTR;

typedef BSTR FAR* LPBSTR;

/* Cairo extension: BLOB, CLIPDATA */
cpp_quote("#ifndef _tagBLOB_DEFINED")
cpp_quote("#define _tagBLOB_DEFINED")
cpp_quote("#define _BLOB_DEFINED")
cpp_quote("#define _LPBLOB_DEFINED")
typedef struct tagBLOB {
    ULONG cbSize;
    [size_is(cbSize)]
    BYTE  *pBlobData;
    } BLOB, * LPBLOB;
cpp_quote("#endif")

cpp_quote("#ifndef _tagCLIPDATA_DEFINED")
cpp_quote("#define _tagCLIPDATA_DEFINED")
cpp_quote("#define _CLIPDATA_DEFINED")
typedef struct tagCLIPDATA {
    ULONG cbSize;       // count that includes sizeof(ulClipFmt)
    long ulClipFmt;     // long to keep alignment
    [size_is(cbSize-4)]
    BYTE * pClipData;   // cbSize-sizeof(ULONG) bytes of data in clipboard format
    } CLIPDATA;
cpp_quote("#endif")

cpp_quote("#ifndef _tagSAFEARRAYBOUND_DEFINED")
cpp_quote("#define _tagSAFEARRAYBOUND_DEFINED")
cpp_quote("#define _SAFEARRAYBOUND_DEFINED")
cpp_quote("#define _LPSAFEARRAYBOUND_DEFINED")
typedef struct tagSAFEARRAYBOUND {
    ULONG cElements;
    LONG lLbound;
} SAFEARRAYBOUND, * LPSAFEARRAYBOUND;
cpp_quote("#endif")


cpp_quote("#ifndef _tagSAFEARRAY_DEFINED")
cpp_quote("#define _tagSAFEARRAY_DEFINED")
cpp_quote("#define _SAFEARRAY_DEFINED")
cpp_quote("#define _LPSAFEARRAY_DEFINED")
cpp_quote("#if 0")
cpp_quote("/* the following is what RPC knows how to remote */")
typedef struct FARSTRUCT tagSAFEARRAY {
    unsigned short cDims;
    unsigned short fFeatures;
#if defined(_WIN32)
    unsigned long cbElements;
    unsigned long cLocks;
#else
    unsigned short cbElements;
    unsigned short cLocks;
#ifdef _MAC
    Handle handle;
#else
    unsigned long handle;               // unused but kept for compatiblity
#endif
#endif
#ifdef LATER
    void HUGEP* pvData;
#else
    BYTE *pvData;
#endif
    [size_is(cDims)] SAFEARRAYBOUND rgsabound[];
} SAFEARRAY, FAR* LPSAFEARRAY;
cpp_quote("#else")
cpp_quote("typedef struct FARSTRUCT tagSAFEARRAY {")
cpp_quote("    unsigned short cDims;")
cpp_quote("    unsigned short fFeatures;")
cpp_quote("#if defined(_WIN32)")
cpp_quote("    unsigned long cbElements;")
cpp_quote("    unsigned long cLocks;")
cpp_quote("#else")
cpp_quote("    unsigned short cbElements;")
cpp_quote("    unsigned short cLocks;")
cpp_quote("    unsigned long handle;               // unused but kept for compatiblity")
cpp_quote("#endif")
cpp_quote("    void HUGEP* pvData;")
cpp_quote("    SAFEARRAYBOUND rgsabound[1];")
cpp_quote("} SAFEARRAY, FAR* LPSAFEARRAY;")
cpp_quote("#endif")

cpp_quote("#endif")

const USHORT FADF_AUTO       = 0x0001;  /* the array is allocated on the stack */
const USHORT FADF_STATIC     = 0x0002;  /* the array is staticly allocated */
const USHORT FADF_EMBEDDED   = 0x0004;  /* array is embedded in a structure        */
const USHORT FADF_FIXEDSIZE  = 0x0010;  /* array may not be resized or reallocated */
const USHORT FADF_BSTR       = 0x0100;  /* an array of BSTRs */
const USHORT FADF_UNKNOWN    = 0x0200;  /* an array of IUnknown* */
const USHORT FADF_DISPATCH   = 0x0400;  /* and array of IDispatch* */
const USHORT FADF_VARIANT    = 0x0800;  /* an array of VARIANTs */
const USHORT FADF_RESERVED   = 0xF0E8;  /* reserved bits */

typedef double DATE;

/* This is a helper struct for use in handling currency. */
cpp_quote("#ifndef _tagCY_DEFINED")
cpp_quote("#define _tagCY_DEFINED")
cpp_quote("#define _CY_DEFINED")

cpp_quote("#if 0")
#if 0   // MIDL can't handle this
cpp_quote("/* the following get a midl-generated tag added, which messes up */")
cpp_quote("/* unqualified references to the Lo and Hi members under C++ */")
typedef union tagCY {
    struct {
#ifdef _MAC
        long      Hi;
        long Lo;
#else
        unsigned long Lo;
        long      Hi;
#endif
    };
    LONGLONG    int64;
} CY;
#else //0
cpp_quote("/* the following isn't the real definition of CY, but it is */")
cpp_quote("/* what RPC knows how to remote */")
typedef struct tagCY {
    LONGLONG    int64;
} CY;
#endif //0
cpp_quote("#else")

cpp_quote("/* real definition that makes the C++ compiler happy */")
cpp_quote("typedef union tagCY {")
cpp_quote("    struct {         ")
cpp_quote("#ifdef _MAC          ")
cpp_quote("        long      Hi;")
cpp_quote("        long Lo;     ")
cpp_quote("#else                ")
cpp_quote("        unsigned long Lo;")
cpp_quote("        long      Hi;")
cpp_quote("#endif               ")
cpp_quote("    };               ")
cpp_quote("    LONGLONG int64;  ")
cpp_quote("} CY;                ")
cpp_quote("#endif")

cpp_quote("#endif")


typedef CY CURRENCY;

cpp_quote("/* 0 == FALSE, -1 == TRUE */")
typedef short VARIANT_BOOL;
cpp_quote("#ifndef VARIANT_TRUE")
cpp_quote("#define VARIANT_TRUE ((VARIANT_BOOL)0xffff)")
cpp_quote("#endif")
cpp_quote("#ifndef VARIANT_FALSE")
cpp_quote("#define VARIANT_FALSE ((VARIANT_BOOL)0)")
cpp_quote("#endif")



/*
 * VARENUM usage key,
 *
 *   [V] - may appear in a VARIANT
 *   [T] - may appear in a TYPEDESC
 *   [P] - may appear in an OLE property set
 *
 */
cpp_quote("#ifndef _VARENUM_DEFINED")
cpp_quote("#define _VARENUM_DEFINED")
/*
 * VARENUM usage key,
 *
 *   [V] - may appear in a VARIANT
 *   [T] - may appear in a TYPEDESC
 *   [P] - may appear in an OLE property set
 *   [S] - may appear in a Safe Array
 *
 */
cpp_quote("/*")
cpp_quote(" * VARENUM usage key,")
cpp_quote(" *")
cpp_quote(" * * [V] - may appear in a VARIANT")
cpp_quote(" * * [T] - may appear in a TYPEDESC")
cpp_quote(" * * [P] - may appear in an OLE property set")
cpp_quote(" * * [S] - may appear in a Safe Array")
cpp_quote(" *")
cpp_quote(" *")
cpp_quote(" *  VT_EMPTY            [V]   [P]     nothing                     ")
cpp_quote(" *  VT_NULL             [V]           SQL style Null              ")
cpp_quote(" *  VT_I2               [V][T][P][S]  2 byte signed int           ")
cpp_quote(" *  VT_I4               [V][T][P][S]  4 byte signed int           ")
cpp_quote(" *  VT_R4               [V][T][P][S]  4 byte real                 ")
cpp_quote(" *  VT_R8               [V][T][P][S]  8 byte real                 ")
cpp_quote(" *  VT_CY               [V][T][P][S]  currency                    ")
cpp_quote(" *  VT_DATE             [V][T][P][S]  date                        ")
cpp_quote(" *  VT_BSTR             [V][T][P][S]  OLE Automation string       ")
cpp_quote(" *  VT_DISPATCH         [V][T]   [S]  IDispatch FAR*              ")
cpp_quote(" *  VT_ERROR            [V][T]   [S]  SCODE                       ")
cpp_quote(" *  VT_BOOL             [V][T][P][S]  True=-1, False=0            ")
cpp_quote(" *  VT_VARIANT          [V][T][P][S]  VARIANT FAR*                ")
cpp_quote(" *  VT_UNKNOWN          [V][T]   [S]  IUnknown FAR*               ")

cpp_quote(" *  VT_I1                  [T]        signed char                 ")
cpp_quote(" *  VT_UI1              [V][T]   [S]  unsigned char               ")
cpp_quote(" *  VT_UI2                 [T]        unsigned short              ")
cpp_quote(" *  VT_UI4                 [T]        unsigned short              ")
cpp_quote(" *  VT_I8                  [T][P]     signed 64-bit int           ")
cpp_quote(" *  VT_UI8                 [T]        unsigned 64-bit int         ")
cpp_quote(" *  VT_INT                 [T]        signed machine int          ")
cpp_quote(" *  VT_UINT                [T]        unsigned machine int        ")
cpp_quote(" *  VT_VOID                [T]        C style void                ")
cpp_quote(" *  VT_HRESULT             [T]                                    ")
cpp_quote(" *  VT_PTR                 [T]        pointer type                ")
cpp_quote(" *  VT_SAFEARRAY           [T]        (use VT_ARRAY in VARIANT)   ")
cpp_quote(" *  VT_CARRAY              [T]        C style array               ")
cpp_quote(" *  VT_USERDEFINED         [T]        user defined type           ")
cpp_quote(" *  VT_LPSTR               [T][P]     null terminated string      ")
cpp_quote(" *  VT_LPWSTR              [T][P]     wide null terminated string ")

cpp_quote(" *  VT_FILETIME               [P]     FILETIME                    ")
cpp_quote(" *  VT_BLOB                   [P]     Length prefixed bytes       ")
cpp_quote(" *  VT_STREAM                 [P]     Name of the stream follows  ")
cpp_quote(" *  VT_STORAGE                [P]     Name of the storage follows ")
cpp_quote(" *  VT_STREAMED_OBJECT        [P]     Stream contains an object   ")
cpp_quote(" *  VT_STORED_OBJECT          [P]     Storage contains an object  ")
cpp_quote(" *  VT_BLOB_OBJECT            [P]     Blob contains an object     ")
cpp_quote(" *  VT_CF                     [P]     Clipboard format            ")
cpp_quote(" *  VT_CLSID                  [P]     A Class ID                  ")

cpp_quote(" *  VT_VECTOR                 [P]     simple counted array        ")
cpp_quote(" *  VT_ARRAY            [V]           SAFEARRAY*                  ")
cpp_quote(" *  VT_BYREF            [V]                                       ")
cpp_quote(" */")

enum VARENUM
{
    VT_EMPTY           = 0,
    VT_NULL            = 1,
    VT_I2              = 2,
    VT_I4              = 3,
    VT_R4              = 4,
    VT_R8              = 5,
    VT_CY              = 6,
    VT_DATE            = 7,
    VT_BSTR            = 8,
    VT_DISPATCH        = 9,
    VT_ERROR           = 10,
    VT_BOOL            = 11,
    VT_VARIANT         = 12,
    VT_UNKNOWN         = 13,

    VT_I1              = 16,
    VT_UI1             = 17,
    VT_UI2             = 18,
    VT_UI4             = 19,
    VT_I8              = 20,
    VT_UI8             = 21,
    VT_INT             = 22,
    VT_UINT            = 23,
    VT_VOID            = 24,
    VT_HRESULT         = 25,
    VT_PTR             = 26,
    VT_SAFEARRAY       = 27,
    VT_CARRAY          = 28,
    VT_USERDEFINED     = 29,
    VT_LPSTR           = 30,
    VT_LPWSTR          = 31,

    VT_FILETIME        = 64,
    VT_BLOB            = 65,
    VT_STREAM          = 66,
    VT_STORAGE         = 67,
    VT_STREAMED_OBJECT = 68,
    VT_STORED_OBJECT   = 69,
    VT_BLOB_OBJECT     = 70,
    VT_CF              = 71,
    VT_CLSID           = 72
};
cpp_quote("#endif")


const USHORT VT_VECTOR =     0x1000;
const USHORT VT_ARRAY  =     0x2000;
const USHORT VT_BYREF  =     0x4000;
const USHORT VT_RESERVED =   0x8000;


cpp_quote("#ifndef _VARTYPE_DEFINED")
cpp_quote("#define _VARTYPE_DEFINED")
typedef unsigned short VARTYPE;
cpp_quote("#endif")

typedef struct tagVARIANT VARIANT;

cpp_quote("/* forward declare IDispatch */")
cpp_quote("typedef interface IDispatch IDispatch;")

cpp_quote("/* VARIANT STRUCTURE")
cpp_quote(" *")
cpp_quote(" *  VARTYPE vt;")
cpp_quote(" *  unsigned short wReserved1;")
cpp_quote(" *  unsigned short wReserved2;")
cpp_quote(" *  unsigned short wReserved3;")
cpp_quote(" *  union {")
cpp_quote(" *    unsigned char        VT_UI1               ")
cpp_quote(" *    short                VT_I2                ")
cpp_quote(" *    long                 VT_I4                ")
cpp_quote(" *    float                VT_R4                ")
cpp_quote(" *    double               VT_R8                ")
cpp_quote(" *    VARIANT_BOOL         VT_BOOL              ")
cpp_quote(" *    SCODE                VT_ERROR             ")
cpp_quote(" *    CY                   VT_CY                ")
cpp_quote(" *    DATE                 VT_DATE              ")
cpp_quote(" *    BSTR                 VT_BSTR              ")
cpp_quote(" *    IUnknown FAR*        VT_UNKNOWN           ")
cpp_quote(" *    IDispatch FAR*       VT_DISPATCH          ")
cpp_quote(" *    SAFEARRAY FAR*       VT_ARRAY|*           ")

cpp_quote(" *    short FAR*           VT_BYREF|VT_I2       ")
cpp_quote(" *    long FAR*            VT_BYREF|VT_I4       ")
cpp_quote(" *    float FAR*           VT_BYREF|VT_R4       ")
cpp_quote(" *    double FAR*          VT_BYREF|VT_R8       ")
cpp_quote(" *    VARIANT_BOOL FAR*    VT_BYREF|VT_BOOL     ")
cpp_quote(" *    SCODE FAR*           VT_BYREF|VT_ERROR    ")
cpp_quote(" *    CY FAR*              VT_BYREF|VT_CY       ")
cpp_quote(" *    DATE FAR*            VT_BYREF|VT_DATE     ")
cpp_quote(" *    BSTR FAR*            VT_BYREF|VT_BSTR     ")
cpp_quote(" *    IUnknown FAR* FAR*   VT_BYREF|VT_UNKNOWN  ")
cpp_quote(" *    IDispatch FAR* FAR*  VT_BYREF|VT_DISPATCH ")
cpp_quote(" *    SAFEARRAY FAR* FAR*  VT_BYREF|VT_ARRAY|*  ")
cpp_quote(" *    VARIANT FAR*         VT_BYREF|VT_VARIANT  ")

cpp_quote(" *    void FAR*            Generic ByRef        ")
cpp_quote(" */")

cpp_quote("#ifndef _tagVARIANT_DEFINED")
cpp_quote("#define _tagVARIANT_DEFINED")
cpp_quote("#if 0")
cpp_quote("/* the following is what RPC knows how to remote */")
struct tagVARIANT{
    VARTYPE vt;
    WORD wReserved1;
    WORD wReserved2;
    WORD wReserved3;
    [switch_type(unsigned short), switch_is((unsigned short) (vt & 0x1fff))] union
    {
[case(VT_I4)]   // moved first so you can statically init most of the structure
      long          lVal;           /* VT_I4                */
[case(VT_UI1)]
      unsigned char bVal;           /* VT_UI1               */
[case(VT_I2)]
      short         iVal;           /* VT_I2                */
[case(VT_R4)]
      float         fltVal;         /* VT_R4                */
[case(VT_R8)]
      double        dblVal;         /* VT_R8                */
[case(VT_BOOL)]
      VARIANT_BOOL  bool;           /* VT_BOOL              */
[case(VT_ERROR)]
      SCODE         scode;          /* VT_ERROR             */
[case(VT_CY)]
      CY            cyVal;          /* VT_CY                */
[case(VT_DATE)]
      DATE          date;           /* VT_DATE              */
[case(VT_BSTR)]
      BSTR          bstrVal;        /* VT_BSTR              */

#if !defined(NO_MARSHAL_INTERFACE)
[case(VT_UNKNOWN)]
      IUnknown      *punkVal;       /* VT_UNKNOWN           */
#endif //!defined(NO_MARSHAL_INTERFACE)

#ifdef HPP
[case(VT_DISPATCH)]
      IDispatch     *pdispVal;      /* VT_DISPATCH          */
#endif

[case(VT_ARRAY)]
      SAFEARRAY     *parray;        /* VT_ARRAY|*           */

[case(VT_UI1|VT_BYREF)]
      unsigned char *pbVal;         /* VT_BYREF|VT_UI1      */
[case(VT_I2|VT_BYREF)]
      short         *piVal;         /* VT_BYREF|VT_I2       */
[case(VT_I4|VT_BYREF)]
      long          *plVal;         /* VT_BYREF|VT_I4       */
[case(VT_R4|VT_BYREF)]
      float         *pfltVal;       /* VT_BYREF|VT_R4       */
[case(VT_R8|VT_BYREF)]
      double        *pdblVal;       /* VT_BYREF|VT_R8       */
[case(VT_BOOL|VT_BYREF)]
      VARIANT_BOOL  *pbool;         /* VT_BYREF|VT_BOOL     */
[case(VT_ERROR|VT_BYREF)]
      SCODE         *pscode;        /* VT_BYREF|VT_ERROR    */
[case(VT_CY|VT_BYREF)]
      CY            *pcyVal;        /* VT_BYREF|VT_CY       */
[case(VT_DATE|VT_BYREF)]
      DATE          *pdate;         /* VT_BYREF|VT_DATE     */
[case(VT_BSTR|VT_BYREF)]
      BSTR          *pbstrVal;      /* VT_BYREF|VT_BSTR     */

#if !defined(NO_MARSHAL_INTERFACE)
[case(VT_UNKNOWN|VT_BYREF)]
      IUnknown      **ppunkVal;     /* VT_BYREF|VT_UNKNOWN  */
#endif //!defined(NO_MARSHAL_INTERFACE)

#ifdef HPP
[case(VT_DISPATCH|VT_BYREF)]
      IDispatch     **ppdispVal;    /* VT_BYREF|VT_DISPATCH */
#endif

[case(VT_ARRAY|VT_BYREF)]
      SAFEARRAY     **pparray;      /* VT_BYREF|VT_ARRAY|*  */
[case(VT_VARIANT, VT_VARIANT|VT_BYREF)]
      VARIANT       *pvarVal;       /* VT_BYREF|VT_VARIANT  */
[case(VT_BYREF)]
#ifdef LATER
      void     * byref;             /* Generic ByRef        */
#else
      long     * byref;             /* form midl likes */
#endif
    }
#if(defined(NONAMELESSUNION))
    u
#endif
     ;
};
cpp_quote("#endif")

cpp_quote("struct tagVARIANT{")
cpp_quote("    VARTYPE vt;")
cpp_quote("    WORD wReserved1;")
cpp_quote("    WORD wReserved2;")
cpp_quote("    WORD wReserved3;")
cpp_quote("    union")
cpp_quote("    {")
cpp_quote("      long          lVal;           /* VT_I4                */")
cpp_quote("      unsigned char bVal;           /* VT_UI1               */")
cpp_quote("      short         iVal;           /* VT_I2                */")
cpp_quote("      float         fltVal;         /* VT_R4                */")
cpp_quote("      double        dblVal;         /* VT_R8                */")
cpp_quote("      VARIANT_BOOL  bool;           /* VT_BOOL              */")
cpp_quote("      SCODE         scode;          /* VT_ERROR             */")
cpp_quote("      CY            cyVal;          /* VT_CY                */")
cpp_quote("      DATE          date;           /* VT_DATE              */")
cpp_quote("      BSTR          bstrVal;        /* VT_BSTR              */")
cpp_quote("      IUnknown      *punkVal;       /* VT_UNKNOWN           */")
cpp_quote("      IDispatch     *pdispVal;      /* VT_DISPATCH          */")
cpp_quote("      SAFEARRAY     *parray;        /* VT_ARRAY|*           */")
cpp_quote("      unsigned char *pbVal;         /* VT_BYREF|VT_UI1      */")
cpp_quote("      short         *piVal;         /* VT_BYREF|VT_I2       */")
cpp_quote("      long          *plVal;         /* VT_BYREF|VT_I4       */")
cpp_quote("      float         *pfltVal;       /* VT_BYREF|VT_R4       */")
cpp_quote("      double        *pdblVal;       /* VT_BYREF|VT_R8       */")
cpp_quote("      VARIANT_BOOL  *pbool;         /* VT_BYREF|VT_BOOL     */")
cpp_quote("      SCODE         *pscode;        /* VT_BYREF|VT_ERROR    */")
cpp_quote("      CY            *pcyVal;        /* VT_BYREF|VT_CY       */")
cpp_quote("      DATE          *pdate;         /* VT_BYREF|VT_DATE     */")
cpp_quote("      BSTR          *pbstrVal;      /* VT_BYREF|VT_BSTR     */")
cpp_quote("      IUnknown      **ppunkVal;     /* VT_BYREF|VT_UNKNOWN  */")
cpp_quote("      IDispatch     **ppdispVal;    /* VT_BYREF|VT_DISPATCH */")
cpp_quote("      SAFEARRAY     **pparray;      /* VT_BYREF|VT_ARRAY|*  */")
cpp_quote("      VARIANT       *pvarVal;       /* VT_BYREF|VT_VARIANT  */")
cpp_quote("      void     * byref;             /* Generic ByRef        */")
cpp_quote("    }")
cpp_quote("#if(defined(NONAMELESSUNION))")
cpp_quote("    u")
cpp_quote("#endif")
cpp_quote("     ;")
cpp_quote("};")

cpp_quote("#endif")

    cpp_quote("#ifndef _LPVARIANT_DEFINED")
    cpp_quote("#define _LPVARIANT_DEFINED")
    typedef struct tagVARIANT * LPVARIANT;
    cpp_quote("#endif")

    cpp_quote("#ifndef _VARIANTARG_DEFINED")
    cpp_quote("#define _VARIANTARG_DEFINED")
    typedef struct tagVARIANT VARIANTARG;
    cpp_quote("#endif")

    cpp_quote("#ifndef _LPVARIANTARG_DEFINED")
    cpp_quote("#define _LPVARIANTARG_DEFINED")
    typedef struct tagVARIANT * LPVARIANTARG;
    cpp_quote("#endif")



//TypeInfo stuff.

    cpp_quote("#ifndef _DISPID_DEFINED")
    cpp_quote("#define _DISPID_DEFINED")
    typedef LONG DISPID;
    cpp_quote("#endif")


    cpp_quote("#ifndef _MEMBERID_DEFINED")
    cpp_quote("#define _MEMBERID_DEFINED")
    typedef DISPID MEMBERID;
    cpp_quote("#endif")

    cpp_quote("#ifndef _HREFTYPE_DEFINED")
    cpp_quote("#define _HREFTYPE_DEFINED")
    typedef DWORD HREFTYPE;
    cpp_quote("#endif")

// Property stuff
    typedef ULONG PROPID;


typedef [transmit_as(long)] enum tagTYPEKIND
{
    TKIND_ENUM = 0,
    TKIND_RECORD,
    TKIND_MODULE,
    TKIND_INTERFACE,
    TKIND_DISPATCH,
    TKIND_COCLASS,
    TKIND_ALIAS,
    TKIND_UNION,
    TKIND_MAX                   /* end of enum marker */
} TYPEKIND;
cpp_quote("#define TYPEKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
cpp_quote("#define TYPEKIND_from_xmit(pLong, pEnum) *(pEnum) = (TYPEKIND) *(pLong)")
cpp_quote("#define TYPEKIND_free_inst(pEnum) ")
cpp_quote("#define TYPEKIND_free_xmit(pLong) ")



cpp_quote("#ifndef _tagTYPEDESC_DEFINED")
cpp_quote("#define _tagTYPEDESC_DEFINED")
cpp_quote("#define _TYPEDESC_DEFINED")

cpp_quote("/* VT_PTR - lptdesc, the pointed at type */")
cpp_quote("/* VT_CARRAY - lpadesc */")
cpp_quote("/* VT_USERDEFINED - hreftype, used to get the UDT typeinfo */")

typedef struct tagTYPEDESC {
    [switch_type(short), switch_is((short)vt)] union
    {
      [case(VT_PTR)] struct tagTYPEDESC * lptdesc;
      [case(VT_CARRAY)] struct tagARRAYDESC * lpadesc;
      [case(VT_USERDEFINED)] HREFTYPE hreftype;
    }
#if(defined(NONAMELESSUNION))
    u
#endif
    ;
    VARTYPE vt;
} TYPEDESC;
cpp_quote("#endif")


cpp_quote("#ifndef _tagARRAYDESC_DEFINED")
cpp_quote("#define _tagARRAYDESC_DEFINED")
cpp_quote("#define _ARRAYDESC_DEFINED")
cpp_quote("#if 0")
    typedef struct tagARRAYDESC {
        TYPEDESC tdescElem;     /* element type */
        USHORT cDims;       /* dimension count */
        [size_is(cDims)] SAFEARRAYBOUND rgbounds[]; /* variable length array of bounds */
    } ARRAYDESC;
cpp_quote("#else")
cpp_quote("typedef struct tagARRAYDESC {")
cpp_quote("    TYPEDESC tdescElem;     /* element type */")
cpp_quote("    USHORT cDims;       /* dimension count */")
cpp_quote("    SAFEARRAYBOUND rgbounds[1]; /* variable length array of bounds */")
cpp_quote("} ARRAYDESC;")
cpp_quote("#endif")
cpp_quote("#endif")


cpp_quote("#ifndef _tagIDLDESC_DEFINED")
cpp_quote("#define _tagIDLDESC_DEFINED")
cpp_quote("#define _IDLDESC_DEFINED")
cpp_quote("#define _LPIDLDESC_DEFINED")
cpp_quote("#ifdef _WIN32")
typedef struct FARSTRUCT tagIDLDESC {
#if defined(_WIN32) || defined(_MAC)
    unsigned long dwReserved;
#else
    BSTR bstrIDLInfo;           /* reserved, but original name retained for
                                   compatibilty */
#endif
    unsigned short wIDLFlags;   /* IN, OUT, etc */
} IDLDESC, FAR* LPIDLDESC;

cpp_quote("#else")
cpp_quote("typedef struct FARSTRUCT tagIDLDESC {")
cpp_quote("#if defined(_WIN32)")
cpp_quote("    unsigned long dwReserved;")
cpp_quote("#else")
cpp_quote("    BSTR bstrIDLInfo;           /* reserved, but original name retained for")
cpp_quote("                                   compatibilty */")
cpp_quote("#endif")
cpp_quote("    unsigned short wIDLFlags;   /* IN, OUT, etc */")
cpp_quote("} IDLDESC, FAR* LPIDLDESC;")
cpp_quote("#endif")
cpp_quote("#endif")


cpp_quote("#ifndef _tagELEMDESC_DEFINED")
cpp_quote("#define _tagELEMDESC_DEFINED")
cpp_quote("#define _ELEMDESC_DEFINED")
cpp_quote("#define _LPELEMDESC_DEFINED")
typedef struct tagELEMDESC {
    TYPEDESC tdesc;     /* the type of the element */
    IDLDESC idldesc;        /* info for remoting the element */
} ELEMDESC, * LPELEMDESC;
cpp_quote("#endif")


cpp_quote("#ifndef _tagTYPEATTR_DEFINED")
cpp_quote("#define _tagTYPEATTR_DEFINED")
cpp_quote("#define _TYPEATTR_DEFINED")
cpp_quote("#define _LPTYPEATTR_DEFINED")
typedef struct tagTYPEATTR {
    GUID guid;          /* the GUID of the TypeInfo */
    LCID lcid;          /* locale of member names and doc strings */
    DWORD dwReserved;
    MEMBERID memidConstructor;  /* ID of constructor, MEMBERID_NIL if none */
    MEMBERID memidDestructor;   /* ID of destructor, MEMBERID_NIL if none */
    LPOLESTR lpstrSchema;
    ULONG cbSizeInstance;    /* the size of an instance of this type */
    TYPEKIND typekind;      /* the kind of type this typeinfo describes */
    WORD cFuncs;        /* number of functions */
    WORD cVars;         /* number of variables / data members */
    WORD cImplTypes;        /* number of implemented interfaces */
    WORD cbSizeVft;     /* the size of this types virtual func table */
    WORD cbAlignment;       /* specifies the alignment requirements for
                   an instance of this type,
                     0 = align on 64k boundary
                     1 = byte align
                     2 = word align
                     4 = dword align... */
    WORD wTypeFlags;
    WORD wMajorVerNum;      /* major version number */
    WORD wMinorVerNum;      /* minor version number */
    TYPEDESC tdescAlias;    /* if typekind == TKIND_ALIAS this field
                   specifies the type for which this type
                   is an alias */
    IDLDESC idldescType;        /* IDL attributes of the described type */
} TYPEATTR, * LPTYPEATTR;
cpp_quote("#endif")


typedef struct tagDISPPARAMS{
    [size_is(cArgs)] VARIANTARG * rgvarg;
    [size_is(cNamedArgs)] DISPID * rgdispidNamedArgs;
    UINT cArgs;
    UINT cNamedArgs;
} DISPPARAMS;


typedef struct tagRemEXCEPINFO {
    WORD wCode;             /* An error code describing the error. */
    WORD wReserved;
    DWORD dwHelpContext;    /* help context of topic within the help file. */
    DWORD scode;
    DWORD cSource;
    DWORD cDescription;
    DWORD cHelpFile;
    [size_is(cSource + cDescription + cHelpFile)] OLECHAR strings[]; //Contains bstrSource, bstrDescription, bstrHelpFile.
}  RemEXCEPINFO;


cpp_quote("#if 0")
typedef [transmit_as(RemEXCEPINFO)] struct tagEXCEPINFO {
    WORD wCode;             /* An error code describing the error. */
    WORD wReserved;

    BSTR bstrSource;        /* A textual, human readable name of the
                   source of the exception. It is up to the
                   IDispatch implementor to fill this in.
                   Typically this will be an application name. */

    BSTR bstrDescription;   /* A textual, human readable description of the
                   error. If no description is available, NULL
                   should be used. */

    BSTR bstrHelpFile;      /* Fully qualified drive, path, and file name
                   of a help file with more information about
                   the error.  If no help is available, NULL
                   should be used. */

    DWORD dwHelpContext;    /* help context of topic within the help file. */

    [unique] void * pvReserved;

    HRESULT (__stdcall * pfnDeferredFillIn)(struct tagEXCEPINFO *);
                /* Use of this field allows an application
                   to defer filling in the bstrDescription,
                   bstrHelpFile, and dwHelpContext fields
                   until they are needed.  This field might
                   be used, for example, if loading the
                   string for the error is a time-consuming
                   operation. If deferred fill-in is not
                   desired, this field should be set to NULL. */

    SCODE scode;
}  EXCEPINFO, * LPEXCEPINFO;
cpp_quote("#else")
cpp_quote("typedef struct tagEXCEPINFO {")
cpp_quote("    WORD wCode;")
cpp_quote("    WORD wReserved;")
cpp_quote("    BSTR bstrSource;")
cpp_quote("    BSTR bstrDescription;")
cpp_quote("    BSTR bstrHelpFile;")
cpp_quote("    DWORD dwHelpContext;")
cpp_quote("    void __RPC_FAR * pvReserved;")
cpp_quote("    HRESULT (__stdcall __RPC_FAR * pfnDeferredFillIn)(struct tagEXCEPINFO __RPC_FAR *);")
cpp_quote("    SCODE scode;")
cpp_quote("}  EXCEPINFO, __RPC_FAR * LPEXCEPINFO;")
cpp_quote("#endif")


typedef [transmit_as(long)] enum tagCALLCONV {
      CC_CDECL = 1
    , CC_MSCPASCAL
    , CC_PASCAL = CC_MSCPASCAL
    , CC_MACPASCAL
    , CC_STDCALL
    , CC_RESERVED
    , CC_SYSCALL
    , CC_MPWCDECL
    , CC_MPWPASCAL
    , CC_MAX                    /* end of enum marker */
#ifdef _MAC
    , CC_FORCELONG = 2147483647
#endif
} CALLCONV;




cpp_quote("#define CALLCONV_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
cpp_quote("#define CALLCONV_from_xmit(pLong, pEnum) *(pEnum) = (CALLCONV) *(pLong)")
cpp_quote("#define CALLCONV_free_inst(pEnum) ")
cpp_quote("#define CALLCONV_free_xmit(pLong) ")


typedef [transmit_as(long)] enum tagFUNCKIND {
    FUNC_VIRTUAL,
    FUNC_PUREVIRTUAL,
    FUNC_NONVIRTUAL,
    FUNC_STATIC,
    FUNC_DISPATCH
} FUNCKIND;
cpp_quote("#define FUNCKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
cpp_quote("#define FUNCKIND_from_xmit(pLong, pEnum) *(pEnum) = (FUNCKIND) *(pLong)")
cpp_quote("#define FUNCKIND_free_inst(pEnum) ")
cpp_quote("#define FUNCKIND_free_xmit(pLong) ")


typedef [transmit_as(long)] enum tagINVOKEKIND {
    INVOKE_FUNC = 1,
    INVOKE_PROPERTYGET = 2,
    INVOKE_PROPERTYPUT = 4,
    INVOKE_PROPERTYPUTREF = 8
} INVOKEKIND;
cpp_quote("#define INVOKEKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
cpp_quote("#define INVOKEKIND_from_xmit(pLong, pEnum) *(pEnum) = (INVOKEKIND) *(pLong)")
cpp_quote("#define INVOKEKIND_free_inst(pEnum) ")
cpp_quote("#define INVOKEKIND_free_xmit(pLong) ")


typedef struct tagFUNCDESC {
    MEMBERID memid;
    [size_is(cScodes)] SCODE * lprgscode;
    [size_is(cParams)] ELEMDESC * lprgelemdescParam;  /* array of parameter types */
    FUNCKIND funckind;
    INVOKEKIND invkind;
    CALLCONV callconv;
    SHORT cParams;
    SHORT cParamsOpt;
    SHORT oVft;
    SHORT cScodes;
    ELEMDESC elemdescFunc;
    WORD wFuncFlags;
} FUNCDESC, * LPFUNCDESC;


typedef [transmit_as(long)] enum tagVARKIND {
    VAR_PERINSTANCE,
    VAR_STATIC,
    VAR_CONST,
    VAR_DISPATCH
} VARKIND;
cpp_quote("#define VARKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
cpp_quote("#define VARKIND_from_xmit(pLong, pEnum) *(pEnum) = (VARKIND) *(pLong)")
cpp_quote("#define VARKIND_free_inst(pEnum) ")
cpp_quote("#define VARKIND_free_xmit(pLong) ")



/* IMPLTYPE Flags */
const USHORT IMPLTYPEFLAG_FDEFAULT = 0x1;
const USHORT IMPLTYPEFLAG_FSOURCE  = 0x2;
const USHORT IMPLTYPEFLAG_FRESTRICTED  = 0x4;






typedef struct tagVARDESC {
    MEMBERID memid;
    LPOLESTR lpstrSchema;
    [switch_type(unsigned short), switch_is((unsigned short)varkind)]
    union
    {
      [case(VAR_PERINSTANCE)] ULONG oInst;      /* VAR_PERINSTANCE - the offset of this
                   variable within the instance */
      [case(VAR_CONST)] VARIANT * lpvarValue;  /* VAR_CONST - the value of the constant */
    };
    ELEMDESC elemdescVar;
    WORD wVarFlags;
    VARKIND varkind;
} VARDESC, * LPVARDESC;


cpp_quote("#ifndef _tagTYPEFLAGS_DEFINED")
cpp_quote("#define _tagTYPEFLAGS_DEFINED")
cpp_quote("#define _TYPEFLAGS_DEFINED")
typedef enum tagTYPEFLAGS {
      TYPEFLAG_FAPPOBJECT = 0x01
    , TYPEFLAG_FCANCREATE = 0x02
    , TYPEFLAG_FLICENSED = 0x04
    , TYPEFLAG_FPREDECLID = 0x08
    , TYPEFLAG_FHIDDEN = 0x10
    , TYPEFLAG_FCONTROL = 0x20
    , TYPEFLAG_FDUAL = 0x40
    , TYPEFLAG_FNONEXTENSIBLE = 0x80
    , TYPEFLAG_FOLEAUTOMATION = 0x100
    , TYPEFLAG_FRESTRICTED = 0x200
#ifdef _MAC
    , TYPEFLAG_FORCELONG  = 2147483647
#endif
} TYPEFLAGS;
cpp_quote("#endif")



cpp_quote("#ifndef _tagFUNCFLAGS_DEFINED")
cpp_quote("#define _tagFUNCFLAGS_DEFINED")
cpp_quote("#define _FUNCFLAGS_DEFINED")
typedef enum tagFUNCFLAGS {
      FUNCFLAG_FRESTRICTED= 1
      , FUNCFLAG_FSOURCE= 0x2
      , FUNCFLAG_FBINDABLE= 0x4
      , FUNCFLAG_FREQUESTEDIT= 0x8
      , FUNCFLAG_FDISPLAYBIND= 0x10
      , FUNCFLAG_FDEFAULTBIND= 0x20
      , FUNCFLAG_FHIDDEN= 0x40
      , FUNCFLAG_FUSESGETLASTERROR= 0x80
#ifdef _MAC
    , FUNCFLAG_FORCELONG  = 2147483647
#endif
} FUNCFLAGS;
cpp_quote("#endif")


cpp_quote("#ifndef _tagVARFLAGS_DEFINED")
cpp_quote("#define _tagVARFLAGS_DEFINED")
cpp_quote("#define _VARFLAGS_DEFINED")
typedef enum tagVARFLAGS {
      VARFLAG_FREADONLY = 1
      , VARFLAG_FSOURCE= 0x2
      , VARFLAG_FBINDABLE= 0x4
      , VARFLAG_FREQUESTEDIT= 0x8
      , VARFLAG_FDISPLAYBIND= 0x10
      , VARFLAG_FDEFAULTBIND= 0x20
      , VARFLAG_FHIDDEN = 0x40
#ifdef _MAC
    , VARFLAG_FORCELONG   = 2147483647
#endif
} VARFLAGS;
cpp_quote("#endif")
}
[
    object,
    uuid(00020405-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ICreateTypeInfo: IUnknown
{

    typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO;



    HRESULT SetGuid(
                     [in] REFGUID guid
                   );

    HRESULT SetTypeFlags(
                        [in]   UINT uTypeFlags
                        );

    HRESULT SetDocString(
                        [in] LPOLESTR lpstrDoc
                        );

    HRESULT SetHelpContext(
                        [in] DWORD dwHelpContext
                          );

    HRESULT SetVersion(
                        [in] WORD wMajorVerNum,
                        [in] WORD wMinorVerNum
                      );

    HRESULT AddRefTypeInfo(

                        [in] ITypeInfo * ptinfo,
                        [in] HREFTYPE * phreftype
                          );

    HRESULT AddFuncDesc(
                        [in] UINT index,
                        [in] FUNCDESC * pfuncdesc
                       );

    HRESULT AddImplType(
                        [in] UINT index,
                        [in] HREFTYPE hreftype
                       );

    HRESULT SetImplTypeFlags(
                        [in] UINT index,
                        [in] INT impltypeflags
                            );

    HRESULT SetAlignment(
                        [in] WORD cbAlignment
                        );

    HRESULT SetSchema(
                        [in] LPOLESTR lpstrSchema
                     );

    HRESULT AddVarDesc(
                        [in]  UINT index,
                        [in]  VARDESC * pvardesc
                      );

    HRESULT SetFuncAndParamNames(
                                 [in]  UINT index,
            [in, size_is((long) cNames)]
                                 [in]  LPOLESTR * rgszNames,
                                 [in]  UINT cNames
                               );

    HRESULT SetVarName(
                        [in] UINT index,
                        [in] LPOLESTR szName
                      );

    HRESULT SetTypeDescAlias(
                              [in]  TYPEDESC * ptdescAlias
                            );

    HRESULT DefineFuncAsDllEntry(
                                 [in] UINT index,
                                 [in] LPOLESTR szDllName,
                                 [in] LPOLESTR szProcName
         );

    HRESULT SetFuncDocString(
                              [in] UINT index,
                              [in] LPOLESTR szDocString
         );

    HRESULT SetVarDocString(
                              [in] UINT index,
                              [in] LPOLESTR szDocString
                           );

    HRESULT SetFuncHelpContext(
                              [in] UINT index,
                              [in] DWORD dwHelpContext
         );

    HRESULT SetVarHelpContext(
                              [in] UINT index,
                              [in] DWORD dwHelpContext
         );

    HRESULT SetMops(
                              [in] UINT index,
                              [in] BSTR bstrMops
         );

    HRESULT SetTypeIdldesc(
                              [in] IDLDESC * pidldesc
         );

    HRESULT LayOut(
                     void
                  );

}




[
    object,
    uuid(00020406-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ICreateTypeLib : IUnknown
{

    typedef [unique] ICreateTypeLib *LPCREATETYPELIB;


    HRESULT CreateTypeInfo(
                            [in]  LPOLESTR szName,
                            [in]  TYPEKIND tkind,
                            [out] ICreateTypeInfo **lplpictinfo
                           );

    HRESULT SetName( LPOLESTR szName);

    HRESULT SetVersion
    (
        [in] WORD wMajorVerNum,
        [in] WORD wMinorVerNum
    );




    HRESULT SetGuid
    (
        [in] REFGUID guid
    );

    HRESULT SetDocString
    (
        [in] LPOLESTR szDoc
    );


    HRESULT SetHelpFileName
    (
        [in] LPOLESTR szHelpFileName
    );

    HRESULT SetHelpContext
    (
        [in] DWORD dwHelpContext
    );

    HRESULT SetLcid
    (
        [in] LCID lcid
    );

    HRESULT SetLibFlags
    (
        [in] UINT uLibFlags
    );


    HRESULT SaveAllChanges
    (
        void
    );

}

[
    object,
    uuid(00020400-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface IDispatch : IUnknown
{

    typedef [unique] IDispatch *LPDISPATCH;

    HRESULT GetTypeInfoCount
    (
        [out] UINT *pctinfo
    );

    HRESULT GetTypeInfo
    (
        [in] UINT itinfo,
        [in] LCID lcid,
        [out] ITypeInfo ** pptinfo
    );

    HRESULT GetIDsOfNames
    (
        [in] REFIID riid,
        [in, size_is(cNames)] LPOLESTR *rgszNames,
        [in] UINT cNames,
        [in] LCID lcid,
        [in, out, size_is(cNames)] DISPID *rgdispid
    );

    HRESULT Invoke
    (
        [in] DISPID dispidMember,
        [in] REFIID riid,
        [in] LCID lcid,
        [in] WORD wFlags,
        [in, unique] DISPPARAMS *pdispparams,
        [in, out, unique] VARIANT *pvarResult,
        [out] EXCEPINFO *pexcepinfo,
        [out] UINT *puArgErr
    );

cpp_quote("/* DISPID reserved to indicate an \"unknown\" name */")
cpp_quote("/* only reserved for data members (properties); reused as a method dispid below */")
   const DISPID DISPID_UNKNOWN       = -1;

cpp_quote("/* DISPID reserved for the \"value\" property */")
   const DISPID DISPID_VALUE         = 0;

cpp_quote("/* The following DISPID is reserved to indicate the param")
cpp_quote(" * that is the right-hand-side (or \"put\" value) of a PropertyPut")
cpp_quote(" */")
const DISPID DISPID_PROPERTYPUT = -3;

cpp_quote("/* DISPID reserved for the standard \"NewEnum\" method */")
const DISPID DISPID_NEWENUM  = -4;

cpp_quote("/* DISPID reserved for the standard \"Evaluate\" method */")
const DISPID DISPID_EVALUATE = -5;

const DISPID DISPID_CONSTRUCTOR = -6;

const DISPID DISPID_DESTRUCTOR = -7;

const DISPID DISPID_COLLECT = -8;

cpp_quote("/* The range -500 through -999 is reserved for Controls */")
cpp_quote("/* The range 0x80010000 through 0x8001FFFF is reserved for Controls */")
cpp_quote("/* The remainder of the negative DISPIDs are reserved for future use */")

}

[
    object,
    local,
    uuid(00020404-0000-0000-C000-000000000046),
    pointer_default(unique)
]

interface IEnumVARIANT : IUnknown
{

    typedef [unique] IEnumVARIANT* LPENUMVARIANT;


    HRESULT Next(
        [in] unsigned long celt,
    [out] VARIANT *rgvar,
    [out] unsigned long *pceltFetched);

    HRESULT Skip(
    [in] unsigned long celt);

    HRESULT Reset();

    HRESULT Clone(
    [out] IEnumVARIANT** ppenum);

}

[
    object,
    uuid(00020403-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ITypeComp : IUnknown
{

    typedef [unique] ITypeComp *LPTYPECOMP;

    typedef [v1_enum] enum tagDESCKIND
    {
        DESCKIND_NONE = 0,
        DESCKIND_FUNCDESC,
        DESCKIND_VARDESC,
        DESCKIND_TYPECOMP,
        DESCKIND_IMPLICITAPPOBJ,
        DESCKIND_MAX
    } DESCKIND;

    cpp_quote("#define DESCKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
    cpp_quote("#define DESCKIND_from_xmit(pLong, pEnum) *(pEnum) = (DESCKIND) *(pLong)")
    cpp_quote("#define DESCKIND_free_inst(pEnum) ")
    cpp_quote("#define DESCKIND_free_xmit(pLong) ")

    [switch_type(long)] union tagBINDPTR
    {
    [case(DESCKIND_FUNCDESC)]
        FUNCDESC *lpfuncdesc;

    [case(DESCKIND_VARDESC)]
        VARDESC *lpvardesc;

    [case(DESCKIND_TYPECOMP)]
        [unique] ITypeComp *lptcomp;

    [default]
        ;
    };

    typedef union tagBINDPTR BINDPTR;
    typedef BINDPTR *LPBINDPTR;

    HRESULT Bind
    (
        [in] LPOLESTR szName,
        [in] ULONG lHashVal,
        [in] WORD fFlags,
        [out] ITypeInfo **pptinfo,
        [out] DESCKIND *pdesckind,
        [out, switch_is((long) *pdesckind)] BINDPTR *pbindptr
    );

    HRESULT BindType
    (
        [in] LPOLESTR szName,
        [in] ULONG lHashVal,
        [out] ITypeInfo **pptinfo,
        [out] ITypeComp **pptcomp
    );
}

[
    object,
    uuid(00020401-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ITypeInfo : IUnknown
{

    typedef [unique] ITypeInfo *LPTYPEINFO;

/*---------------------------------------------------------------------*/
/*                            ITypeInfo                                */
/*---------------------------------------------------------------------*/

    HRESULT GetTypeAttr
    (
        [out] TYPEATTR **pptypeattr
    );

    HRESULT GetTypeComp
    (
        [out] ITypeComp **pptcomp
    );

    HRESULT GetFuncDesc
    (
        [in] UINT index,
        [out] FUNCDESC **pppfuncdesc
    );

    HRESULT GetVarDesc
    (
        [in] UINT index,
        [out] VARDESC **ppvardesc
    );

    HRESULT GetNames
    (
        [in] MEMBERID memid,
        [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgbstrNames,
        [in] UINT cMaxNames,
        [out] UINT *pcNames
    );


    HRESULT GetRefTypeOfImplType
    (
        [in] UINT index,
        [out] HREFTYPE *hpreftype
    );


    HRESULT GetImplTypeFlags
    (
        [in] UINT index,
        [out] INT * pimpltypeflags
    );



    HRESULT GetIDsOfNames
    (
        [in, size_is(cNames)] OLECHAR **rglpszNames,
        [in] UINT cNames,
        [out, size_is(cNames)] MEMBERID *rgmemid
    );

    HRESULT Invoke
    (
    [in, unique] void *pvInstance,
        [in] MEMBERID memid,
        [in] WORD wFlags,
        [in] DISPPARAMS *pdispparams,
        [out] VARIANT *pvarResult,
        [out] EXCEPINFO *pexcepinfo,
        [out] UINT *puArgErr
    );

    HRESULT GetDocumentation
    (
        [in] MEMBERID memid,
        [out] BSTR *pbstrName,
        [out] BSTR *pbstrDocString,
        [out] DWORD *pdwHelpContext,
        [out] BSTR * pbstrHelpFile
    );

    HRESULT GetDllEntry
    (
        [in] MEMBERID memid,
        [in] INVOKEKIND invkind,
        [out] BSTR *pbstrDllName,
        [out] BSTR *pbstrName,
        [out] WORD *pwOrdinal
    );

    HRESULT GetRefTypeInfo
    (
        [in] HREFTYPE hreftype,
        [out] ITypeInfo ** pptinfo
    );

    HRESULT __stdcall AddressOfMember
    (
        [in] MEMBERID memid,
        [in] INVOKEKIND invkind,
        [out] void **ppv
    );

    HRESULT CreateInstance
    (
        [in] IUnknown * puncOuter,
        [in] REFIID riid,
        [out] void **ppvObj
    );

    HRESULT GetMops
    (
        [in] MEMBERID memid,
        [out] BSTR *pbstrMops
    );

    HRESULT GetContainingTypeLib
    (
        [out] ITypeLib **pptlib,
        [out] UINT *pindex
    );

    void ReleaseTypeAttr
    (
        [in] TYPEATTR *ptypeattr
    );

    void ReleaseFuncDesc
    (
        [in] FUNCDESC *pfuncdesc
    );

    void ReleaseVarDesc
    (
        [in] VARDESC *pvardesc
    );
}

[
    object,
    uuid(00020402-0000-0000-C000-000000000046),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */

]

interface ITypeLib : IUnknown
{

    typedef [transmit_as(long)] enum tagSYSKIND
    {
        SYS_WIN16 = 0,
        SYS_WIN32,
        SYS_MAC
    } SYSKIND;


    typedef [transmit_as(long)] enum tagLIBFLAGS
    {
      LIBFLAG_FRESTRICTED = 0x01
      , LIBFLAG_FCONTROL = 0x02
      , LIBFLAG_FHIDDEN = 0x04
    } LIBFLAGS;

    // macros to work around a casting problem with midl generated code
    // and to preserve all 32-bits of the enum value
    //
    cpp_quote("#define SYSKIND_to_xmit(pEnum, ppLong) *(ppLong) = (long *) (pEnum)")
    cpp_quote("#define SYSKIND_from_xmit(pLong, pEnum) *(pEnum) = (SYSKIND) *(pLong)")
    cpp_quote("#define SYSKIND_free_inst(pEnum) ")
    cpp_quote("#define SYSKIND_free_xmit(pLong) ")


    typedef [unique] ITypeLib *LPTYPELIB;

    typedef struct tagTLIBATTR
    {
        GUID guid;
        LCID lcid;
        SYSKIND syskind;
        WORD wMajorVerNum;
        WORD wMinorVerNum;
        WORD wLibFlags;
    } TLIBATTR;

    typedef TLIBATTR *LPTLIBATTR;

    UINT GetTypeInfoCount
    (
        void
    );

    HRESULT GetTypeInfo
    (
        [in] UINT index,
        [out] ITypeInfo **ppitinfo
    );

    HRESULT GetTypeInfoType
    (
        [in] UINT index,
        [out] TYPEKIND * ptkind
    );

    HRESULT GetTypeInfoOfGuid
    (
        [in] REFGUID guid,
        [out] ITypeInfo **pptinfo
    );

    HRESULT GetLibAttr
    (
        [out] TLIBATTR **pptlibattr
    );

    HRESULT GetTypeComp
    (
        [out] ITypeComp **pptcomp
    );

    HRESULT GetDocumentation
    (
        [in] INT index,
        [out] BSTR *pbstrName,
        [out] BSTR *pbstrDocString,
        [out] DWORD *pdwHelpContext,
        [out] BSTR *pbstrHelpFile
    );

    HRESULT IsName
    (
        [in] LPOLESTR szNameBuf,
        [in] ULONG lHashVal,
        [out] BOOL *pfName
    );

    HRESULT FindName
    (
        [in] LPOLESTR szNameBuf,
        [in] ULONG lHashVal,
        [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo ** rgptinfo,
        [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID * rgmemid,
        [in, out] USHORT *pcFound
    );

    void ReleaseTLibAttr
    (
        [in] TLIBATTR *ptlibattr
    );

}

[
    object,
    uuid(1CF2B120-547D-101B-8E65-08002B2BD119),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface IErrorInfo: IUnknown
{

    typedef [unique] IErrorInfo *LPERRORINFO;

    HRESULT GetGUID(
                     [out] GUID FAR* pguid
                   );

    HRESULT GetSource(
                     [out] BSTR FAR* pbstrSource
                   );

    HRESULT GetDescription(
                     [out] BSTR FAR* pbstrDescription
                   );

    HRESULT GetHelpFile(
                     [out] BSTR FAR* pbstrHelpFile
                   );

    HRESULT GetHelpContext(
                     [out] DWORD FAR* pdwHelpContext
                   );

}

[
    object,
    uuid(22F03340-547D-101B-8E65-08002B2BD119),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ICreateErrorInfo: IUnknown
{

    typedef [unique] ICreateErrorInfo *LPCREATEERRORINFO;

    HRESULT SetGUID(
                     [in] REFGUID rguid
                   );

    HRESULT SetSource(
                     [in] LPOLESTR szSource
                   );

    HRESULT SetDescription(
                     [in] LPOLESTR szDescription
                   );

    HRESULT SetHelpFile(
                     [in] LPOLESTR szHelpFile
                   );

    HRESULT SetHelpContext(
                     [in] DWORD dwHelpContext
                   );

}

[
    object,
    uuid(DF0B3D60-548F-101B-8E65-08002B2BD119),
    pointer_default(unique),
    local  /* marshalling supplied by oleaut32.dll */
]

interface ISupportErrorInfo: IUnknown
{

    typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO;

    HRESULT InterfaceSupportsErrorInfo(
                     [in] REFIID riid
                   );

}

