system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-01 09:50:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/include/oaidl.idl

1642 lines
37 KiB
Text
Raw Blame History

/*
* Copyright 2002 Ove Kaaven
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#ifndef DO_NO_IMPORTS
import "objidl.idl";
#endif
interface IDispatch;
interface ITypeInfo;
interface ITypeLib;
interface IRecordInfo;
[
version(1.0),
pointer_default(unique)
]
interface IOleAutomationTypes
{
typedef CY CURRENCY;
/* Safe Array */
typedef struct tagSAFEARRAYBOUND {
ULONG cElements;
LONG lLbound;
} SAFEARRAYBOUND, *LPSAFEARRAYBOUND;
typedef [unique] struct _wireVARIANT *wireVARIANT;
typedef [unique] struct _wireBRECORD *wireBRECORD;
typedef struct _wireSAFEARR_BSTR {
ULONG Size;
[size_is(Size), ref] wireBSTR *aBstr;
} SAFEARR_BSTR;
typedef struct _wireSAFEARR_UNKNOWN {
ULONG Size;
[size_is(Size), ref] IUnknown **apUnknown;
} SAFEARR_UNKNOWN;
typedef struct _wireSAFEARR_DISPATCH {
ULONG Size;
[size_is(Size), ref] IDispatch **apDispatch;
} SAFEARR_DISPATCH;
typedef struct _wireSAFEARR_VARIANT {
ULONG Size;
[size_is(Size), ref] wireVARIANT *aVariant;
} SAFEARR_VARIANT;
typedef struct _wireSAFEARR_BRECORD {
ULONG Size;
[size_is(Size), ref] wireBRECORD *aRecord;
} SAFEARR_BRECORD;
typedef struct _wireSAFEARR_HAVEIID {
ULONG Size;
[size_is(Size), ref] IUnknown **apUnknown;
IID iid;
} SAFEARR_HAVEIID;
typedef [v1_enum] enum tagSF_TYPE {
SF_ERROR = VT_ERROR,
SF_I1 = VT_I1,
SF_I2 = VT_I2,
SF_I4 = VT_I4,
SF_I8 = VT_I8,
SF_BSTR = VT_BSTR,
SF_UNKNOWN = VT_UNKNOWN,
SF_DISPATCH = VT_DISPATCH,
SF_VARIANT = VT_VARIANT,
SF_RECORD = VT_RECORD,
SF_HAVEIID = VT_UNKNOWN|VT_RESERVED,
} SF_TYPE;
typedef union _wireSAFEARRAY_UNION switch(ULONG sfType) u {
case SF_BSTR: SAFEARR_BSTR BstrStr;
case SF_UNKNOWN: SAFEARR_UNKNOWN UnknownStr;
case SF_DISPATCH: SAFEARR_DISPATCH DispatchStr;
case SF_VARIANT: SAFEARR_VARIANT VariantStr;
case SF_RECORD: SAFEARR_BRECORD RecordStr;
case SF_HAVEIID: SAFEARR_HAVEIID HaveIidStr;
case SF_I1: BYTE_SIZEDARR ByteStr;
case SF_I2: WORD_SIZEDARR WordStr;
case SF_I4: DWORD_SIZEDARR LongStr;
case SF_I8: HYPER_SIZEDARR HyperStr;
} SAFEARRAYUNION;
typedef [unique] struct _wireSAFEARRAY {
USHORT cDims;
USHORT fFeatures;
ULONG cbElements;
ULONG cLocks;
SAFEARRAYUNION uArrayStructs;
[size_is(cDims)] SAFEARRAYBOUND rgsabound[];
} *wireSAFEARRAY;
typedef [unique] wireSAFEARRAY *wirePSAFEARRAY;
typedef struct tagSAFEARRAY {
USHORT cDims;
USHORT fFeatures;
ULONG cbElements;
ULONG cLocks;
PVOID pvData;
SAFEARRAYBOUND rgsabound[];
} SAFEARRAY;
typedef [wire_marshal(wirePSAFEARRAY)] SAFEARRAY *LPSAFEARRAY;
const USHORT FADF_AUTO = 0x0001;
const USHORT FADF_STATIC = 0x0002;
const USHORT FADF_EMBEDDED = 0x0004;
const USHORT FADF_FIXEDSIZE = 0x0010;
const USHORT FADF_RECORD = 0x0020;
const USHORT FADF_HAVEIID = 0x0040;
const USHORT FADF_HAVEVARTYPE = 0x0080;
const USHORT FADF_BSTR = 0x0100;
const USHORT FADF_UNKNOWN = 0x0200;
const USHORT FADF_DISPATCH = 0x0400;
const USHORT FADF_VARIANT = 0x0800;
const USHORT FADF_RESERVED = 0xF008;
/* Undocumented flags */
const USHORT FADF_DATADELETED = 0x1000; /* Data in a vector has been deleted */
const USHORT FADF_CREATEVECTOR = 0x2000; /* This array is a vector */
/* Variant */
cpp_quote("#ifdef NONAMELESSUNION")
cpp_quote("#define __VARIANT_NAME_1 n1")
cpp_quote("#define __VARIANT_NAME_2 n2")
cpp_quote("#define __VARIANT_NAME_3 n3")
cpp_quote("#define __VARIANT_NAME_4 brecVal")
cpp_quote("#else")
cpp_quote("#define __tagVARIANT")
cpp_quote("#define __VARIANT_NAME_1")
cpp_quote("#define __VARIANT_NAME_2")
cpp_quote("#define __VARIANT_NAME_3")
cpp_quote("#define __tagBRECORD")
cpp_quote("#define __VARIANT_NAME_4")
cpp_quote("#endif")
typedef [wire_marshal(wireVARIANT)] struct tagVARIANT VARIANT;
struct tagVARIANT {
union {
struct __tagVARIANT {
VARTYPE vt;
WORD wReserved1;
WORD wReserved2;
WORD wReserved3;
union {
signed char cVal;
USHORT uiVal;
ULONG ulVal;
INT intVal;
UINT uintVal;
BYTE bVal;
SHORT iVal;
LONG lVal;
FLOAT fltVal;
DOUBLE dblVal;
VARIANT_BOOL boolVal;
#if 0 /* illegal in C++ */
_VARIANT_BOOL bool;
#endif
SCODE scode;
DATE date;
BSTR bstrVal;
CY cyVal;
IUnknown *punkVal;
IDispatch *pdispVal;
SAFEARRAY *parray;
LONGLONG llVal;
ULONGLONG ullVal;
signed char *pcVal;
USHORT *puiVal;
ULONG *pulVal;
INT *pintVal;
UINT *puintVal;
BYTE *pbVal;
SHORT *piVal;
LONG *plVal;
FLOAT *pfltVal;
DOUBLE *pdblVal;
VARIANT_BOOL *pboolVal;
#if 0
_VARIANT_BOOL *pbool;
#endif
SCODE *pscode;
DATE *pdate;
BSTR *pbstrVal;
VARIANT *pvarVal;
PVOID byref;
CY *pcyVal;
DECIMAL *pdecVal;
IUnknown **ppunkVal;
IDispatch **ppdispVal;
SAFEARRAY **pparray;
LONGLONG *pllVal;
ULONGLONG *pullVal;
struct __tagBRECORD {
PVOID pvRecord;
IRecordInfo *pRecInfo;
} __VARIANT_NAME_4;
} __VARIANT_NAME_3;
} __VARIANT_NAME_2;
DECIMAL decVal;
} __VARIANT_NAME_1;
};
typedef VARIANT *LPVARIANT;
typedef VARIANT VARIANTARG;
typedef VARIANTARG *LPVARIANTARG;
cpp_quote("#if 0")
typedef const VARIANT *REFVARIANT;
cpp_quote("#elif !defined(_REFVARIANT_DEFINED)")
cpp_quote("#define _REFVARIANT_DEFINED")
cpp_quote("#ifdef __cplusplus")
cpp_quote("#define REFVARIANT const VARIANT &")
cpp_quote("#else")
cpp_quote("#define REFVARIANT const VARIANT *__MIDL_CONST")
cpp_quote("#endif")
cpp_quote("#endif")
struct _wireBRECORD {
ULONG fFlags;
ULONG clSize;
IRecordInfo *pRecInfo;
[size_is(clSize)] byte *pRecord;
};
struct _wireVARIANT {
DWORD clSize;
DWORD rpcReserved;
USHORT vt;
USHORT wReserved1;
USHORT wReserved2;
USHORT wReserved3;
[switch_is(vt)] union {
[case(VT_EMPTY, VT_NULL)] ;
[case(VT_I1)] signed char cVal;
[case(VT_UI2)] USHORT uiVal;
[case(VT_UI4)] ULONG ulVal;
[case(VT_INT)] INT intVal;
[case(VT_UINT)] UINT uintVal;
[case(VT_UI1)] BYTE bVal;
[case(VT_I2)] SHORT iVal;
[case(VT_I4)] LONG lVal;
[case(VT_R4)] FLOAT fltVal;
[case(VT_R8)] DOUBLE dblVal;
[case(VT_BOOL)] VARIANT_BOOL boolVal;
[case(VT_ERROR)] SCODE scode;
[case(VT_DATE)] DATE date;
[case(VT_BSTR)] wireBSTR bstrVal;
[case(VT_CY)] CY cyVal;
[case(VT_DECIMAL)] DECIMAL decVal;
[case(VT_UNKNOWN)] IUnknown *punkVal;
[case(VT_DISPATCH)] IDispatch *pdispVal;
[case(VT_ARRAY)] wireSAFEARRAY parray;
[case(VT_I1|VT_BYREF)] signed char *pcVal;
[case(VT_UI2|VT_BYREF)] USHORT *puiVal;
[case(VT_UI4|VT_BYREF)] ULONG *pulVal;
[case(VT_INT|VT_BYREF)] INT *pintVal;
[case(VT_UINT|VT_BYREF)] UINT *puintVal;
[case(VT_UI1|VT_BYREF)] BYTE *pbVal;
[case(VT_I2|VT_BYREF)] SHORT *piVal;
[case(VT_I4|VT_BYREF)] LONG *plVal;
[case(VT_R4|VT_BYREF)] FLOAT *pfltVal;
[case(VT_R8|VT_BYREF)] DOUBLE *pdblVal;
[case(VT_BOOL|VT_BYREF)] VARIANT_BOOL *pboolVal;
[case(VT_ERROR|VT_BYREF)] SCODE *pscode;
[case(VT_DATE|VT_BYREF)] DATE *pdate;
[case(VT_BSTR|VT_BYREF)] wireBSTR *pbstrVal;
[case(VT_VARIANT|VT_BYREF)] wireVARIANT *pvarVal;
[case(VT_CY|VT_BYREF)] CY *pcyVal;
[case(VT_DECIMAL|VT_BYREF)] DECIMAL *pdecVal;
[case(VT_UNKNOWN|VT_BYREF)] IUnknown **ppunkVal;
[case(VT_DISPATCH|VT_BYREF)] IDispatch **ppdispVal;
[case(VT_ARRAY|VT_BYREF)] wireSAFEARRAY *pparray;
[case(VT_RECORD, VT_RECORD|VT_BYREF)] wireBRECORD brecVal;
} DUMMYUNIONNAME;
};
/* Dispatch */
typedef LONG DISPID;
typedef DWORD HREFTYPE;
typedef DISPID MEMBERID;
typedef [v1_enum] enum tagTYPEKIND {
TKIND_ENUM = 0,
TKIND_RECORD,
TKIND_MODULE,
TKIND_INTERFACE,
TKIND_DISPATCH,
TKIND_COCLASS,
TKIND_ALIAS,
TKIND_UNION,
TKIND_MAX
} TYPEKIND;
typedef struct tagTYPEDESC {
[switch_is(vt)] union {
[case(VT_PTR, VT_SAFEARRAY)] struct tagTYPEDESC *lptdesc;
[case(VT_CARRAY)] struct tagARRAYDESC *lpadesc;
[case(VT_USERDEFINED)] HREFTYPE hreftype;
[default] ;
} DUMMYUNIONNAME;
VARTYPE vt;
} TYPEDESC;
typedef struct tagARRAYDESC {
TYPEDESC tdescElem;
USHORT cDims;
[size_is(cDims)] SAFEARRAYBOUND rgbounds[];
} ARRAYDESC;
typedef struct tagPARAMDESCEX {
ULONG cBytes;
VARIANTARG varDefaultValue;
} PARAMDESCEX, *LPPARAMDESCEX;
typedef struct tagPARAMDESC {
LPPARAMDESCEX pparamdescex;
USHORT wParamFlags;
} PARAMDESC, *LPPARAMDESC;
const USHORT PARAMFLAG_NONE = 0x00;
const USHORT PARAMFLAG_FIN = 0x01;
const USHORT PARAMFLAG_FOUT = 0x02;
const USHORT PARAMFLAG_FLCID = 0x04;
const USHORT PARAMFLAG_FRETVAL = 0x08;
const USHORT PARAMFLAG_FOPT = 0x10;
const USHORT PARAMFLAG_FHASDEFAULT = 0x20;
const USHORT PARAMFLAG_FHASCUSTDATA = 0x40;
typedef struct tagIDLDESC {
ULONG_PTR dwReserved;
USHORT wIDLFlags;
} IDLDESC, *LPIDLDESC;
const USHORT IDLFLAG_NONE = PARAMFLAG_NONE;
const USHORT IDLFLAG_FIN = PARAMFLAG_FIN;
const USHORT IDLFLAG_FOUT = PARAMFLAG_FOUT;
const USHORT IDLFLAG_FLCID = PARAMFLAG_FLCID;
const USHORT IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL;
cpp_quote("#if 0") /* for IDL only */
typedef struct tagELEMDESC {
TYPEDESC tdesc;
PARAMDESC paramdesc;
} ELEMDESC;
cpp_quote("#else") /* C/C++ defs */
cpp_quote("typedef struct tagELEMDESC {")
cpp_quote(" TYPEDESC tdesc;")
cpp_quote(" union {")
cpp_quote(" IDLDESC idldesc;")
cpp_quote(" PARAMDESC paramdesc;")
cpp_quote(" } DUMMYUNIONNAME;")
cpp_quote("} ELEMDESC, *LPELEMDESC;")
cpp_quote("#endif")
typedef struct tagTYPEATTR {
GUID guid;
LCID lcid;
DWORD dwReserved;
MEMBERID memidConstructor;
MEMBERID memidDestructor;
LPOLESTR lpstrSchema;
ULONG cbSizeInstance;
TYPEKIND typekind;
WORD cFuncs;
WORD cVars;
WORD cImplTypes;
WORD cbSizeVft;
WORD cbAlignment;
WORD wTypeFlags;
WORD wMajorVerNum;
WORD wMinorVerNum;
TYPEDESC tdescAlias;
IDLDESC idldescType;
} TYPEATTR, *LPTYPEATTR;
typedef struct tagDISPPARAMS {
[size_is(cArgs)] VARIANTARG *rgvarg;
[size_is(cNamedArgs)] DISPID *rgdispidNamedArgs;
UINT cArgs;
UINT cNamedArgs;
} DISPPARAMS;
cpp_quote("#if 0") /* for IDL only */
typedef struct tagEXCEPINFO {
WORD wCode;
WORD wReserved;
BSTR bstrSource;
BSTR bstrDescription;
BSTR bstrHelpFile;
DWORD dwHelpContext;
ULONG_PTR pvReserved;
ULONG_PTR pfnDeferredFillIn;
SCODE scode;
} EXCEPINFO;
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(" PVOID pvReserved;")
cpp_quote(" HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);")
cpp_quote(" SCODE scode;")
cpp_quote("} EXCEPINFO, *LPEXCEPINFO;")
cpp_quote("#endif")
typedef [v1_enum] enum tagCALLCONV {
CC_FASTCALL = 0,
CC_CDECL = 1,
CC_MSCPASCAL,
CC_PASCAL = CC_MSCPASCAL,
CC_MACPASCAL,
CC_STDCALL,
CC_FPFASTCALL,
CC_SYSCALL,
CC_MPWCDECL,
CC_MPWPASCAL,
CC_MAX
} CALLCONV;
typedef [v1_enum] enum tagFUNCKIND {
FUNC_VIRTUAL,
FUNC_PUREVIRTUAL,
FUNC_NONVIRTUAL,
FUNC_STATIC,
FUNC_DISPATCH
} FUNCKIND;
typedef [v1_enum] enum tagINVOKEKIND {
INVOKE_FUNC = 1,
INVOKE_PROPERTYGET = 2,
INVOKE_PROPERTYPUT = 4,
INVOKE_PROPERTYPUTREF = 8
} INVOKEKIND;
typedef struct tagFUNCDESC {
MEMBERID memid;
[size_is(cScodes)] SCODE *lprgscode;
[size_is(cParams)] ELEMDESC *lprgelemdescParam;
FUNCKIND funckind;
INVOKEKIND invkind;
CALLCONV callconv;
SHORT cParams;
SHORT cParamsOpt;
SHORT oVft;
SHORT cScodes;
ELEMDESC elemdescFunc;
WORD wFuncFlags;
} FUNCDESC, *LPFUNCDESC;
typedef [v1_enum] enum tagVARKIND {
VAR_PERINSTANCE,
VAR_STATIC,
VAR_CONST,
VAR_DISPATCH
} VARKIND;
const USHORT IMPLTYPEFLAG_FDEFAULT = 0x1;
const USHORT IMPLTYPEFLAG_FSOURCE = 0x2;
const USHORT IMPLTYPEFLAG_FRESTRICTED = 0x4;
const USHORT IMPLTYPEFLAG_FDEFAULTVTABLE = 0x8;
typedef struct tagVARDESC {
MEMBERID memid;
LPOLESTR lpstrSchema;
[switch_is(varkind)] union {
[case(VAR_PERINSTANCE, VAR_DISPATCH, VAR_STATIC)] ULONG oInst;
[case(VAR_CONST)] VARIANT *lpvarValue;
} DUMMYUNIONNAME;
ELEMDESC elemdescVar;
WORD wVarFlags;
VARKIND varkind;
} VARDESC, *LPVARDESC;
typedef enum tagTYPEFLAGS {
TYPEFLAG_FAPPOBJECT = 0x0001,
TYPEFLAG_FCANCREATE = 0x0002,
TYPEFLAG_FLICENSED = 0x0004,
TYPEFLAG_FPREDECLID = 0x0008,
TYPEFLAG_FHIDDEN = 0x0010,
TYPEFLAG_FCONTROL = 0x0020,
TYPEFLAG_FDUAL = 0x0040,
TYPEFLAG_FNONEXTENSIBLE = 0x0080,
TYPEFLAG_FOLEAUTOMATION = 0x0100,
TYPEFLAG_FRESTRICTED = 0x0200,
TYPEFLAG_FAGGREGATABLE = 0x0400,
TYPEFLAG_FREPLACEABLE = 0x0800,
TYPEFLAG_FDISPATCHABLE = 0x1000,
TYPEFLAG_FREVERSEBIND = 0x2000,
TYPEFLAG_FPROXY = 0x4000
} TYPEFLAGS;
typedef enum tagFUNCFLAGS {
FUNCFLAG_FRESTRICTED = 0x0001,
FUNCFLAG_FSOURCE = 0x0002,
FUNCFLAG_FBINDABLE = 0x0004,
FUNCFLAG_FREQUESTEDIT = 0x0008,
FUNCFLAG_FDISPLAYBIND = 0x0010,
FUNCFLAG_FDEFAULTBIND = 0x0020,
FUNCFLAG_FHIDDEN = 0x0040,
FUNCFLAG_FUSESGETLASTERROR = 0x0080,
FUNCFLAG_FDEFAULTCOLLELEM = 0x0100,
FUNCFLAG_FUIDEFAULT = 0x0200,
FUNCFLAG_FNONBROWSABLE = 0x0400,
FUNCFLAG_FREPLACEABLE = 0x0800,
FUNCFLAG_FIMMEDIATEBIND = 0x1000
} FUNCFLAGS;
typedef enum tagVARFLAGS {
VARFLAG_FREADONLY = 0x0001,
VARFLAG_FSOURCE = 0x0002,
VARFLAG_FBINDABLE = 0x0004,
VARFLAG_FREQUESTEDIT = 0x0008,
VARFLAG_FDISPLAYBIND = 0x0010,
VARFLAG_FDEFAULTBIND = 0x0020,
VARFLAG_FHIDDEN = 0x0040,
VARFLAG_FRESTRICTED = 0x0080,
VARFLAG_FDEFAULTCOLLELEM = 0x0100,
VARFLAG_FUIDEFAULT = 0x0200,
VARFLAG_FNONBROWSABLE = 0x0400,
VARFLAG_FREPLACEABLE = 0x0800,
VARFLAG_FIMMEDIATEBIND = 0x1000
} VARFLAGS;
typedef [wire_marshal(DWORD)] struct tagCLEANLOCALSTORAGE {
IUnknown *pInterface;
PVOID pStorage;
DWORD flags;
} CLEANLOCALSTORAGE;
typedef struct tagCUSTDATAITEM {
GUID guid;
VARIANTARG varValue;
} CUSTDATAITEM, *LPCUSTDATAITEM;
typedef struct tagCUSTDATA {
DWORD cCustData;
[size_is(cCustData)] LPCUSTDATAITEM prgCustData;
} CUSTDATA, *LPCUSTDATA;
} /* interface IOleAutomationTypes */
/******************** INTERFACES ********************/
[
object,
uuid(00020400-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IDispatch : IUnknown
{
typedef [unique] IDispatch *LPDISPATCH;
const DISPID DISPID_UNKNOWN = -1;
const DISPID DISPID_VALUE = 0;
const DISPID DISPID_PROPERTYPUT = -3;
const DISPID DISPID_NEWENUM = -4;
const DISPID DISPID_EVALUATE = -5;
const DISPID DISPID_CONSTRUCTOR = -6;
const DISPID DISPID_DESTRUCTOR = -7;
const DISPID DISPID_COLLECT = -8;
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,
[out, size_is(cNames)] DISPID *rgDispId);
[local]
HRESULT Invoke(
[in] DISPID dispIdMember,
[in] REFIID riid,
[in] LCID lcid,
[in] WORD wFlags,
[in, out] DISPPARAMS *pDispParams,
[out] VARIANT *pVarResult,
[out] EXCEPINFO *pExcepInfo,
[out] UINT *puArgErr);
[call_as(Invoke)]
HRESULT RemoteInvoke(
[in] DISPID dispIdMember,
[in] REFIID riid,
[in] LCID lcid,
[in] DWORD dwFlags,
[in] DISPPARAMS *pDispParams,
[out] VARIANT *pVarResult,
[out] EXCEPINFO *pExcepInfo,
[out] UINT *pArgErr,
[in] UINT cVarRef,
[in, size_is(cVarRef)] UINT *rgVarRefIdx,
[in, out, size_is(cVarRef)] VARIANTARG *rgVarRef);
}
[
object,
uuid(00020404-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface IEnumVARIANT : IUnknown
{
typedef [unique] IEnumVARIANT *LPENUMVARIANT;
[local]
HRESULT Next(
[in] ULONG celt,
[out] VARIANT *rgVar,
[out] ULONG *pCeltFetched);
[call_as(Next)]
HRESULT RemoteNext(
[in] ULONG celt,
[out, size_is(celt), length_is(*pCeltFetched)]
VARIANT *rgVar,
[out] ULONG *pCeltFetched);
HRESULT Skip(
[in] ULONG celt);
HRESULT Reset();
HRESULT Clone(
[out] IEnumVARIANT **ppEnum);
}
[
object,
uuid(00020403-0000-0000-C000-000000000046),
pointer_default(unique)
]
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;
typedef union tagBINDPTR {
FUNCDESC *lpfuncdesc;
VARDESC *lpvardesc;
ITypeComp *lptcomp;
} BINDPTR, *LPBINDPTR;
[local]
HRESULT Bind(
[in] LPOLESTR szName,
[in] ULONG lHashVal,
[in] WORD wFlags,
[out] ITypeInfo **ppTInfo,
[out] DESCKIND *pDescKind,
[out] BINDPTR *pBindPtr);
[call_as(Bind)]
HRESULT RemoteBind(
[in] LPOLESTR szName,
[in] ULONG lHashVal,
[in] WORD wFlags,
[out] ITypeInfo **ppTInfo,
[out] DESCKIND *pDescKind,
[out] LPFUNCDESC *ppFuncDesc,
[out] LPVARDESC *ppVarDesc,
[out] ITypeComp **ppTypeComp,
[out] CLEANLOCALSTORAGE *pDummy);
[local]
HRESULT BindType(
[in] LPOLESTR szName,
[in] ULONG lHashVal,
[out] ITypeInfo **ppTInfo,
[out] ITypeComp **ppTComp);
[call_as(BindType)]
HRESULT RemoteBindType(
[in] LPOLESTR szName,
[in] ULONG lHashVal,
[out] ITypeInfo **ppTInfo);
}
[
object,
uuid(00020401-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ITypeInfo : IUnknown
{
typedef [unique] ITypeInfo *LPTYPEINFO;
[local]
HRESULT GetTypeAttr(
[out] TYPEATTR **ppTypeAttr);
[call_as(GetTypeAttr)]
HRESULT RemoteGetTypeAttr(
[out] LPTYPEATTR *ppTypeAttr,
[out] CLEANLOCALSTORAGE *pDummy);
HRESULT GetTypeComp(
[out] ITypeComp **ppTComp);
[local]
HRESULT GetFuncDesc(
[in] UINT index,
[out] FUNCDESC **ppFuncDesc);
[call_as(GetFuncDesc)]
HRESULT RemoteGetFuncDesc(
[in] UINT index,
[out] LPFUNCDESC *ppFuncDesc,
[out] CLEANLOCALSTORAGE *pDummy);
[local]
HRESULT GetVarDesc(
[in] UINT index,
[out] VARDESC **ppVarDesc);
[call_as(GetVarDesc)]
HRESULT RemoteGetVarDesc(
[in] UINT index,
[out] LPVARDESC *ppVarDesc,
[out] CLEANLOCALSTORAGE *pDummy);
[local]
HRESULT GetNames(
[in] MEMBERID memid,
[out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames,
[in] UINT cMaxNames,
[out] UINT *pcNames);
[call_as(GetNames)]
HRESULT RemoteGetNames(
[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 *pRefType);
HRESULT GetImplTypeFlags(
[in] UINT index,
[out] INT *pImplTypeFlags);
[local]
HRESULT GetIDsOfNames(
[in, size_is(cNames)] LPOLESTR *rgszNames,
[in] UINT cNames,
[out, size_is(cNames)] MEMBERID *pMemId);
[call_as(GetIDsOfNames)]
HRESULT LocalGetIDsOfNames();
[local]
HRESULT Invoke(
[in] PVOID pvInstance,
[in] MEMBERID memid,
[in] WORD wFlags,
[in, out] DISPPARAMS *pDispParams,
[out] VARIANT *pVarResult,
[out] EXCEPINFO *pExcepInfo,
[out] UINT *puArgErr);
[call_as(Invoke)]
HRESULT LocalInvoke();
[local]
HRESULT GetDocumentation(
[in] MEMBERID memid,
[out] BSTR *pBstrName,
[out] BSTR *pBstrDocString,
[out] DWORD *pdwHelpContext,
[out] BSTR *pBstrHelpFile);
[call_as(GetDocumentation)]
HRESULT RemoteGetDocumentation(
[in] MEMBERID memid,
[in] DWORD refPtrFlags,
[out] BSTR *pBstrName,
[out] BSTR *pBstrDocString,
[out] DWORD *pdwHelpContext,
[out] BSTR *pBstrHelpFile);
[local]
HRESULT GetDllEntry(
[in] MEMBERID memid,
[in] INVOKEKIND invKind,
[out] BSTR *pBstrDllName,
[out] BSTR *pBstrName,
[out] WORD *pwOrdinal);
[call_as(GetDllEntry)]
HRESULT RemoteGetDllEntry(
[in] MEMBERID memid,
[in] INVOKEKIND invKind,
[in] DWORD refPtrFlags,
[out] BSTR *pBstrDllName,
[out] BSTR *pBstrName,
[out] WORD *pwOrdinal);
HRESULT GetRefTypeInfo(
[in] HREFTYPE hRefType,
[out] ITypeInfo **ppTInfo);
[local]
HRESULT AddressOfMember(
[in] MEMBERID memid,
[in] INVOKEKIND invKind,
[out] PVOID *ppv);
[call_as(AddressOfMember)]
HRESULT LocalAddressOfMember();
[local]
HRESULT CreateInstance(
[in] IUnknown *pUnkOuter,
[in] REFIID riid,
[out, iid_is(riid)] PVOID *ppvObj);
[call_as(CreateInstance)]
HRESULT RemoteCreateInstance(
[in] REFIID riid,
[out, iid_is(riid)] IUnknown **ppvObj);
HRESULT GetMops(
[in] MEMBERID memid,
[out] BSTR *pBstrMops);
[local]
HRESULT GetContainingTypeLib(
[out] ITypeLib **ppTLib,
[out] UINT *pIndex);
[call_as(GetContainingTypeLib)]
HRESULT RemoteGetContainingTypeLib(
[out] ITypeLib **ppTLib,
[out] UINT *pIndex);
[local]
void ReleaseTypeAttr(
[in] TYPEATTR *pTypeAttr);
[call_as(ReleaseTypeAttr)]
HRESULT LocalReleaseTypeAttr();
[local]
void ReleaseFuncDesc(
[in] FUNCDESC *pFuncDesc);
[call_as(ReleaseFuncDesc)]
HRESULT LocalReleaseFuncDesc();
[local]
void ReleaseVarDesc(
[in] VARDESC *pVarDesc);
[call_as(ReleaseVarDesc)]
HRESULT LocalReleaseVarDesc();
}
[
object,
uuid(00020412-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ITypeInfo2 : ITypeInfo
{
typedef [unique] ITypeInfo2 *LPTYPEINFO2;
HRESULT GetTypeKind(
[out] TYPEKIND *pTypeKind);
HRESULT GetTypeFlags(
[out] ULONG *pTypeFlags);
HRESULT GetFuncIndexOfMemId(
[in] MEMBERID memid,
[in] INVOKEKIND invKind,
[out] UINT *pFuncIndex);
HRESULT GetVarIndexOfMemId(
[in] MEMBERID memid,
[out] UINT *pVarIndex);
HRESULT GetCustData(
[in] REFGUID guid,
[out] VARIANT *pVarVal);
HRESULT GetFuncCustData(
[in] UINT index,
[in] REFGUID guid,
[out] VARIANT *pVarVal);
HRESULT GetParamCustData(
[in] UINT indexFunc,
[in] UINT indexParam,
[in] REFGUID guid,
[out] VARIANT *pVarVal);
HRESULT GetVarCustData(
[in] UINT index,
[in] REFGUID guid,
[out] VARIANT *pVarVal);
HRESULT GetImplTypeCustData(
[in] UINT index,
[in] REFGUID guid,
[out] VARIANT *pVarVal);
[local]
HRESULT GetDocumentation2(
[in] MEMBERID memid,
[in] LCID lcid,
[out] BSTR *pbstrHelpString,
[out] DWORD *pdwHelpStringContext,
[out] BSTR *pbstrHelpStringDll);
[call_as(GetDocumentation2)]
HRESULT RemoteGetDocumentation2(
[in] MEMBERID memid,
[in] LCID lcid,
[in] DWORD refPtrFlags,
[out] BSTR *pbstrHelpString,
[out] DWORD *pdwHelpStringContext,
[out] BSTR *pbstrHelpStringDll);
HRESULT GetAllCustData(
[out] CUSTDATA *pCustData);
HRESULT GetAllFuncCustData(
[in] UINT index,
[out] CUSTDATA *pCustData);
HRESULT GetAllParamCustData(
[in] UINT indexFunc,
[in] UINT indexParam,
[out] CUSTDATA *pCustData);
HRESULT GetAllVarCustData(
[in] UINT index,
[out] CUSTDATA *pCustData);
HRESULT GetAllImplTypeCustData(
[in] UINT index,
[out] CUSTDATA *pCustData);
}
[
object,
uuid(00020402-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ITypeLib : IUnknown
{
typedef [unique] ITypeLib *LPTYPELIB;
typedef [v1_enum] enum tagSYSKIND {
SYS_WIN16 = 0,
SYS_WIN32,
SYS_MAC,
SYS_WIN64
} SYSKIND;
typedef [v1_enum] enum tagLIBFLAGS {
LIBFLAG_FRESTRICTED = 0x01,
LIBFLAG_FCONTROL = 0x02,
LIBFLAG_FHIDDEN = 0x04,
LIBFLAG_FHASDISKIMAGE = 0x08
} LIBFLAGS;
typedef struct tagTLIBATTR {
GUID guid;
LCID lcid;
SYSKIND syskind;
WORD wMajorVerNum;
WORD wMinorVerNum;
WORD wLibFlags;
} TLIBATTR, *LPTLIBATTR;
[local]
UINT GetTypeInfoCount();
[call_as(GetTypeInfoCount)]
HRESULT RemoteGetTypeInfoCount(
[out] UINT *pcTInfo);
HRESULT GetTypeInfo(
[in] UINT index,
[out] ITypeInfo **ppTInfo);
HRESULT GetTypeInfoType(
[in] UINT index,
[out] TYPEKIND *pTKind);
HRESULT GetTypeInfoOfGuid(
[in] REFGUID guid,
[out] ITypeInfo **ppTinfo);
[local]
HRESULT GetLibAttr(
[out] TLIBATTR **ppTLibAttr);
[call_as(GetLibAttr)]
HRESULT RemoteGetLibAttr(
[out] LPTLIBATTR *ppTLibAttr,
[out] CLEANLOCALSTORAGE *pDummy);
HRESULT GetTypeComp(
[out] ITypeComp **ppTComp);
[local]
HRESULT GetDocumentation(
[in] INT index,
[out] BSTR *pBstrName,
[out] BSTR *pBstrDocString,
[out] DWORD *pdwHelpContext,
[out] BSTR *pBstrHelpFile);
[call_as(GetDocumentation)]
HRESULT RemoteGetDocumentation(
[in] INT index,
[in] DWORD refPtrFlags,
[out] BSTR *pBstrName,
[out] BSTR *pBstrDocString,
[out] DWORD *pdwHelpContext,
[out] BSTR *pBstrHelpFile);
[local]
HRESULT IsName(
[in, out] LPOLESTR szNameBuf,
[in] ULONG lHashVal,
[out] BOOL *pfName);
[call_as(IsName)]
HRESULT RemoteIsName(
[in] LPOLESTR szNameBuf,
[in] ULONG lHashVal,
[out] BOOL *pfName,
[out] BSTR *pBstrLibName);
[local]
HRESULT FindName(
[in, out] LPOLESTR szNameBuf,
[in] ULONG lHashVal,
[out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
[out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
[in, out] USHORT *pcFound);
[call_as(FindName)]
HRESULT RemoteFindName(
[in] LPOLESTR szNameBuf,
[in] ULONG lHashVal,
[out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo,
[out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId,
[in, out] USHORT *pcFound,
[out] BSTR *pBstrLibName);
[local]
void ReleaseTLibAttr(
[in] TLIBATTR *pTLibAttr);
[call_as(ReleaseTLibAttr)]
HRESULT LocalReleaseTLibAttr();
}
[
object,
uuid(00020411-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ITypeLib2 : ITypeLib
{
typedef [unique] ITypeLib2 *LPTYPELIB2;
HRESULT GetCustData(
[in] REFGUID guid,
[out] VARIANT *pVarVal);
[local]
HRESULT GetLibStatistics(
[out] ULONG *pcUniqueNames,
[out] ULONG *pcchUniqueNames);
[call_as(GetLibStatistics)]
HRESULT RemoteGetLibStatistics(
[out] ULONG *pcUniqueNames,
[out] ULONG *pcchUniqueNames);
[local]
HRESULT GetDocumentation2(
[in] INT index,
[in] LCID lcid,
[out] BSTR *pbstrHelpString,
[out] DWORD *pdwHelpStringContext,
[out] BSTR *pbstrHelpStringDll);
[call_as(GetDocumentation2)]
HRESULT RemoteGetDocumentation2(
[in] INT index,
[in] LCID lcid,
[in] DWORD refPtrFlags,
[out] BSTR *pbstrHelpString,
[out] DWORD *pdwHelpStringContext,
[out] BSTR *pbstrHelpStringDll);
HRESULT GetAllCustData(
[out] CUSTDATA *pCustData);
}
[
local,
object,
uuid(00020410-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ITypeChangeEvents : IUnknown
{
typedef [unique] ITypeChangeEvents *LPTYPECHANGEEVENTS;
typedef enum tagCHANGEKIND {
CHANGEKIND_ADDMEMBER,
CHANGEKIND_DELETEMEMBER,
CHANGEKIND_SETNAMES,
CHANGEKIND_SETDOCUMENTATION,
CHANGEKIND_GENERAL,
CHANGEKIND_INVALIDATE,
CHANGEKIND_CHANGEFAILED,
CHANGEKIND_MAX
} CHANGEKIND;
HRESULT RequestTypeChange(
[in] CHANGEKIND changeKind,
[in] ITypeInfo *pTInfoBefore,
[in] LPOLESTR pStrName,
[out] INT *pfCancel);
HRESULT AfterTypeChange(
[in] CHANGEKIND changeKind,
[in] ITypeInfo *pTInfoAfter,
[in] LPOLESTR pStrName);
}
[
object,
uuid(1CF2B120-547D-101B-8E65-08002B2BD119),
pointer_default(unique)
]
interface IErrorInfo : IUnknown
{
typedef [unique] IErrorInfo *LPERRORINFO;
HRESULT GetGUID(
[out] GUID *pGUID);
HRESULT GetSource(
[out] BSTR *pBstrSource);
HRESULT GetDescription(
[out] BSTR *pBstrDescription);
HRESULT GetHelpFile(
[out] BSTR *pBstrHelpFile);
HRESULT GetHelpContext(
[out] DWORD *pdwHelpContext);
}
[
object,
uuid(22F03340-547D-101B-8E65-08002B2BD119),
pointer_default(unique)
]
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)
]
interface ISupportErrorInfo : IUnknown
{
typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO;
HRESULT InterfaceSupportsErrorInfo(
[in] REFIID riid);
}
[
object,
uuid(0000002E-0000-0000-C000-000000000046)
]
interface ITypeFactory : IUnknown
{
HRESULT CreateFromTypeInfo(
[in] ITypeInfo *pTypeInfo,
[in] REFIID riid,
[out, iid_is(riid)] IUnknown **ppv);
}
[
local,
object,
uuid(0000002D-0000-0000-C000-000000000046)
]
interface ITypeMarshal : IUnknown
{
HRESULT Size(
[in] PVOID pvType,
[in] DWORD dwDestContext,
[in] PVOID pvDestContext,
[out] ULONG *pSize);
HRESULT Marshal(
[in] PVOID pvType,
[in] DWORD dwDestContext,
[in] PVOID pvDestContext,
[in] ULONG cbBufferLength,
[out] BYTE *pBuffer,
[out] ULONG *pcbWritten);
HRESULT Unmarshal(
[out] PVOID pvType,
[in] DWORD dwFlags,
[in] ULONG cbBufferLength,
[in] BYTE *pBuffer,
[out] ULONG *pcbRead);
HRESULT Free(
[in] PVOID pvType);
}
[
local,
object,
uuid(0000002F-0000-0000-C000-000000000046)
]
interface IRecordInfo : IUnknown
{
typedef [unique] IRecordInfo *LPRECORDINFO;
HRESULT RecordInit(
[out] PVOID pvNew);
HRESULT RecordClear(
[in] PVOID pvExisting);
HRESULT RecordCopy(
[in] PVOID pvExisting,
[out] PVOID pvNew);
HRESULT GetGuid(
[out] GUID *pguid);
HRESULT GetName(
[out] BSTR *pbstrName);
HRESULT GetSize(
[out] ULONG *pcbSize);
HRESULT GetTypeInfo(
[out] ITypeInfo **ppTypeInfo);
HRESULT GetField(
[in] PVOID pvData,
[in] LPCOLESTR szFieldName,
[out] VARIANT *pvarField);
HRESULT GetFieldNoCopy(
[in] PVOID pvData,
[in] LPCOLESTR szFieldName,
[out] VARIANT *pvarField,
[out] PVOID *ppvDataCArray);
HRESULT PutField(
[in] ULONG wFlags,
[in, out] PVOID pvData,
[in] LPCOLESTR szFieldName,
[in] VARIANT *pvarField);
HRESULT PutFieldNoCopy(
[in] ULONG wFlags,
[in, out] PVOID pvData,
[in] LPCOLESTR szFieldName,
[in] VARIANT *pvarField);
HRESULT GetFieldNames(
[in, out] ULONG *pcNames,
[out, size_is(*pcNames), length_is(*pcNames)] BSTR *rgBstrNames);
BOOL IsMatchingType(
[in] IRecordInfo *pRecordInfo);
PVOID RecordCreate();
HRESULT RecordCreateCopy(
[in] PVOID pvSource,
[out] PVOID *ppvDest);
HRESULT RecordDestroy(
[in] PVOID pvRecord);
}
[
local,
object,
uuid(00020405-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ICreateTypeInfo : IUnknown
{
typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO;
HRESULT SetGuid(
[in] REFGUID guid);
HRESULT SetTypeFlags(
[in] UINT uTypeFlags);
HRESULT SetDocString(
[in] LPOLESTR pStrDoc);
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 pStrSchema);
HRESULT AddVarDesc(
[in] UINT index,
[in] VARDESC *pVarDesc);
HRESULT SetFuncAndParamNames(
[in] UINT index,
[in, size_is(cNames)] 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();
}
[
local,
object,
uuid(0002040E-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ICreateTypeInfo2 : ICreateTypeInfo
{
typedef [unique] ICreateTypeInfo2 *LPCREATETYPEINFO2;
HRESULT DeleteFuncDesc(
[in] UINT index);
HRESULT DeleteFuncDescByMemId(
[in] MEMBERID memid,
[in] INVOKEKIND invKind);
HRESULT DeleteVarDesc(
[in] UINT index);
HRESULT DeleteVarDescByMemId(
[in] MEMBERID memid);
HRESULT DeleteImplType(
[in] UINT index);
HRESULT SetCustData(
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetFuncCustData(
[in] UINT index,
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetParamCustData(
[in] UINT indexFunc,
[in] UINT indexParam,
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetVarCustData(
[in] UINT index,
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetImplTypeCustData(
[in] UINT index,
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetHelpStringContext(
[in] ULONG dwHelpStringContext);
HRESULT SetFuncHelpStringContext(
[in] UINT index,
[in] ULONG dwHelpStringContext);
HRESULT SetVarHelpStringContext(
[in] UINT index,
[in] ULONG dwHelpStringContext);
HRESULT Invalidate();
HRESULT SetName(
[in] LPOLESTR szName);
}
[
local,
object,
uuid(00020406-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ICreateTypeLib : IUnknown
{
typedef [unique] ICreateTypeLib *LPCREATETYPELIB;
HRESULT CreateTypeInfo(
[in] LPOLESTR szName,
[in] TYPEKIND tkind,
[out] ICreateTypeInfo **ppCTInfo);
HRESULT SetName(
[in] 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();
}
[
local,
object,
uuid(0002040F-0000-0000-C000-000000000046),
pointer_default(unique)
]
interface ICreateTypeLib2 : ICreateTypeLib
{
typedef [unique] ICreateTypeLib2 *LPCREATETYPELIB2;
HRESULT DeleteTypeInfo(
[in] LPOLESTR szName);
HRESULT SetCustData(
[in] REFGUID guid,
[in] VARIANT *pVarVal);
HRESULT SetHelpStringContext(
[in] ULONG dwHelpStringContext);
HRESULT SetHelpStringDll(
[in] LPOLESTR szFileName);
}
/*****************************************************************************
* IErrorLog interface
*/
[
object,
uuid(3127ca40-446e-11ce-8135-00aa004bb851),
pointer_default(unique)
]
interface IErrorLog : IUnknown
{
typedef IErrorLog *LPERRORLOG;
HRESULT AddError(
[in] LPCOLESTR pszPropName,
[in] EXCEPINFO *pExcepInfo);
}
/*****************************************************************************
* IPropertyBag interface
*/
[
object,
uuid(55272a00-42cb-11ce-8135-00aa004bb851),
pointer_default(unique)
]
interface IPropertyBag : IUnknown
{
typedef IPropertyBag *LPPROPERTYBAG;
[local]
HRESULT Read(
[in] LPCOLESTR pszPropName,
[in, out] VARIANT *pVar,
[in] IErrorLog *pErrorLog);
[call_as(Read)]
HRESULT RemoteRead(
[in] LPCOLESTR pszPropName,
[out] VARIANT *pVar,
[in] IErrorLog *pErrorLog,
[in] DWORD varType,
[in] IUnknown *pUnkObj);
HRESULT Write(
[in] LPCOLESTR pszPropName,
[in] VARIANT *pVar);
}
Reference in a new issue View git blame Copy permalink