//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1995. // // File: oleauto.h // // Contents: Defines the Ole Automation interfaces and APIs. // // Interfaces: // IDispatch; // ITypeInfo; // ITypeLib; // ITypeComp; // ICreateTypeInfo; // ICreateTypeLib; // IErrorInfo; // ICreateErrorInfo; // ISupportErrorInfo; // // Functions: SysAllocString BSTR API // SysReAllocString // SysAllocStringLen // SysReAllocStringLen // SysFreeString // SysStringLen // DosDateTimeToVariantTime Time API // VariantTimeToDosDateTime // SafeArrayCreate Safe Array API // SafeArrayDestroy // SafeArrayGetDim // SafeArrayGetElemsize // SafeArrayGetUBound // SafeArrayGetLBound // SafeArrayLock // SafeArrayUnlock // SafeArrayAccessData // SafeArrayUnaccessData // SafeArrayGetElement // SafeArrayPutElement // SafeArrayCopy // VariantInit Variant API // VariantClear // VariantCopy // VariantCopyInd // VariantChangeType // LHashValOfName TypeInfo API // LoadTypeLib // LoadRegTypeLib // RegisterTypeLib // DeregisterTypeLib // CreateTypeLib // DispGetParam Dispatch API // DispGetIDsOfNames // DispInvoke // CreateDispTypeInfo // CreateStdDispatch // RegisterActiveObject Active Object Registration API // RevokeActiveObject // GetActiveObject // OaBuildVersion // //---------------------------------------------------------------------------- #if !defined( _OLEAUTO_H_ ) #define _OLEAUTO_H_ // Set packing to 8 for ISV, and Win95 support #ifndef RC_INVOKED #include #endif // RC_INVOKED // Definition of the OLE Automation APIs, and macros. #ifdef _OLEAUT32_ #define WINOLEAUTAPI STDAPI #define WINOLEAUTAPI_(type) STDAPI_(type) #else #define WINOLEAUTAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE #define WINOLEAUTAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE #endif #define STDOLE_MAJORVERNUM 0x1 #define STDOLE_MINORVERNUM 0x0 #define STDOLE_LCID 0x0000 /* if not already picked up from olenls.h */ #ifndef _LCID_DEFINED typedef DWORD LCID; # define _LCID_DEFINED #endif /* pull in the MIDL generated header */ #include /*---------------------------------------------------------------------*/ /* BSTR API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI_(BSTR) SysAllocString(const OLECHAR FAR*); WINOLEAUTAPI_(int) SysReAllocString(BSTR FAR*, const OLECHAR FAR*); WINOLEAUTAPI_(BSTR) SysAllocStringLen(const OLECHAR FAR*, unsigned int); WINOLEAUTAPI_(int) SysReAllocStringLen(BSTR FAR*, const OLECHAR FAR*, unsigned int); WINOLEAUTAPI_(void) SysFreeString(BSTR); WINOLEAUTAPI_(unsigned int) SysStringLen(BSTR); #ifdef _WIN32 WINOLEAUTAPI_(unsigned int) SysStringByteLen(BSTR bstr); WINOLEAUTAPI_(BSTR) SysAllocStringByteLen(const char FAR* psz, unsigned int len); #endif /*---------------------------------------------------------------------*/ /* Time API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI_(int) DosDateTimeToVariantTime( unsigned short wDosDate, unsigned short wDosTime, double FAR* pvtime); WINOLEAUTAPI_(int) VariantTimeToDosDateTime( double vtime, unsigned short FAR* pwDosDate, unsigned short FAR* pwDosTime); /*---------------------------------------------------------------------*/ /* SafeArray API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI SafeArrayAllocDescriptor(unsigned int cDims, SAFEARRAY FAR* FAR* ppsaOut); WINOLEAUTAPI SafeArrayAllocData(SAFEARRAY FAR* psa); WINOLEAUTAPI_(SAFEARRAY FAR*) SafeArrayCreate( VARTYPE vt, unsigned int cDims, SAFEARRAYBOUND FAR* rgsabound); WINOLEAUTAPI SafeArrayDestroyDescriptor(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayDestroyData(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayDestroy(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew); WINOLEAUTAPI_(unsigned int) SafeArrayGetDim(SAFEARRAY FAR* psa); WINOLEAUTAPI_(unsigned int) SafeArrayGetElemsize(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound); WINOLEAUTAPI SafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound); WINOLEAUTAPI SafeArrayLock(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayUnlock(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData); WINOLEAUTAPI SafeArrayUnaccessData(SAFEARRAY FAR* psa); WINOLEAUTAPI SafeArrayGetElement( SAFEARRAY FAR* psa, long FAR* rgIndices, void FAR* pv); WINOLEAUTAPI SafeArrayPutElement( SAFEARRAY FAR* psa, long FAR* rgIndices, void FAR* pv); WINOLEAUTAPI SafeArrayCopy( SAFEARRAY FAR* psa, SAFEARRAY FAR* FAR* ppsaOut); WINOLEAUTAPI SafeArrayPtrOfIndex( SAFEARRAY FAR* psa, long FAR* rgIndices, void HUGEP* FAR* ppvData); /*---------------------------------------------------------------------*/ /* VARIANT API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI_(void) VariantInit(VARIANTARG FAR* pvarg); WINOLEAUTAPI VariantClear(VARIANTARG FAR* pvarg); WINOLEAUTAPI VariantCopy( VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvargSrc); WINOLEAUTAPI VariantCopyInd( VARIANT FAR* pvarDest, VARIANTARG FAR* pvargSrc); WINOLEAUTAPI VariantChangeType( VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvarSrc, unsigned short wFlags, VARTYPE vt); WINOLEAUTAPI VariantChangeTypeEx( VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvarSrc, LCID lcid, unsigned short wFlags, VARTYPE vt); #define VARIANT_NOVALUEPROP 1 /*---------------------------------------------------------------------*/ /* VARTYPE Coercion API */ /*---------------------------------------------------------------------*/ /* Note: The routines that convert *from* a string are defined * to take a OLECHAR* rather than a BSTR because no allocation is * required, and this makes the routines a bit more generic. * They may of course still be passed a BSTR as the strIn param. */ /* Any of the coersion functions that converts either from or to a string * takes an additional lcid and dwFlags arguments. The lcid argument allows * locale specific parsing to occur. The dwFlags allow additional function * specific condition to occur. All function that accept the dwFlags argument * can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the * VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and * VAR_DATEVALUEONLY flags */ #define VAR_TIMEVALUEONLY 0x0001 /* return time value */ #define VAR_DATEVALUEONLY 0x0002 /* return date value */ WINOLEAUTAPI VarUI1FromI2(short sIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromI4(long lIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromR4(float fltIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromR8(double dblIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromCy(CY cyIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromDate(DATE dateIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned char FAR* pbOut); WINOLEAUTAPI VarUI1FromBool(VARIANT_BOOL boolIn, unsigned char FAR* pbOut); WINOLEAUTAPI VarI2FromUI1(unsigned char bIn, short FAR* psOut); WINOLEAUTAPI VarI2FromI4(long lIn, short FAR* psOut); WINOLEAUTAPI VarI2FromR4(float fltIn, short FAR* psOut); WINOLEAUTAPI VarI2FromR8(double dblIn, short FAR* psOut); WINOLEAUTAPI VarI2FromCy(CY cyIn, short FAR* psOut); WINOLEAUTAPI VarI2FromDate(DATE dateIn, short FAR* psOut); WINOLEAUTAPI VarI2FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, short FAR* psOut); WINOLEAUTAPI VarI2FromDisp(IDispatch FAR* pdispIn, LCID lcid, short FAR* psOut); WINOLEAUTAPI VarI2FromBool(VARIANT_BOOL boolIn, short FAR* psOut); WINOLEAUTAPI VarI4FromUI1(unsigned char bIn, long FAR* plOut); WINOLEAUTAPI VarI4FromI2(short sIn, long FAR* plOut); WINOLEAUTAPI VarI4FromR4(float fltIn, long FAR* plOut); WINOLEAUTAPI VarI4FromR8(double dblIn, long FAR* plOut); WINOLEAUTAPI VarI4FromCy(CY cyIn, long FAR* plOut); WINOLEAUTAPI VarI4FromDate(DATE dateIn, long FAR* plOut); WINOLEAUTAPI VarI4FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, long FAR* plOut); WINOLEAUTAPI VarI4FromDisp(IDispatch FAR* pdispIn, LCID lcid, long FAR* plOut); WINOLEAUTAPI VarI4FromBool(VARIANT_BOOL boolIn, long FAR* plOut); WINOLEAUTAPI VarR4FromUI1(unsigned char bIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromI2(short sIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromI4(long lIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromR8(double dblIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromCy(CY cyIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromDate(DATE dateIn, float FAR* pfltOut); WINOLEAUTAPI VarR4FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, float FAR* pfltOut); WINOLEAUTAPI VarR4FromDisp(IDispatch FAR* pdispIn, LCID lcid, float FAR* pfltOut); WINOLEAUTAPI VarR4FromBool(VARIANT_BOOL boolIn, float FAR* pfltOut); WINOLEAUTAPI VarR8FromUI1(unsigned char bIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromI2(short sIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromI4(long lIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromR4(float fltIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromCy(CY cyIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromDate(DATE dateIn, double FAR* pdblOut); WINOLEAUTAPI VarR8FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, double FAR* pdblOut); WINOLEAUTAPI VarR8FromDisp(IDispatch FAR* pdispIn, LCID lcid, double FAR* pdblOut); WINOLEAUTAPI VarR8FromBool(VARIANT_BOOL boolIn, double FAR* pdblOut); WINOLEAUTAPI VarDateFromUI1(unsigned char bIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromI2(short sIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromI4(long lIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromR4(float fltIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromR8(double dblIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromCy(CY cyIn, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromDisp(IDispatch FAR* pdispIn, LCID lcid, DATE FAR* pdateOut); WINOLEAUTAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE FAR* pdateOut); WINOLEAUTAPI VarCyFromUI1(unsigned char bIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromI2(short sIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromI4(long lIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromR4(float fltIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromR8(double dblIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromDate(DATE dateIn, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromDisp(IDispatch FAR* pdispIn, LCID lcid, CY FAR* pcyOut); WINOLEAUTAPI VarCyFromBool(VARIANT_BOOL boolIn, CY FAR* pcyOut); WINOLEAUTAPI VarBstrFromUI1(unsigned char bVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromI2(short iVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromI4(long lIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromR4(float fltIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromR8(double dblIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut); WINOLEAUTAPI VarBoolFromUI1(unsigned char bIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromI2(short sIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromI4(long lIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromR4(float fltIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromR8(double dblIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, VARIANT_BOOL FAR* pboolOut); WINOLEAUTAPI VarBoolFromDisp(IDispatch FAR* pdispIn, LCID lcid, VARIANT_BOOL FAR* pboolOut); /* Mac Note: On the Mac, the coersion functions support the * Symantec C++ calling convention for float/double. To support * float/double arguments compiled with the MPW C compiler, * use the following APIs to move MPW float/double values into * a VARIANT. */ /*---------------------------------------------------------------------*/ /* ITypeLib */ /*---------------------------------------------------------------------*/ typedef ITypeLib FAR* LPTYPELIB; /*---------------------------------------------------------------------*/ /* ITypeInfo */ /*---------------------------------------------------------------------*/ typedef LONG DISPID; typedef DISPID MEMBERID; #define MEMBERID_NIL DISPID_UNKNOWN #define ID_DEFAULTINST -2 #define IDLFLAG_NONE 0 #define IDLFLAG_FIN 0x1 #define IDLFLAG_FOUT 0x2 #define IDLFLAG_FLCID 0x4 #define IDLFLAG_FRETVAL 0x8 /* Flags for IDispatch::Invoke */ #define DISPATCH_METHOD 0x1 #define DISPATCH_PROPERTYGET 0x2 #define DISPATCH_PROPERTYPUT 0x4 #define DISPATCH_PROPERTYPUTREF 0x8 typedef ITypeInfo FAR* LPTYPEINFO; /*---------------------------------------------------------------------*/ /* ITypeComp */ /*---------------------------------------------------------------------*/ typedef ITypeComp FAR* LPTYPECOMP; /*---------------------------------------------------------------------*/ /* ICreateTypeLib */ /*---------------------------------------------------------------------*/ typedef ICreateTypeLib FAR* LPCREATETYPELIB; typedef ICreateTypeInfo FAR* LPCREATETYPEINFO; /*---------------------------------------------------------------------*/ /* TypeInfo API */ /*---------------------------------------------------------------------*/ /* compute a 16bit hash value for the given name */ #ifdef _WIN32 WINOLEAUTAPI_(ULONG) LHashValOfNameSysA(SYSKIND syskind, LCID lcid, const char FAR* szName); #endif WINOLEAUTAPI_(ULONG) LHashValOfNameSys(SYSKIND syskind, LCID lcid, const OLECHAR FAR* szName); #define LHashValOfName(lcid, szName) \ LHashValOfNameSys(SYS_WIN32, lcid, szName) #define WHashValOfLHashVal(lhashval) \ ((unsigned short) (0x0000ffff & (lhashval))) #define IsHashValCompatible(lhashval1, lhashval2) \ ((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2)))) /* load the typelib from the file with the given filename */ WINOLEAUTAPI LoadTypeLib(const OLECHAR FAR *szFile, ITypeLib FAR* FAR* pptlib); /* load registered typelib */ WINOLEAUTAPI LoadRegTypeLib( REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid, ITypeLib FAR* FAR* pptlib); /* get path to registered typelib */ WINOLEAUTAPI QueryPathOfRegTypeLib( REFGUID guid, unsigned short wMaj, unsigned short wMin, LCID lcid, LPBSTR lpbstrPathName); /* add typelib to registry */ WINOLEAUTAPI RegisterTypeLib(ITypeLib FAR* ptlib, OLECHAR FAR *szFullPath, OLECHAR FAR *szHelpDir); /* remove typelib from registry */ WINOLEAUTAPI DeregisterTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid); WINOLEAUTAPI CreateTypeLib(SYSKIND syskind, const OLECHAR FAR *szFile, ICreateTypeLib FAR* FAR* ppctlib); /*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/ /* IDispatch */ /*---------------------------------------------------------------------*/ typedef IDispatch FAR* LPDISPATCH; /*---------------------------------------------------------------------*/ /* IDispatch implementation support */ /*---------------------------------------------------------------------*/ typedef struct FARSTRUCT tagPARAMDATA { OLECHAR FAR* szName; /* parameter name */ VARTYPE vt; /* parameter type */ } PARAMDATA, FAR* LPPARAMDATA; typedef struct FARSTRUCT tagMETHODDATA { OLECHAR FAR* szName; /* method name */ PARAMDATA FAR* ppdata; /* pointer to an array of PARAMDATAs */ DISPID dispid; /* method ID */ UINT iMeth; /* method index */ CALLCONV cc; /* calling convention */ UINT cArgs; /* count of arguments */ WORD wFlags; /* same wFlags as on IDispatch::Invoke() */ VARTYPE vtReturn; } METHODDATA, FAR* LPMETHODDATA; typedef struct FARSTRUCT tagINTERFACEDATA { METHODDATA FAR* pmethdata; /* pointer to an array of METHODDATAs */ UINT cMembers; /* count of members */ } INTERFACEDATA, FAR* LPINTERFACEDATA; /* Locate the parameter indicated by the given position, and * return it coerced to the given target VARTYPE (vtTarg). */ WINOLEAUTAPI DispGetParam( DISPPARAMS FAR* pdispparams, UINT position, VARTYPE vtTarg, VARIANT FAR* pvarResult, UINT FAR* puArgErr); /* Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames() */ WINOLEAUTAPI DispGetIDsOfNames( ITypeInfo FAR* ptinfo, OLECHAR FAR* FAR* rgszNames, UINT cNames, DISPID FAR* rgdispid); /* Automatic TypeInfo driven implementation of IDispatch::Invoke() */ WINOLEAUTAPI DispInvoke( void FAR* _this, ITypeInfo FAR* ptinfo, DISPID dispidMember, WORD wFlags, DISPPARAMS FAR* pparams, VARIANT FAR* pvarResult, EXCEPINFO FAR* pexcepinfo, UINT FAR* puArgErr); /* Construct a TypeInfo from an interface data description */ WINOLEAUTAPI CreateDispTypeInfo( INTERFACEDATA FAR* pidata, LCID lcid, ITypeInfo FAR* FAR* pptinfo); /* Create an instance of the standard TypeInfo driven IDispatch * implementation. */ WINOLEAUTAPI CreateStdDispatch( IUnknown FAR* punkOuter, void FAR* pvThis, ITypeInfo FAR* ptinfo, IUnknown FAR* FAR* ppunkStdDisp); /*---------------------------------------------------------------------*/ /* Active Object Registration API */ /*---------------------------------------------------------------------*/ /* flags for RegisterActiveObject */ #define ACTIVEOBJECT_STRONG 0x0 #define ACTIVEOBJECT_WEAK 0x1 WINOLEAUTAPI RegisterActiveObject( IUnknown FAR* punk, REFCLSID rclsid, DWORD dwFlags, DWORD FAR* pdwRegister); WINOLEAUTAPI RevokeActiveObject( DWORD dwRegister, void FAR* pvReserved); WINOLEAUTAPI GetActiveObject( REFCLSID rclsid, void FAR* pvReserved, IUnknown FAR* FAR* ppunk); /*---------------------------------------------------------------------*/ /* ErrorInfo API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI SetErrorInfo(unsigned long dwReserved, IErrorInfo FAR* perrinfo); WINOLEAUTAPI GetErrorInfo(unsigned long dwReserved, IErrorInfo FAR* FAR* pperrinfo); WINOLEAUTAPI CreateErrorInfo(ICreateErrorInfo FAR* FAR* pperrinfo); /*---------------------------------------------------------------------*/ /* MISC API */ /*---------------------------------------------------------------------*/ WINOLEAUTAPI_(unsigned long) OaBuildVersion(void); // Declare variant access functions. #ifdef NONAMELESSUNION # define V_UNION(X, Y) ((X)->u.Y) #else # define V_UNION(X, Y) ((X)->Y) #endif /* Variant access macros */ #define V_VT(X) ((X)->vt) #define V_ISBYREF(X) (V_VT(X)&VT_BYREF) #define V_ISARRAY(X) (V_VT(X)&VT_ARRAY) #define V_ISVECTOR(X) (V_VT(X)&VT_VECTOR) #define V_NONE(X) V_I2(X) #define V_UI1(X) V_UNION(X, bVal) #define V_UI1REF(X) V_UNION(X, pbVal) #define V_I2(X) V_UNION(X, iVal) #define V_I2REF(X) V_UNION(X, piVal) #define V_I4(X) V_UNION(X, lVal) #define V_I4REF(X) V_UNION(X, plVal) #define V_I8(X) V_UNION(X, hVal) #define V_I8REF(X) V_UNION(X, phVal) #define V_R4(X) V_UNION(X, fltVal) #define V_R4REF(X) V_UNION(X, pfltVal) #define V_R8(X) V_UNION(X, dblVal) #define V_R8REF(X) V_UNION(X, pdblVal) #define V_CY(X) V_UNION(X, cyVal) #define V_CYREF(X) V_UNION(X, pcyVal) #define V_DATE(X) V_UNION(X, date) #define V_DATEREF(X) V_UNION(X, pdate) #define V_BSTR(X) V_UNION(X, bstrVal) #define V_BSTRREF(X) V_UNION(X, pbstrVal) #define V_DISPATCH(X) V_UNION(X, pdispVal) #define V_DISPATCHREF(X) V_UNION(X, ppdispVal) #define V_ERROR(X) V_UNION(X, scode) #define V_ERRORREF(X) V_UNION(X, pscode) #define V_BOOL(X) V_UNION(X, bool) #define V_BOOLREF(X) V_UNION(X, pbool) #define V_UNKNOWN(X) V_UNION(X, punkVal) #define V_UNKNOWNREF(X) V_UNION(X, ppunkVal) #define V_VARIANTREF(X) V_UNION(X, pvarVal) #define V_LPSTR(X) V_UNION(X, pszVal) #define V_LPSTRREF(X) V_UNION(X, ppszVal) #define V_LPWSTR(X) V_UNION(X, pwszVal) #define V_LPWSTRREF(X) V_UNION(X, ppwszVal) #define V_FILETIME(X) V_UNION(X, filetime) #define V_FILETIMEREF(X) V_UNION(X, pfiletime) #define V_BLOB(X) V_UNION(X, blob) #define V_UUID(X) V_UNION(X, puuid) #define V_CLSID(X) V_UNION(X, puuid) #define V_ARRAY(X) V_UNION(X, parray) #define V_ARRAYREF(X) V_UNION(X, pparray) #define V_BYREF(X) V_UNION(X, byref) #ifndef RC_INVOKED #include #endif // RC_INVOKED #endif // __OLEAUTO_H__