home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 December / PCWKCD1296.iso / vjplusb / activex / inetsdk / include / oleauto.h < prev    next >
C/C++ Source or Header  |  1996-07-15  |  33KB  |  772 lines
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //  Copyright (C) Microsoft Corporation, 1992 - 1996.
  5. //
  6. //  File:       oleauto.h
  7. //
  8. //  Contents:   Defines Ole Automation support function prototypes, constants
  9. //
  10. //----------------------------------------------------------------------------
  11.  
  12. #if !defined( _OLEAUTO_H_ )
  13. #define _OLEAUTO_H_
  14.  
  15. // Set packing to 8 for ISV, and Win95 support
  16. #ifndef RC_INVOKED
  17. #include <pshpack8.h>
  18. #endif // RC_INVOKED
  19.  
  20. //  Definition of the OLE Automation APIs, and macros.
  21.  
  22. #ifdef _OLEAUT32_
  23. #define WINOLEAUTAPI        STDAPI
  24. #define WINOLEAUTAPI_(type) STDAPI_(type)
  25. #else
  26. #define WINOLEAUTAPI        EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
  27. #define WINOLEAUTAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
  28. #endif
  29.  
  30. EXTERN_C const IID IID_StdOle;
  31.  
  32. #define STDOLE_MAJORVERNUM  0x1
  33. #define STDOLE_MINORVERNUM  0x0
  34. #define STDOLE_LCID         0x0000
  35.  
  36. // Version # of stdole2.tlb
  37. #define STDOLE2_MAJORVERNUM 0x2
  38. #define STDOLE2_MINORVERNUM 0x0
  39. #define STDOLE2_LCID        0x0000
  40.  
  41. /* if not already picked up from olenls.h */
  42. #ifndef _LCID_DEFINED
  43. typedef DWORD LCID;
  44. # define _LCID_DEFINED
  45. #endif
  46.  
  47. #ifndef BEGIN_INTERFACE
  48. #define BEGIN_INTERFACE
  49. #define END_INTERFACE
  50. #endif
  51.  
  52. /* pull in the MIDL generated header */
  53. #include <oaidl.h>
  54.  
  55.  
  56. /*---------------------------------------------------------------------*/
  57. /*                            BSTR API                                 */
  58. /*---------------------------------------------------------------------*/
  59.  
  60. WINOLEAUTAPI_(BSTR) SysAllocString(const OLECHAR *);
  61. WINOLEAUTAPI_(INT)  SysReAllocString(BSTR *, const OLECHAR *);
  62. WINOLEAUTAPI_(BSTR) SysAllocStringLen(const OLECHAR *, UINT);
  63. WINOLEAUTAPI_(INT)  SysReAllocStringLen(BSTR *, const OLECHAR *, UINT);
  64. WINOLEAUTAPI_(void) SysFreeString(BSTR);
  65. WINOLEAUTAPI_(UINT) SysStringLen(BSTR);
  66.  
  67. #ifdef _WIN32
  68. WINOLEAUTAPI_(UINT) SysStringByteLen(BSTR bstr);
  69. WINOLEAUTAPI_(BSTR) SysAllocStringByteLen(LPCSTR psz, UINT len);
  70. #endif
  71.  
  72. /*---------------------------------------------------------------------*/
  73. /*                            Time API                                 */
  74. /*---------------------------------------------------------------------*/
  75.  
  76. WINOLEAUTAPI_(INT) DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime, DOUBLE * pvtime);
  77.  
  78. WINOLEAUTAPI_(INT) VariantTimeToDosDateTime(DOUBLE vtime, USHORT * pwDosDate, USHORT * pwDosTime);
  79.  
  80. #ifdef _WIN32
  81. WINOLEAUTAPI_(INT) SystemTimeToVariantTime(LPSYSTEMTIME lpSystemTime, DOUBLE *pvtime);
  82. WINOLEAUTAPI_(INT) VariantTimeToSystemTime(DOUBLE vtime, LPSYSTEMTIME lpSystemTime);
  83. #endif
  84.  
  85.  
  86. /*---------------------------------------------------------------------*/
  87. /*                          SafeArray API                              */
  88. /*---------------------------------------------------------------------*/
  89.  
  90. WINOLEAUTAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY ** ppsaOut);
  91. WINOLEAUTAPI SafeArrayAllocData(SAFEARRAY * psa);
  92. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND * rgsabound);
  93. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements);
  94. WINOLEAUTAPI SafeArrayCopyData(SAFEARRAY *psaSource, SAFEARRAY *psaTarget);
  95. WINOLEAUTAPI SafeArrayDestroyDescriptor(SAFEARRAY * psa);
  96. WINOLEAUTAPI SafeArrayDestroyData(SAFEARRAY * psa);
  97. WINOLEAUTAPI SafeArrayDestroy(SAFEARRAY * psa);
  98. WINOLEAUTAPI SafeArrayRedim(SAFEARRAY * psa, SAFEARRAYBOUND * psaboundNew);
  99. WINOLEAUTAPI_(UINT) SafeArrayGetDim(SAFEARRAY * psa);
  100. WINOLEAUTAPI_(UINT) SafeArrayGetElemsize(SAFEARRAY * psa);
  101. WINOLEAUTAPI SafeArrayGetUBound(SAFEARRAY * psa, UINT nDim, LONG * plUbound);
  102. WINOLEAUTAPI SafeArrayGetLBound(SAFEARRAY * psa, UINT nDim, LONG * plLbound);
  103. WINOLEAUTAPI SafeArrayLock(SAFEARRAY * psa);
  104. WINOLEAUTAPI SafeArrayUnlock(SAFEARRAY * psa);
  105. WINOLEAUTAPI SafeArrayAccessData(SAFEARRAY * psa, void HUGEP** ppvData);
  106. WINOLEAUTAPI SafeArrayUnaccessData(SAFEARRAY * psa);
  107. WINOLEAUTAPI SafeArrayGetElement(SAFEARRAY * psa, LONG * rgIndices, void * pv);
  108. WINOLEAUTAPI SafeArrayPutElement(SAFEARRAY * psa, LONG * rgIndices, void * pv);
  109. WINOLEAUTAPI SafeArrayCopy(SAFEARRAY * psa, SAFEARRAY ** ppsaOut);
  110. WINOLEAUTAPI SafeArrayPtrOfIndex(SAFEARRAY * psa, LONG * rgIndices, void ** ppvData);
  111.  
  112.  
  113. /*---------------------------------------------------------------------*/
  114. /*                           VARIANT API                               */
  115. /*---------------------------------------------------------------------*/
  116.  
  117. WINOLEAUTAPI_(void) VariantInit(VARIANTARG * pvarg);
  118. WINOLEAUTAPI VariantClear(VARIANTARG * pvarg);
  119. WINOLEAUTAPI VariantCopy(VARIANTARG * pvargDest, VARIANTARG * pvargSrc);
  120. WINOLEAUTAPI VariantCopyInd(VARIANT * pvarDest, VARIANTARG * pvargSrc);
  121. WINOLEAUTAPI VariantChangeType(VARIANTARG * pvargDest,
  122.                 VARIANTARG * pvarSrc, USHORT wFlags, VARTYPE vt);
  123. WINOLEAUTAPI VariantChangeTypeEx(VARIANTARG * pvargDest,
  124.                 VARIANTARG * pvarSrc, LCID lcid, USHORT wFlags, VARTYPE vt);
  125.  
  126. // Flags for VariantChangeType/VariantChangeTypeEx
  127. #define VARIANT_NOVALUEPROP 0x1
  128. #define VARIANT_ALPHABOOL   0x2 // For VT_BOOL to VT_BSTR conversions,
  129.                                 // convert to "True"/"False" instead of
  130.                                 // "-1"/"0"
  131. #define VARIANT_NOUSEROVERRIDE   0x4    // For conversions to/from VT_BSTR,
  132.                     // passes LOCALE_NOUSEROVERRIDE
  133.                     // to core coercion routines
  134.  
  135.  
  136. /*---------------------------------------------------------------------*/
  137. /*                Vector <-> Bstr conversion APIs                      */
  138. /*---------------------------------------------------------------------*/
  139.  
  140. WINOLEAUTAPI VectorFromBstr (BSTR bstr, SAFEARRAY ** ppsa);
  141. WINOLEAUTAPI BstrFromVector (SAFEARRAY *psa, BSTR *pbstr);
  142.  
  143.  
  144. /*---------------------------------------------------------------------*/
  145. /*                     VARTYPE Coercion API                            */
  146. /*---------------------------------------------------------------------*/
  147.  
  148. /* Note: The routines that convert *from* a string are defined
  149.  * to take a OLECHAR* rather than a BSTR because no allocation is
  150.  * required, and this makes the routines a bit more generic.
  151.  * They may of course still be passed a BSTR as the strIn param.
  152.  */
  153.  
  154. /* Any of the coersion functions that converts either from or to a string
  155.  * takes an additional lcid and dwFlags arguments. The lcid argument allows
  156.  * locale specific parsing to occur.  The dwFlags allow additional function
  157.  * specific condition to occur.  All function that accept the dwFlags argument
  158.  * can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  159.  * VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
  160.  * VAR_DATEVALUEONLY flags
  161.  */
  162.  
  163. #define VAR_TIMEVALUEONLY   ((DWORD)0x00000001)    /* return time value */
  164. #define VAR_DATEVALUEONLY   ((DWORD)0x00000002)    /* return date value */
  165.  
  166. WINOLEAUTAPI VarUI1FromI2(SHORT sIn, BYTE * pbOut);
  167. WINOLEAUTAPI VarUI1FromI4(LONG lIn, BYTE * pbOut);
  168. WINOLEAUTAPI VarUI1FromR4(FLOAT fltIn, BYTE * pbOut);
  169. WINOLEAUTAPI VarUI1FromR8(DOUBLE dblIn, BYTE * pbOut);
  170. WINOLEAUTAPI VarUI1FromCy(CY cyIn, BYTE * pbOut);
  171. WINOLEAUTAPI VarUI1FromDate(DATE dateIn, BYTE * pbOut);
  172. WINOLEAUTAPI VarUI1FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, BYTE * pbOut);
  173. WINOLEAUTAPI VarUI1FromDisp(IDispatch * pdispIn, LCID lcid, BYTE * pbOut);
  174. WINOLEAUTAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE * pbOut);
  175. WINOLEAUTAPI VarUI1FromI1(CHAR cIn, BYTE *pbOut);
  176. WINOLEAUTAPI VarUI1FromUI2(USHORT uiIn, BYTE *pbOut);
  177. WINOLEAUTAPI VarUI1FromUI4(ULONG ulIn, BYTE *pbOut);
  178. WINOLEAUTAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE *pbOut);
  179.  
  180. WINOLEAUTAPI VarI2FromUI1(BYTE bIn, SHORT * psOut);
  181. WINOLEAUTAPI VarI2FromI4(LONG lIn, SHORT * psOut);
  182. WINOLEAUTAPI VarI2FromR4(FLOAT fltIn, SHORT * psOut);
  183. WINOLEAUTAPI VarI2FromR8(DOUBLE dblIn, SHORT * psOut);
  184. WINOLEAUTAPI VarI2FromCy(CY cyIn, SHORT * psOut);
  185. WINOLEAUTAPI VarI2FromDate(DATE dateIn, SHORT * psOut);
  186. WINOLEAUTAPI VarI2FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, SHORT * psOut);
  187. WINOLEAUTAPI VarI2FromDisp(IDispatch * pdispIn, LCID lcid, SHORT * psOut);
  188. WINOLEAUTAPI VarI2FromBool(VARIANT_BOOL boolIn, SHORT * psOut);
  189. WINOLEAUTAPI VarI2FromI1(CHAR cIn, SHORT *psOut);
  190. WINOLEAUTAPI VarI2FromUI2(USHORT uiIn, SHORT *psOut);
  191. WINOLEAUTAPI VarI2FromUI4(ULONG ulIn, SHORT *psOut);
  192. WINOLEAUTAPI VarI2FromDec(DECIMAL *pdecIn, SHORT *psOut);
  193.  
  194. WINOLEAUTAPI VarI4FromUI1(BYTE bIn, LONG * plOut);
  195. WINOLEAUTAPI VarI4FromI2(SHORT sIn, LONG * plOut);
  196. WINOLEAUTAPI VarI4FromR4(FLOAT fltIn, LONG * plOut);
  197. WINOLEAUTAPI VarI4FromR8(DOUBLE dblIn, LONG * plOut);
  198. WINOLEAUTAPI VarI4FromCy(CY cyIn, LONG * plOut);
  199. WINOLEAUTAPI VarI4FromDate(DATE dateIn, LONG * plOut);
  200. WINOLEAUTAPI VarI4FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, LONG * plOut);
  201. WINOLEAUTAPI VarI4FromDisp(IDispatch * pdispIn, LCID lcid, LONG * plOut);
  202. WINOLEAUTAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG * plOut);
  203. WINOLEAUTAPI VarI4FromI1(CHAR cIn, LONG *plOut);
  204. WINOLEAUTAPI VarI4FromUI2(USHORT uiIn, LONG *plOut);
  205. WINOLEAUTAPI VarI4FromUI4(ULONG ulIn, LONG *plOut);
  206. WINOLEAUTAPI VarI4FromDec(DECIMAL *pdecIn, LONG *plOut);
  207. WINOLEAUTAPI VarI4FromInt(INT intIn, LONG *plOut);
  208.  
  209. WINOLEAUTAPI VarR4FromUI1(BYTE bIn, FLOAT * pfltOut);
  210. WINOLEAUTAPI VarR4FromI2(SHORT sIn, FLOAT * pfltOut);
  211. WINOLEAUTAPI VarR4FromI4(LONG lIn, FLOAT * pfltOut);
  212. WINOLEAUTAPI VarR4FromR8(DOUBLE dblIn, FLOAT * pfltOut);
  213. WINOLEAUTAPI VarR4FromCy(CY cyIn, FLOAT * pfltOut);
  214. WINOLEAUTAPI VarR4FromDate(DATE dateIn, FLOAT * pfltOut);
  215. WINOLEAUTAPI VarR4FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, FLOAT *pfltOut);
  216. WINOLEAUTAPI VarR4FromDisp(IDispatch * pdispIn, LCID lcid, FLOAT * pfltOut);
  217. WINOLEAUTAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT * pfltOut);
  218. WINOLEAUTAPI VarR4FromI1(CHAR cIn, FLOAT *pfltOut);
  219. WINOLEAUTAPI VarR4FromUI2(USHORT uiIn, FLOAT *pfltOut);
  220. WINOLEAUTAPI VarR4FromUI4(ULONG ulIn, FLOAT *pfltOut);
  221. WINOLEAUTAPI VarR4FromDec(DECIMAL *pdecIn, FLOAT *pfltOut);
  222.  
  223. WINOLEAUTAPI VarR8FromUI1(BYTE bIn, DOUBLE * pdblOut);
  224. WINOLEAUTAPI VarR8FromI2(SHORT sIn, DOUBLE * pdblOut);
  225. WINOLEAUTAPI VarR8FromI4(LONG lIn, DOUBLE * pdblOut);
  226. WINOLEAUTAPI VarR8FromR4(FLOAT fltIn, DOUBLE * pdblOut);
  227. WINOLEAUTAPI VarR8FromCy(CY cyIn, DOUBLE * pdblOut);
  228. WINOLEAUTAPI VarR8FromDate(DATE dateIn, DOUBLE * pdblOut);
  229. WINOLEAUTAPI VarR8FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DOUBLE *pdblOut);
  230. WINOLEAUTAPI VarR8FromDisp(IDispatch * pdispIn, LCID lcid, DOUBLE * pdblOut);
  231. WINOLEAUTAPI VarR8FromBool(VARIANT_BOOL boolIn, DOUBLE * pdblOut);
  232. WINOLEAUTAPI VarR8FromI1(CHAR cIn, DOUBLE *pdblOut);
  233. WINOLEAUTAPI VarR8FromUI2(USHORT uiIn, DOUBLE *pdblOut);
  234. WINOLEAUTAPI VarR8FromUI4(ULONG ulIn, DOUBLE *pdblOut);
  235. WINOLEAUTAPI VarR8FromDec(DECIMAL *pdecIn, DOUBLE *pdblOut);
  236.  
  237. WINOLEAUTAPI VarDateFromUI1(BYTE bIn, DATE * pdateOut);
  238. WINOLEAUTAPI VarDateFromI2(SHORT sIn, DATE * pdateOut);
  239. WINOLEAUTAPI VarDateFromI4(LONG lIn, DATE * pdateOut);
  240. WINOLEAUTAPI VarDateFromR4(FLOAT fltIn, DATE * pdateOut);
  241. WINOLEAUTAPI VarDateFromR8(DOUBLE dblIn, DATE * pdateOut);
  242. WINOLEAUTAPI VarDateFromCy(CY cyIn, DATE * pdateOut);
  243. WINOLEAUTAPI VarDateFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DATE *pdateOut);
  244. WINOLEAUTAPI VarDateFromDisp(IDispatch * pdispIn, LCID lcid, DATE * pdateOut);
  245. WINOLEAUTAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE * pdateOut);
  246. WINOLEAUTAPI VarDateFromI1(CHAR cIn, DATE *pdateOut);
  247. WINOLEAUTAPI VarDateFromUI2(USHORT uiIn, DATE *pdateOut);
  248. WINOLEAUTAPI VarDateFromUI4(ULONG ulIn, DATE *pdateOut);
  249. WINOLEAUTAPI VarDateFromDec(DECIMAL *pdecIn, DATE *pdateOut);
  250.  
  251. WINOLEAUTAPI VarCyFromUI1(BYTE bIn, CY * pcyOut);
  252. WINOLEAUTAPI VarCyFromI2(SHORT sIn, CY * pcyOut);
  253. WINOLEAUTAPI VarCyFromI4(LONG lIn, CY * pcyOut);
  254. WINOLEAUTAPI VarCyFromR4(FLOAT fltIn, CY * pcyOut);
  255. WINOLEAUTAPI VarCyFromR8(DOUBLE dblIn, CY * pcyOut);
  256. WINOLEAUTAPI VarCyFromDate(DATE dateIn, CY * pcyOut);
  257. WINOLEAUTAPI VarCyFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, CY * pcyOut);
  258. WINOLEAUTAPI VarCyFromDisp(IDispatch * pdispIn, LCID lcid, CY * pcyOut);
  259. WINOLEAUTAPI VarCyFromBool(VARIANT_BOOL boolIn, CY * pcyOut);
  260. WINOLEAUTAPI VarCyFromI1(CHAR cIn, CY *pcyOut);
  261. WINOLEAUTAPI VarCyFromUI2(USHORT uiIn, CY *pcyOut);
  262. WINOLEAUTAPI VarCyFromUI4(ULONG ulIn, CY *pcyOut);
  263. WINOLEAUTAPI VarCyFromDec(DECIMAL *pdecIn, CY *pcyOut);
  264.  
  265. WINOLEAUTAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  266. WINOLEAUTAPI VarBstrFromI2(SHORT iVal, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  267. WINOLEAUTAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  268. WINOLEAUTAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  269. WINOLEAUTAPI VarBstrFromR8(DOUBLE dblIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  270. WINOLEAUTAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  271. WINOLEAUTAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  272. WINOLEAUTAPI VarBstrFromDisp(IDispatch * pdispIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  273. WINOLEAUTAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  274. WINOLEAUTAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  275. WINOLEAUTAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  276. WINOLEAUTAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  277. WINOLEAUTAPI VarBstrFromDec(DECIMAL *pdecIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  278.  
  279. WINOLEAUTAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL * pboolOut);
  280. WINOLEAUTAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL * pboolOut);
  281. WINOLEAUTAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL * pboolOut);
  282. WINOLEAUTAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL * pboolOut);
  283. WINOLEAUTAPI VarBoolFromR8(DOUBLE dblIn, VARIANT_BOOL * pboolOut);
  284. WINOLEAUTAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL * pboolOut);
  285. WINOLEAUTAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL * pboolOut);
  286. WINOLEAUTAPI VarBoolFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL * pboolOut);
  287. WINOLEAUTAPI VarBoolFromDisp(IDispatch * pdispIn, LCID lcid, VARIANT_BOOL * pboolOut);
  288. WINOLEAUTAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL *pboolOut);
  289. WINOLEAUTAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL *pboolOut);
  290. WINOLEAUTAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pboolOut);
  291. WINOLEAUTAPI VarBoolFromDec(DECIMAL *pdecIn, VARIANT_BOOL *pboolOut);
  292.  
  293. WINOLEAUTAPI VarI1FromUI1(BYTE bIn, CHAR *pcOut);
  294. WINOLEAUTAPI VarI1FromI2(SHORT uiIn, CHAR *pcOut);
  295. WINOLEAUTAPI VarI1FromI4(LONG lIn, CHAR *pcOut);
  296. WINOLEAUTAPI VarI1FromR4(FLOAT fltIn, CHAR *pcOut);
  297. WINOLEAUTAPI VarI1FromR8(DOUBLE dblIn, CHAR *pcOut);
  298. WINOLEAUTAPI VarI1FromDate(DATE dateIn, CHAR *pcOut);
  299. WINOLEAUTAPI VarI1FromCy(CY cyIn, CHAR *pcOut);
  300. WINOLEAUTAPI VarI1FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CHAR *pcOut);
  301. WINOLEAUTAPI VarI1FromDisp(IDispatch *pdispIn, LCID lcid, CHAR *pcOut);
  302. WINOLEAUTAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR *pcOut);
  303. WINOLEAUTAPI VarI1FromUI2(USHORT uiIn, CHAR *pcOut);
  304. WINOLEAUTAPI VarI1FromUI4(ULONG ulIn, CHAR *pcOut);
  305. WINOLEAUTAPI VarI1FromDec(DECIMAL *pdecIn, CHAR *pcOut);
  306.  
  307. WINOLEAUTAPI VarUI2FromUI1(BYTE bIn, USHORT *puiOut);
  308. WINOLEAUTAPI VarUI2FromI2(SHORT uiIn, USHORT *puiOut);
  309. WINOLEAUTAPI VarUI2FromI4(LONG lIn, USHORT *puiOut);
  310. WINOLEAUTAPI VarUI2FromR4(FLOAT fltIn, USHORT *puiOut);
  311. WINOLEAUTAPI VarUI2FromR8(DOUBLE dblIn, USHORT *puiOut);
  312. WINOLEAUTAPI VarUI2FromDate(DATE dateIn, USHORT *puiOut);
  313. WINOLEAUTAPI VarUI2FromCy(CY cyIn, USHORT *puiOut);
  314. WINOLEAUTAPI VarUI2FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, USHORT *puiOut);
  315. WINOLEAUTAPI VarUI2FromDisp(IDispatch *pdispIn, LCID lcid, USHORT *puiOut);
  316. WINOLEAUTAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT *puiOut);
  317. WINOLEAUTAPI VarUI2FromI1(CHAR cIn, USHORT *puiOut);
  318. WINOLEAUTAPI VarUI2FromUI4(ULONG ulIn, USHORT *puiOut);
  319. WINOLEAUTAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT *puiOut);
  320.  
  321. WINOLEAUTAPI VarUI4FromUI1(BYTE bIn, ULONG *pulOut);
  322. WINOLEAUTAPI VarUI4FromI2(SHORT uiIn, ULONG *pulOut);
  323. WINOLEAUTAPI VarUI4FromI4(LONG lIn, ULONG *pulOut);
  324. WINOLEAUTAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut);
  325. WINOLEAUTAPI VarUI4FromR8(DOUBLE dblIn, ULONG *pulOut);
  326. WINOLEAUTAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut);
  327. WINOLEAUTAPI VarUI4FromCy(CY cyIn, ULONG *pulOut);
  328. WINOLEAUTAPI VarUI4FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut);
  329. WINOLEAUTAPI VarUI4FromDisp(IDispatch *pdispIn, LCID lcid, ULONG *pulOut);
  330. WINOLEAUTAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG *pulOut);
  331. WINOLEAUTAPI VarUI4FromI1(CHAR cIn, ULONG *pulOut);
  332. WINOLEAUTAPI VarUI4FromUI2(USHORT uiIn, ULONG *pulOut);
  333. WINOLEAUTAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut);
  334.  
  335. WINOLEAUTAPI VarDecFromUI1(BYTE bIn, DECIMAL *pdecOut);
  336. WINOLEAUTAPI VarDecFromI2(SHORT uiIn, DECIMAL *pdecOut);
  337. WINOLEAUTAPI VarDecFromI4(LONG lIn, DECIMAL *pdecOut);
  338. WINOLEAUTAPI VarDecFromR4(FLOAT fltIn, DECIMAL *pdecOut);
  339. WINOLEAUTAPI VarDecFromR8(DOUBLE dblIn, DECIMAL *pdecOut);
  340. WINOLEAUTAPI VarDecFromDate(DATE dateIn, DECIMAL *pdecOut);
  341. WINOLEAUTAPI VarDecFromCy(CY cyIn, DECIMAL *pdecOut);
  342. WINOLEAUTAPI VarDecFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DECIMAL *pdecOut);
  343. WINOLEAUTAPI VarDecFromDisp(IDispatch *pdispIn, LCID lcid, DECIMAL *pdecOut);
  344. WINOLEAUTAPI VarDecFromBool(VARIANT_BOOL boolIn, DECIMAL *pdecOut);
  345. WINOLEAUTAPI VarDecFromI1(CHAR cIn, DECIMAL *pdecOut);
  346. WINOLEAUTAPI VarDecFromUI2(USHORT uiIn, DECIMAL *pdecOut);
  347. WINOLEAUTAPI VarDecFromUI4(ULONG ulIn, DECIMAL *pdecOut);
  348.  
  349. #define VarUI4FromUI4(in, pOut) (*(pOut) = (in))
  350. #define VarI4FromI4(in, pOut)   (*(pOut) = (in))
  351.  
  352. #define VarUI1FromInt       VarUI1FromI4
  353. #define VarUI1FromUint      VarUI1FromUI4
  354. #define VarI2FromInt        VarI2FromI4
  355. #define VarI2FromUint       VarI2FromUI4
  356. #define VarI4FromInt        VarI4FromI4
  357. #define VarI4FromUint       VarI4FromUI4
  358. #define VarR4FromInt        VarR4FromI4
  359. #define VarR4FromUint       VarR4FromUI4
  360. #define VarR8FromInt        VarR8FromI4
  361. #define VarR8FromUint       VarR8FromUI4
  362. #define VarDateFromInt      VarDateFromI4
  363. #define VarDateFromUint     VarDateFromUI4
  364. #define VarCyFromInt        VarCyFromI4
  365. #define VarCyFromUint       VarCyFromUI4
  366. #define VarBstrFromInt      VarBstrFromI4
  367. #define VarBstrFromUint     VarBstrFromUI4
  368. #define VarBoolFromInt      VarBoolFromI4
  369. #define VarBoolFromUint     VarBoolFromUI4
  370. #define VarI1FromInt        VarI1FromI4
  371. #define VarI1FromUint       VarI1FromUI4
  372. #define VarUI2FromInt       VarUI2FromI4
  373. #define VarUI2FromUint      VarUI2FromUI4
  374. #define VarUI4FromInt       VarUI4FromI4
  375. #define VarUI4FromUint      VarUI4FromUI4
  376. #define VarDecFromInt       VarDecFromI4
  377. #define VarDecFromUint      VarDecFromUI4
  378. #define VarIntFromUI1       VarI4FromUI1
  379. #define VarIntFromI2        VarI4FromI2
  380. #define VarIntFromI4        VarI4FromI4
  381. #define VarIntFromR4        VarI4FromR4
  382. #define VarIntFromR8        VarI4FromR8
  383. #define VarIntFromDate      VarI4FromDate
  384. #define VarIntFromCy        VarI4FromCy
  385. #define VarIntFromStr       VarI4FromStr
  386. #define VarIntFromDisp      VarI4FromDisp
  387. #define VarIntFromBool      VarI4FromBool
  388. #define VarIntFromI1        VarI4FromI1
  389. #define VarIntFromUI2       VarI4FromUI2
  390. #define VarIntFromUI4       VarI4FromUI4
  391. #define VarIntFromDec       VarI4FromDec
  392. #define VarIntFromUint      VarI4FromUI4
  393. #define VarUintFromUI1      VarUI4FromUI1
  394. #define VarUintFromI2       VarUI4FromI2
  395. #define VarUintFromI4       VarUI4FromI4
  396. #define VarUintFromR4       VarUI4FromR4
  397. #define VarUintFromR8       VarUI4FromR8
  398. #define VarUintFromDate     VarUI4FromDate
  399. #define VarUintFromCy       VarUI4FromCy
  400. #define VarUintFromStr      VarUI4FromStr
  401. #define VarUintFromDisp     VarUI4FromDisp
  402. #define VarUintFromBool     VarUI4FromBool
  403. #define VarUintFromI1       VarUI4FromI1
  404. #define VarUintFromUI2      VarUI4FromUI2
  405. #define VarUintFromUI4      VarUI4FromUI4
  406. #define VarUintFromDec      VarUI4FromDec
  407. #define VarUintFromInt      VarUI4FromI4
  408.  
  409. /* Mac Note: On the Mac, the coersion functions support the
  410.  * Symantec C++ calling convention for float/double. To support
  411.  * float/double arguments compiled with the MPW C compiler,
  412.  * use the following APIs to move MPW float/double values into
  413.  * a VARIANT.
  414.  */
  415.  
  416. /*---------------------------------------------------------------------*/
  417. /*            New VARIANT <-> string parsing functions                 */
  418. /*---------------------------------------------------------------------*/
  419.  
  420. typedef struct {
  421.     INT   cDig;
  422.     ULONG dwInFlags;
  423.     ULONG dwOutFlags;
  424.     INT   cchUsed;
  425.     INT   nBaseShift;
  426.     INT   nPwr10;
  427. } NUMPARSE;
  428.  
  429. /* flags used by both dwInFlags and dwOutFlags:
  430.  */
  431. #define NUMPRS_LEADING_WHITE    0x0001
  432. #define NUMPRS_TRAILING_WHITE   0x0002
  433. #define NUMPRS_LEADING_PLUS     0x0004
  434. #define NUMPRS_TRAILING_PLUS    0x0008
  435. #define NUMPRS_LEADING_MINUS    0x0010
  436. #define NUMPRS_TRAILING_MINUS   0x0020
  437. #define NUMPRS_HEX_OCT          0x0040
  438. #define NUMPRS_PARENS           0x0080
  439. #define NUMPRS_DECIMAL          0x0100
  440. #define NUMPRS_THOUSANDS        0x0200
  441. #define NUMPRS_CURRENCY         0x0400
  442. #define NUMPRS_EXPONENT         0x0800
  443. #define NUMPRS_USE_ALL          0x1000
  444. #define NUMPRS_STD              0x1FFF
  445.  
  446. /* flags used by dwOutFlags only:
  447.  */
  448. #define NUMPRS_NEG              0x10000
  449. #define NUMPRS_INEXACT          0x20000
  450.  
  451. /* flags used by VarNumFromParseNum to indicate acceptable result types:
  452.  */
  453. #define VTBIT_I1        (1 << VT_I1)
  454. #define VTBIT_UI1       (1 << VT_UI1)
  455. #define VTBIT_I2        (1 << VT_I2)
  456. #define VTBIT_UI2       (1 << VT_UI2)
  457. #define VTBIT_I4        (1 << VT_I4)
  458. #define VTBIT_UI4       (1 << VT_UI4)
  459. #define VTBIT_R4        (1 << VT_R4)
  460. #define VTBIT_R8        (1 << VT_R8)
  461. #define VTBIT_CY        (1 << VT_CY)
  462. #define VTBIT_DECIMAL   (1 << VT_DECIMAL)
  463.  
  464.  
  465. WINOLEAUTAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
  466.             NUMPARSE * pnumprs, BYTE * rgbDig);
  467.  
  468. WINOLEAUTAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
  469.             ULONG dwVtBits, VARIANT * pvar);
  470.  
  471.  
  472. /*---------------------------------------------------------------------*/
  473. /*                   New date functions                                */
  474. /*---------------------------------------------------------------------*/
  475.  
  476. #define VAR_VALIDDATE       0x0004    /* VarDateFromUdate() only */
  477. #define VAR_CALENDAR_HIJRI  0x0008    /* use Hijri calender */
  478. #define VARIANT_CALENDAR_HIJRI VAR_CALENDAR_HIJRI
  479.  
  480. /* The UDATE structure is used with VarDateFromUdate() and VarUdateFromDate().
  481.  * It represents an "unpacked date".
  482.  */
  483. typedef struct {
  484.     SYSTEMTIME st;
  485.     USHORT  wDayOfYear;
  486. } UDATE;
  487.  
  488. /* APIs to "pack" and "unpack" dates.
  489.  */
  490. WINOLEAUTAPI VarDateFromUdate(UDATE *pudateIn, ULONG dwFlags, DATE *pdateOut);
  491.  
  492. WINOLEAUTAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *pudateOut);
  493.  
  494. /* API to retrieve the secondary(altername) month names
  495.    Useful for Hijri, Polish and Russian alternate month names
  496. */   
  497. WINOLEAUTAPI GetAltMonthNames(LCID lcid, LPOLESTR * * prgp);
  498.  
  499.  
  500.  
  501. /*---------------------------------------------------------------------*/
  502. /*                 ITypeLib                                            */
  503. /*---------------------------------------------------------------------*/
  504.  
  505. typedef ITypeLib * LPTYPELIB;
  506.  
  507.  
  508. /*---------------------------------------------------------------------*/
  509. /*                ITypeInfo                                            */
  510. /*---------------------------------------------------------------------*/
  511.  
  512.  
  513. typedef LONG DISPID;
  514. typedef DISPID MEMBERID;
  515.  
  516. #define MEMBERID_NIL DISPID_UNKNOWN
  517. #define ID_DEFAULTINST  -2
  518.  
  519.  
  520. /* Flags for IDispatch::Invoke */
  521. #define DISPATCH_METHOD         0x1
  522. #define DISPATCH_PROPERTYGET    0x2
  523. #define DISPATCH_PROPERTYPUT    0x4
  524. #define DISPATCH_PROPERTYPUTREF 0x8
  525.  
  526. typedef ITypeInfo * LPTYPEINFO;
  527.  
  528.  
  529. /*---------------------------------------------------------------------*/
  530. /*                ITypeComp                                            */
  531. /*---------------------------------------------------------------------*/
  532.  
  533. typedef ITypeComp * LPTYPECOMP;
  534.  
  535.  
  536. /*---------------------------------------------------------------------*/
  537. /*             ICreateTypeLib                                          */
  538. /*---------------------------------------------------------------------*/
  539.  
  540. typedef ICreateTypeLib * LPCREATETYPELIB;
  541.  
  542. typedef ICreateTypeInfo * LPCREATETYPEINFO;
  543.  
  544. /*---------------------------------------------------------------------*/
  545. /*             TypeInfo API                                            */
  546. /*---------------------------------------------------------------------*/
  547.  
  548. /* compute a 16bit hash value for the given name
  549.  */
  550. #ifdef _WIN32
  551. WINOLEAUTAPI_(ULONG) LHashValOfNameSysA(SYSKIND syskind, LCID lcid,
  552.             LPCSTR szName);
  553. #endif
  554.  
  555. WINOLEAUTAPI_(ULONG)
  556. LHashValOfNameSys(SYSKIND syskind, LCID lcid, const OLECHAR * szName);
  557.  
  558. #define LHashValOfName(lcid, szName) \
  559.             LHashValOfNameSys(SYS_WIN32, lcid, szName)
  560.  
  561. #define WHashValOfLHashVal(lhashval) \
  562.             ((USHORT) (0x0000ffff & (lhashval)))
  563.  
  564. #define IsHashValCompatible(lhashval1, lhashval2) \
  565.             ((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2))))
  566.  
  567. /* load the typelib from the file with the given filename
  568.  */
  569. WINOLEAUTAPI LoadTypeLib(const OLECHAR  *szFile, ITypeLib ** pptlib);
  570.  
  571. /* Control how a type library is registered
  572.  */
  573. typedef enum tagREGKIND
  574. {
  575.     REGKIND_DEFAULT,
  576.     REGKIND_REGISTER,
  577.     REGKIND_NONE
  578. } REGKIND;
  579.  
  580. WINOLEAUTAPI LoadTypeLibEx(LPCOLESTR szFile, REGKIND regkind,
  581.             ITypeLib ** pptlib);
  582.  
  583. /* load registered typelib
  584.  */
  585. WINOLEAUTAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor,
  586.             LCID lcid, ITypeLib ** pptlib);
  587.  
  588. /* get path to registered typelib
  589.  */
  590. WINOLEAUTAPI QueryPathOfRegTypeLib(REFGUID guid, USHORT wMaj, USHORT wMin,
  591.             LCID lcid, LPBSTR lpbstrPathName);
  592.  
  593. /* add typelib to registry
  594.  */
  595. WINOLEAUTAPI RegisterTypeLib(ITypeLib * ptlib, OLECHAR  *szFullPath,
  596.             OLECHAR  *szHelpDir);
  597.  
  598. /* remove typelib from registry
  599.  */
  600.  
  601. WINOLEAUTAPI UnRegisterTypeLib(REFGUID libID, WORD wVerMajor,
  602.             WORD wVerMinor, LCID lcid, SYSKIND syskind);
  603.  
  604. WINOLEAUTAPI CreateTypeLib(SYSKIND syskind, const OLECHAR  *szFile,
  605.             ICreateTypeLib ** ppctlib);
  606.  
  607. WINOLEAUTAPI CreateTypeLib2(SYSKIND syskind, LPCOLESTR szFile,
  608.             ICreateTypeLib2 **ppctlib);
  609.  
  610.  
  611. /*---------------------------------------------------------------------*/
  612. /*           IDispatch implementation support                          */
  613. /*---------------------------------------------------------------------*/
  614.  
  615. typedef IDispatch * LPDISPATCH;
  616.  
  617. typedef struct tagPARAMDATA {
  618.     OLECHAR * szName;   /* parameter name */
  619.     VARTYPE vt;         /* parameter type */
  620. } PARAMDATA, * LPPARAMDATA;
  621.  
  622. typedef struct tagMETHODDATA {
  623.     OLECHAR * szName;   /* method name */
  624.     PARAMDATA * ppdata; /* pointer to an array of PARAMDATAs */
  625.     DISPID dispid;      /* method ID */
  626.     UINT iMeth;         /* method index */
  627.     CALLCONV cc;        /* calling convention */
  628.     UINT cArgs;         /* count of arguments */
  629.     WORD wFlags;        /* same wFlags as on IDispatch::Invoke() */
  630.     VARTYPE vtReturn;
  631. } METHODDATA, * LPMETHODDATA;
  632.  
  633. typedef struct tagINTERFACEDATA {
  634.     METHODDATA * pmethdata;  /* pointer to an array of METHODDATAs */
  635.     UINT cMembers;      /* count of members */
  636. } INTERFACEDATA, * LPINTERFACEDATA;
  637.  
  638.  
  639.  
  640. /* Locate the parameter indicated by the given position, and
  641.  * return it coerced to the given target VARTYPE (vtTarg).
  642.  */
  643. WINOLEAUTAPI DispGetParam(DISPPARAMS * pdispparams, UINT position,
  644.             VARTYPE vtTarg, VARIANT * pvarResult, UINT * puArgErr);
  645.  
  646. /* Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames()
  647.  */
  648. WINOLEAUTAPI DispGetIDsOfNames(ITypeInfo * ptinfo, OLECHAR ** rgszNames,
  649.             UINT cNames, DISPID * rgdispid);
  650.  
  651. /* Automatic TypeInfo driven implementation of IDispatch::Invoke()
  652.  */
  653. WINOLEAUTAPI DispInvoke(void * _this, ITypeInfo * ptinfo, DISPID dispidMember,
  654.             WORD wFlags, DISPPARAMS * pparams, VARIANT * pvarResult,
  655.             EXCEPINFO * pexcepinfo, UINT * puArgErr);
  656.  
  657. /* Construct a TypeInfo from an interface data description
  658.  */
  659. WINOLEAUTAPI CreateDispTypeInfo(INTERFACEDATA * pidata, LCID lcid,
  660.             ITypeInfo ** pptinfo);
  661.  
  662. /* Create an instance of the standard TypeInfo driven IDispatch
  663.  * implementation.
  664.  */
  665. WINOLEAUTAPI CreateStdDispatch(IUnknown * punkOuter, void * pvThis,
  666.             ITypeInfo * ptinfo, IUnknown ** ppunkStdDisp);
  667.  
  668. /* Low-level helper for IDispatch::Invoke() provides machine independence
  669.  * for customized Invoke().
  670.  */
  671. WINOLEAUTAPI DispCallFunc(void * pvInstance, ULONG oVft, CALLCONV cc,
  672.             VARTYPE vtReturn, UINT  cActuals, VARTYPE * prgvt,
  673.             VARIANTARG ** prgpvarg, VARIANT * pvargResult);
  674.  
  675.  
  676. /*---------------------------------------------------------------------*/
  677. /*            Active Object Registration API                           */
  678. /*---------------------------------------------------------------------*/
  679.  
  680. /* flags for RegisterActiveObject */
  681. #define ACTIVEOBJECT_STRONG 0x0
  682. #define ACTIVEOBJECT_WEAK 0x1
  683.  
  684. WINOLEAUTAPI RegisterActiveObject(IUnknown * punk, REFCLSID rclsid,
  685.             DWORD dwFlags, DWORD * pdwRegister);
  686.  
  687. WINOLEAUTAPI RevokeActiveObject(DWORD dwRegister, void * pvReserved);
  688.  
  689. WINOLEAUTAPI GetActiveObject(REFCLSID rclsid, void * pvReserved,
  690.             IUnknown ** ppunk);
  691.  
  692. /*---------------------------------------------------------------------*/
  693. /*                           ErrorInfo API                             */
  694. /*---------------------------------------------------------------------*/
  695.  
  696. WINOLEAUTAPI SetErrorInfo(ULONG dwReserved, IErrorInfo * perrinfo);
  697. WINOLEAUTAPI GetErrorInfo(ULONG dwReserved, IErrorInfo ** pperrinfo);
  698. WINOLEAUTAPI CreateErrorInfo(ICreateErrorInfo ** pperrinfo);
  699.  
  700. /*---------------------------------------------------------------------*/
  701. /*                           MISC API                                  */
  702. /*---------------------------------------------------------------------*/
  703.  
  704. WINOLEAUTAPI_(ULONG) OaBuildVersion(void);
  705.  
  706. WINOLEAUTAPI_(void) ClearCustData(LPCUSTDATA pCustData);
  707.  
  708. // Declare variant access functions.
  709.  
  710. #if __STDC__ || defined(NONAMELESSUNION)
  711. #define V_UNION(X, Y)   ((X)->n1.n2.n3.Y)
  712. #define V_VT(X)         ((X)->n1.n2.vt)
  713. #else
  714. #define V_UNION(X, Y)   ((X)->Y)
  715. #define V_VT(X)         ((X)->vt)
  716. #endif
  717.  
  718. /* Variant access macros
  719.  */
  720. #define V_ISBYREF(X)     (V_VT(X)&VT_BYREF)
  721. #define V_ISARRAY(X)     (V_VT(X)&VT_ARRAY)
  722. #define V_ISVECTOR(X)    (V_VT(X)&VT_VECTOR)
  723. #define V_NONE(X)        V_I2(X)
  724.  
  725. #define V_UI1(X)         V_UNION(X, bVal)
  726. #define V_UI1REF(X)      V_UNION(X, pbVal)
  727. #define V_I2(X)          V_UNION(X, iVal)
  728. #define V_I2REF(X)       V_UNION(X, piVal)
  729. #define V_I4(X)          V_UNION(X, lVal)
  730. #define V_I4REF(X)       V_UNION(X, plVal)
  731. #define V_R4(X)          V_UNION(X, fltVal)
  732. #define V_R4REF(X)       V_UNION(X, pfltVal)
  733. #define V_R8(X)          V_UNION(X, dblVal)
  734. #define V_R8REF(X)       V_UNION(X, pdblVal)
  735. #define V_I1(X)          V_UNION(X, cVal)
  736. #define V_I1REF(X)       V_UNION(X, pcVal)
  737. #define V_UI2(X)         V_UNION(X, uiVal)
  738. #define V_UI2REF(X)      V_UNION(X, puiVal)
  739. #define V_UI4(X)         V_UNION(X, ulVal)
  740. #define V_UI4REF(X)      V_UNION(X, pulVal)
  741. #define V_INT(X)         V_UNION(X, intVal)
  742. #define V_INTREF(X)      V_UNION(X, pintVal)
  743. #define V_UINT(X)        V_UNION(X, uintVal)
  744. #define V_UINTREF(X)     V_UNION(X, puintVal)
  745. #define V_CY(X)          V_UNION(X, cyVal)
  746. #define V_CYREF(X)       V_UNION(X, pcyVal)
  747. #define V_DATE(X)        V_UNION(X, date)
  748. #define V_DATEREF(X)     V_UNION(X, pdate)
  749. #define V_BSTR(X)        V_UNION(X, bstrVal)
  750. #define V_BSTRREF(X)     V_UNION(X, pbstrVal)
  751. #define V_DISPATCH(X)    V_UNION(X, pdispVal)
  752. #define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
  753. #define V_ERROR(X)       V_UNION(X, scode)
  754. #define V_ERRORREF(X)    V_UNION(X, pscode)
  755. #define V_BOOL(X)        V_UNION(X, boolVal)
  756. #define V_BOOLREF(X)     V_UNION(X, pboolVal)
  757. #define V_UNKNOWN(X)     V_UNION(X, punkVal)
  758. #define V_UNKNOWNREF(X)  V_UNION(X, ppunkVal)
  759. #define V_VARIANTREF(X)  V_UNION(X, pvarVal)
  760. #define V_ARRAY(X)       V_UNION(X, parray)
  761. #define V_ARRAYREF(X)    V_UNION(X, pparray)
  762. #define V_BYREF(X)       V_UNION(X, byref)
  763.  
  764. #define V_DECIMAL(X)     V_UNION(X, decVal)
  765. #define V_DECIMALREF(X)  V_UNION(X, pdecVal)
  766.  
  767. #ifndef RC_INVOKED
  768. #include <poppack.h>
  769. #endif // RC_INVOKED
  770.  
  771. #endif     // __OLEAUTO_H__
  772.