home *** CD-ROM | disk | FTP | other *** search
/ PC Format (South-Africa) 2001 June / PCFJune.iso / Xenon / C++ / FreeCommandLineTools.exe / Include / oleauto.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  40.9 KB  |  942 lines
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //  Copyright (C) Microsoft Corporation, 1992-1999.
  5. //
  6. //  File:       oleauto.h
  7. //
  8. //  Contents:   Defines Ole Automation support function prototypes, constants
  9. //
  10. //----------------------------------------------------------------------------
  11.  
  12. #if !defined( _OLEAUTO_H_ )
  13. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  14. #define _OLEAUTO_H_
  15.  
  16. #if _MSC_VER > 1000
  17. #pragma once
  18. #endif
  19.  
  20. // Set packing to 8 for ISV, and Win95 support
  21. #ifndef RC_INVOKED
  22. #include <pshpack8.h>
  23. #endif // RC_INVOKED
  24.  
  25. //  Definition of the OLE Automation APIs, and macros.
  26.  
  27. #ifdef _OLEAUT32_
  28. #define WINOLEAUTAPI        STDAPI
  29. #define WINOLEAUTAPI_(type) STDAPI_(type)
  30. #else
  31. #define WINOLEAUTAPI        EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
  32. #define WINOLEAUTAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
  33. #endif
  34.  
  35. EXTERN_C const IID IID_StdOle;
  36.  
  37. #define STDOLE_MAJORVERNUM  0x1
  38. #define STDOLE_MINORVERNUM  0x0
  39. #define STDOLE_LCID         0x0000
  40.  
  41. // Version # of stdole2.tlb
  42. #define STDOLE2_MAJORVERNUM 0x2
  43. #define STDOLE2_MINORVERNUM 0x0
  44. #define STDOLE2_LCID        0x0000
  45.  
  46. /* if not already picked up from olenls.h */
  47. #ifndef _LCID_DEFINED
  48. typedef DWORD LCID;
  49. # define _LCID_DEFINED
  50. #endif
  51.  
  52. #ifndef BEGIN_INTERFACE
  53. #define BEGIN_INTERFACE
  54. #define END_INTERFACE
  55. #endif
  56.  
  57. /* pull in the MIDL generated header */
  58. #include <oaidl.h>
  59.  
  60.  
  61. /*---------------------------------------------------------------------*/
  62. /*                            BSTR API                                 */
  63. /*---------------------------------------------------------------------*/
  64.  
  65. WINOLEAUTAPI_(BSTR) SysAllocString(const OLECHAR *);
  66. WINOLEAUTAPI_(INT)  SysReAllocString(BSTR *, const OLECHAR *);
  67. WINOLEAUTAPI_(BSTR) SysAllocStringLen(const OLECHAR *, UINT);
  68. WINOLEAUTAPI_(INT)  SysReAllocStringLen(BSTR *, const OLECHAR *, UINT);
  69. WINOLEAUTAPI_(void) SysFreeString(BSTR);
  70. WINOLEAUTAPI_(UINT) SysStringLen(BSTR);
  71.  
  72. #ifdef _WIN32
  73. WINOLEAUTAPI_(UINT) SysStringByteLen(BSTR bstr);
  74. WINOLEAUTAPI_(BSTR) SysAllocStringByteLen(LPCSTR psz, UINT len);
  75. #endif
  76.  
  77. /*---------------------------------------------------------------------*/
  78. /*                            Time API                                 */
  79. /*---------------------------------------------------------------------*/
  80.  
  81. WINOLEAUTAPI_(INT) DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime, DOUBLE * pvtime);
  82.  
  83. WINOLEAUTAPI_(INT) VariantTimeToDosDateTime(DOUBLE vtime, USHORT * pwDosDate, USHORT * pwDosTime);
  84.  
  85. #ifdef _WIN32
  86. WINOLEAUTAPI_(INT) SystemTimeToVariantTime(LPSYSTEMTIME lpSystemTime, DOUBLE *pvtime);
  87. WINOLEAUTAPI_(INT) VariantTimeToSystemTime(DOUBLE vtime, LPSYSTEMTIME lpSystemTime);
  88. #endif
  89.  
  90.  
  91. /*---------------------------------------------------------------------*/
  92. /*                          SafeArray API                              */
  93. /*---------------------------------------------------------------------*/
  94.  
  95. WINOLEAUTAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY ** ppsaOut);
  96. WINOLEAUTAPI SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, SAFEARRAY ** ppsaOut);
  97. WINOLEAUTAPI SafeArrayAllocData(SAFEARRAY * psa);
  98. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND * rgsabound);
  99. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND * rgsabound, PVOID pvExtra);
  100. WINOLEAUTAPI SafeArrayCopyData(SAFEARRAY *psaSource, SAFEARRAY *psaTarget);
  101. WINOLEAUTAPI SafeArrayDestroyDescriptor(SAFEARRAY * psa);
  102. WINOLEAUTAPI SafeArrayDestroyData(SAFEARRAY * psa);
  103. WINOLEAUTAPI SafeArrayDestroy(SAFEARRAY * psa);
  104. WINOLEAUTAPI SafeArrayRedim(SAFEARRAY * psa, SAFEARRAYBOUND * psaboundNew);
  105. WINOLEAUTAPI_(UINT) SafeArrayGetDim(SAFEARRAY * psa);
  106. WINOLEAUTAPI_(UINT) SafeArrayGetElemsize(SAFEARRAY * psa);
  107. WINOLEAUTAPI SafeArrayGetUBound(SAFEARRAY * psa, UINT nDim, LONG * plUbound);
  108. WINOLEAUTAPI SafeArrayGetLBound(SAFEARRAY * psa, UINT nDim, LONG * plLbound);
  109. WINOLEAUTAPI SafeArrayLock(SAFEARRAY * psa);
  110. WINOLEAUTAPI SafeArrayUnlock(SAFEARRAY * psa);
  111. WINOLEAUTAPI SafeArrayAccessData(SAFEARRAY * psa, void HUGEP** ppvData);
  112. WINOLEAUTAPI SafeArrayUnaccessData(SAFEARRAY * psa);
  113. WINOLEAUTAPI SafeArrayGetElement(SAFEARRAY * psa, LONG * rgIndices, void * pv);
  114. WINOLEAUTAPI SafeArrayPutElement(SAFEARRAY * psa, LONG * rgIndices, void * pv);
  115. WINOLEAUTAPI SafeArrayCopy(SAFEARRAY * psa, SAFEARRAY ** ppsaOut);
  116. WINOLEAUTAPI SafeArrayPtrOfIndex(SAFEARRAY * psa, LONG * rgIndices, void ** ppvData);
  117. WINOLEAUTAPI SafeArraySetRecordInfo(SAFEARRAY * psa, IRecordInfo * prinfo);
  118. WINOLEAUTAPI SafeArrayGetRecordInfo(SAFEARRAY * psa, IRecordInfo ** prinfo);
  119. WINOLEAUTAPI SafeArraySetIID(SAFEARRAY * psa, REFGUID guid);
  120. WINOLEAUTAPI SafeArrayGetIID(SAFEARRAY * psa, GUID * pguid);
  121. WINOLEAUTAPI SafeArrayGetVartype(SAFEARRAY * psa, VARTYPE * pvt);
  122. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements);
  123. WINOLEAUTAPI_(SAFEARRAY *) SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cElements, PVOID pvExtra);
  124.  
  125. /*---------------------------------------------------------------------*/
  126. /*                           VARIANT API                               */
  127. /*---------------------------------------------------------------------*/
  128.  
  129. WINOLEAUTAPI_(void) VariantInit(VARIANTARG * pvarg);
  130. WINOLEAUTAPI VariantClear(VARIANTARG * pvarg);
  131. WINOLEAUTAPI VariantCopy(VARIANTARG * pvargDest, VARIANTARG * pvargSrc);
  132. WINOLEAUTAPI VariantCopyInd(VARIANT * pvarDest, VARIANTARG * pvargSrc);
  133. WINOLEAUTAPI VariantChangeType(VARIANTARG * pvargDest,
  134.                 VARIANTARG * pvarSrc, USHORT wFlags, VARTYPE vt);
  135. WINOLEAUTAPI VariantChangeTypeEx(VARIANTARG * pvargDest,
  136.                 VARIANTARG * pvarSrc, LCID lcid, USHORT wFlags, VARTYPE vt);
  137.  
  138. // Flags for VariantChangeType/VariantChangeTypeEx
  139. #define VARIANT_NOVALUEPROP      0x01
  140. #define VARIANT_ALPHABOOL        0x02 // For VT_BOOL to VT_BSTR conversions,
  141.                                       // convert to "True"/"False" instead of
  142.                                       // "-1"/"0"
  143. #define VARIANT_NOUSEROVERRIDE   0x04 // For conversions to/from VT_BSTR,
  144.                       // passes LOCALE_NOUSEROVERRIDE
  145.                       // to core coercion routines
  146. #define VARIANT_CALENDAR_HIJRI   0x08
  147. #define VARIANT_LOCALBOOL        0x10 // For VT_BOOL to VT_BSTR and back,
  148.                                       // convert to local language rather than
  149.                                       // English
  150.  
  151. /*---------------------------------------------------------------------*/
  152. /*                Vector <-> Bstr conversion APIs                      */
  153. /*---------------------------------------------------------------------*/
  154.  
  155. WINOLEAUTAPI VectorFromBstr (BSTR bstr, SAFEARRAY ** ppsa);
  156. WINOLEAUTAPI BstrFromVector (SAFEARRAY *psa, BSTR *pbstr);
  157.  
  158. /*---------------------------------------------------------------------*/
  159. /*                     Variant API Flags                               */
  160. /*---------------------------------------------------------------------*/
  161.  
  162. /* Any of the coersion functions that converts either from or to a string
  163.  * takes an additional lcid and dwFlags arguments. The lcid argument allows
  164.  * locale specific parsing to occur.  The dwFlags allow additional function
  165.  * specific condition to occur.  All function that accept the dwFlags argument
  166.  * can include either 0 or LOCALE_NOUSEROVERRIDE flag.
  167.  */
  168.  
  169. /* The VarDateFromStr and VarBstrFromDate functions also accept the
  170.  * VAR_TIMEVALUEONLY and VAR_DATEVALUEONLY flags
  171.  */
  172. #define VAR_TIMEVALUEONLY       ((DWORD)0x00000001)    /* return time value */
  173. #define VAR_DATEVALUEONLY       ((DWORD)0x00000002)    /* return date value */
  174.  
  175. /* VarDateFromUdate() only */
  176. #define VAR_VALIDDATE           ((DWORD)0x00000004)
  177.  
  178. /* Accepted by all date & format APIs */
  179. #define VAR_CALENDAR_HIJRI      ((DWORD)0x00000008)    /* use Hijri calender */
  180.  
  181. /* Booleans can optionally be accepted in localized form. Pass VAR_LOCALBOOL
  182.  * into VarBoolFromStr and VarBstrFromBool to use localized boolean names
  183.  */
  184. #define VAR_LOCALBOOL           ((DWORD)0x00000010)
  185.  
  186. /* When passed into VarFormat and VarFormatFromTokens, prevents substitution
  187.  * of formats in the case where a string is passed in that can not be
  188.  * coverted into the desired type. (for ex, 'Format("Hello", "General Number")')
  189.  */
  190. #define VAR_FORMAT_NOSUBSTITUTE ((DWORD)0x00000020)
  191.  
  192. /*---------------------------------------------------------------------*/
  193. /*                     VARTYPE Coercion API                            */
  194. /*---------------------------------------------------------------------*/
  195.  
  196. /* Note: The routines that convert *from* a string are defined
  197.  * to take a OLECHAR* rather than a BSTR because no allocation is
  198.  * required, and this makes the routines a bit more generic.
  199.  * They may of course still be passed a BSTR as the strIn param.
  200.  */
  201.  
  202. WINOLEAUTAPI VarUI1FromI2(SHORT sIn, BYTE * pbOut);
  203. WINOLEAUTAPI VarUI1FromI4(LONG lIn, BYTE * pbOut);
  204. WINOLEAUTAPI VarUI1FromR4(FLOAT fltIn, BYTE * pbOut);
  205. WINOLEAUTAPI VarUI1FromR8(DOUBLE dblIn, BYTE * pbOut);
  206. WINOLEAUTAPI VarUI1FromCy(CY cyIn, BYTE * pbOut);
  207. WINOLEAUTAPI VarUI1FromDate(DATE dateIn, BYTE * pbOut);
  208. WINOLEAUTAPI VarUI1FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, BYTE * pbOut);
  209. WINOLEAUTAPI VarUI1FromDisp(IDispatch * pdispIn, LCID lcid, BYTE * pbOut);
  210. WINOLEAUTAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE * pbOut);
  211. WINOLEAUTAPI VarUI1FromI1(CHAR cIn, BYTE *pbOut);
  212. WINOLEAUTAPI VarUI1FromUI2(USHORT uiIn, BYTE *pbOut);
  213. WINOLEAUTAPI VarUI1FromUI4(ULONG ulIn, BYTE *pbOut);
  214. WINOLEAUTAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE *pbOut);
  215.  
  216. WINOLEAUTAPI VarI2FromUI1(BYTE bIn, SHORT * psOut);
  217. WINOLEAUTAPI VarI2FromI4(LONG lIn, SHORT * psOut);
  218. WINOLEAUTAPI VarI2FromR4(FLOAT fltIn, SHORT * psOut);
  219. WINOLEAUTAPI VarI2FromR8(DOUBLE dblIn, SHORT * psOut);
  220. WINOLEAUTAPI VarI2FromCy(CY cyIn, SHORT * psOut);
  221. WINOLEAUTAPI VarI2FromDate(DATE dateIn, SHORT * psOut);
  222. WINOLEAUTAPI VarI2FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, SHORT * psOut);
  223. WINOLEAUTAPI VarI2FromDisp(IDispatch * pdispIn, LCID lcid, SHORT * psOut);
  224. WINOLEAUTAPI VarI2FromBool(VARIANT_BOOL boolIn, SHORT * psOut);
  225. WINOLEAUTAPI VarI2FromI1(CHAR cIn, SHORT *psOut);
  226. WINOLEAUTAPI VarI2FromUI2(USHORT uiIn, SHORT *psOut);
  227. WINOLEAUTAPI VarI2FromUI4(ULONG ulIn, SHORT *psOut);
  228. WINOLEAUTAPI VarI2FromDec(DECIMAL *pdecIn, SHORT *psOut);
  229.  
  230. WINOLEAUTAPI VarI4FromUI1(BYTE bIn, LONG * plOut);
  231. WINOLEAUTAPI VarI4FromI2(SHORT sIn, LONG * plOut);
  232. WINOLEAUTAPI VarI4FromR4(FLOAT fltIn, LONG * plOut);
  233. WINOLEAUTAPI VarI4FromR8(DOUBLE dblIn, LONG * plOut);
  234. WINOLEAUTAPI VarI4FromCy(CY cyIn, LONG * plOut);
  235. WINOLEAUTAPI VarI4FromDate(DATE dateIn, LONG * plOut);
  236. WINOLEAUTAPI VarI4FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, LONG * plOut);
  237. WINOLEAUTAPI VarI4FromDisp(IDispatch * pdispIn, LCID lcid, LONG * plOut);
  238. WINOLEAUTAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG * plOut);
  239. WINOLEAUTAPI VarI4FromI1(CHAR cIn, LONG *plOut);
  240. WINOLEAUTAPI VarI4FromUI2(USHORT uiIn, LONG *plOut);
  241. WINOLEAUTAPI VarI4FromUI4(ULONG ulIn, LONG *plOut);
  242. WINOLEAUTAPI VarI4FromDec(DECIMAL *pdecIn, LONG *plOut);
  243. WINOLEAUTAPI VarI4FromInt(INT intIn, LONG *plOut);
  244.  
  245. WINOLEAUTAPI VarR4FromUI1(BYTE bIn, FLOAT * pfltOut);
  246. WINOLEAUTAPI VarR4FromI2(SHORT sIn, FLOAT * pfltOut);
  247. WINOLEAUTAPI VarR4FromI4(LONG lIn, FLOAT * pfltOut);
  248. WINOLEAUTAPI VarR4FromR8(DOUBLE dblIn, FLOAT * pfltOut);
  249. WINOLEAUTAPI VarR4FromCy(CY cyIn, FLOAT * pfltOut);
  250. WINOLEAUTAPI VarR4FromDate(DATE dateIn, FLOAT * pfltOut);
  251. WINOLEAUTAPI VarR4FromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, FLOAT *pfltOut);
  252. WINOLEAUTAPI VarR4FromDisp(IDispatch * pdispIn, LCID lcid, FLOAT * pfltOut);
  253. WINOLEAUTAPI VarR4FromBool(VARIANT_BOOL boolIn, FLOAT * pfltOut);
  254. WINOLEAUTAPI VarR4FromI1(CHAR cIn, FLOAT *pfltOut);
  255. WINOLEAUTAPI VarR4FromUI2(USHORT uiIn, FLOAT *pfltOut);
  256. WINOLEAUTAPI VarR4FromUI4(ULONG ulIn, FLOAT *pfltOut);
  257. WINOLEAUTAPI VarR4FromDec(DECIMAL *pdecIn, FLOAT *pfltOut);
  258.  
  259. WINOLEAUTAPI VarR8FromUI1(BYTE bIn, DOUBLE * pdblOut);
  260. WINOLEAUTAPI VarR8FromI2(SHORT sIn, DOUBLE * pdblOut);
  261. WINOLEAUTAPI VarR8FromI4(LONG lIn, DOUBLE * pdblOut);
  262. WINOLEAUTAPI VarR8FromR4(FLOAT fltIn, DOUBLE * pdblOut);
  263. WINOLEAUTAPI VarR8FromCy(CY cyIn, DOUBLE * pdblOut);
  264. WINOLEAUTAPI VarR8FromDate(DATE dateIn, DOUBLE * pdblOut);
  265. WINOLEAUTAPI VarR8FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DOUBLE *pdblOut);
  266. WINOLEAUTAPI VarR8FromDisp(IDispatch * pdispIn, LCID lcid, DOUBLE * pdblOut);
  267. WINOLEAUTAPI VarR8FromBool(VARIANT_BOOL boolIn, DOUBLE * pdblOut);
  268. WINOLEAUTAPI VarR8FromI1(CHAR cIn, DOUBLE *pdblOut);
  269. WINOLEAUTAPI VarR8FromUI2(USHORT uiIn, DOUBLE *pdblOut);
  270. WINOLEAUTAPI VarR8FromUI4(ULONG ulIn, DOUBLE *pdblOut);
  271. WINOLEAUTAPI VarR8FromDec(DECIMAL *pdecIn, DOUBLE *pdblOut);
  272.  
  273. WINOLEAUTAPI VarDateFromUI1(BYTE bIn, DATE * pdateOut);
  274. WINOLEAUTAPI VarDateFromI2(SHORT sIn, DATE * pdateOut);
  275. WINOLEAUTAPI VarDateFromI4(LONG lIn, DATE * pdateOut);
  276. WINOLEAUTAPI VarDateFromR4(FLOAT fltIn, DATE * pdateOut);
  277. WINOLEAUTAPI VarDateFromR8(DOUBLE dblIn, DATE * pdateOut);
  278. WINOLEAUTAPI VarDateFromCy(CY cyIn, DATE * pdateOut);
  279. WINOLEAUTAPI VarDateFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DATE *pdateOut);
  280. WINOLEAUTAPI VarDateFromDisp(IDispatch * pdispIn, LCID lcid, DATE * pdateOut);
  281. WINOLEAUTAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE * pdateOut);
  282. WINOLEAUTAPI VarDateFromI1(CHAR cIn, DATE *pdateOut);
  283. WINOLEAUTAPI VarDateFromUI2(USHORT uiIn, DATE *pdateOut);
  284. WINOLEAUTAPI VarDateFromUI4(ULONG ulIn, DATE *pdateOut);
  285. WINOLEAUTAPI VarDateFromDec(DECIMAL *pdecIn, DATE *pdateOut);
  286.  
  287. WINOLEAUTAPI VarCyFromUI1(BYTE bIn, CY * pcyOut);
  288. WINOLEAUTAPI VarCyFromI2(SHORT sIn, CY * pcyOut);
  289. WINOLEAUTAPI VarCyFromI4(LONG lIn, CY * pcyOut);
  290. WINOLEAUTAPI VarCyFromR4(FLOAT fltIn, CY * pcyOut);
  291. WINOLEAUTAPI VarCyFromR8(DOUBLE dblIn, CY * pcyOut);
  292. WINOLEAUTAPI VarCyFromDate(DATE dateIn, CY * pcyOut);
  293. WINOLEAUTAPI VarCyFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, CY * pcyOut);
  294. WINOLEAUTAPI VarCyFromDisp(IDispatch * pdispIn, LCID lcid, CY * pcyOut);
  295. WINOLEAUTAPI VarCyFromBool(VARIANT_BOOL boolIn, CY * pcyOut);
  296. WINOLEAUTAPI VarCyFromI1(CHAR cIn, CY *pcyOut);
  297. WINOLEAUTAPI VarCyFromUI2(USHORT uiIn, CY *pcyOut);
  298. WINOLEAUTAPI VarCyFromUI4(ULONG ulIn, CY *pcyOut);
  299. WINOLEAUTAPI VarCyFromDec(DECIMAL *pdecIn, CY *pcyOut);
  300.  
  301. WINOLEAUTAPI VarBstrFromUI1(BYTE bVal, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  302. WINOLEAUTAPI VarBstrFromI2(SHORT iVal, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  303. WINOLEAUTAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  304. WINOLEAUTAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  305. WINOLEAUTAPI VarBstrFromR8(DOUBLE dblIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  306. WINOLEAUTAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  307. WINOLEAUTAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  308. WINOLEAUTAPI VarBstrFromDisp(IDispatch * pdispIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  309. WINOLEAUTAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR * pbstrOut);
  310. WINOLEAUTAPI VarBstrFromI1(CHAR cIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  311. WINOLEAUTAPI VarBstrFromUI2(USHORT uiIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  312. WINOLEAUTAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  313. WINOLEAUTAPI VarBstrFromDec(DECIMAL *pdecIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut);
  314.  
  315. WINOLEAUTAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL * pboolOut);
  316. WINOLEAUTAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL * pboolOut);
  317. WINOLEAUTAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL * pboolOut);
  318. WINOLEAUTAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL * pboolOut);
  319. WINOLEAUTAPI VarBoolFromR8(DOUBLE dblIn, VARIANT_BOOL * pboolOut);
  320. WINOLEAUTAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL * pboolOut);
  321. WINOLEAUTAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL * pboolOut);
  322. WINOLEAUTAPI VarBoolFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL * pboolOut);
  323. WINOLEAUTAPI VarBoolFromDisp(IDispatch * pdispIn, LCID lcid, VARIANT_BOOL * pboolOut);
  324. WINOLEAUTAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL *pboolOut);
  325. WINOLEAUTAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL *pboolOut);
  326. WINOLEAUTAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pboolOut);
  327. WINOLEAUTAPI VarBoolFromDec(DECIMAL *pdecIn, VARIANT_BOOL *pboolOut);
  328.  
  329. WINOLEAUTAPI VarI1FromUI1(BYTE bIn, CHAR *pcOut);
  330. WINOLEAUTAPI VarI1FromI2(SHORT uiIn, CHAR *pcOut);
  331. WINOLEAUTAPI VarI1FromI4(LONG lIn, CHAR *pcOut);
  332. WINOLEAUTAPI VarI1FromR4(FLOAT fltIn, CHAR *pcOut);
  333. WINOLEAUTAPI VarI1FromR8(DOUBLE dblIn, CHAR *pcOut);
  334. WINOLEAUTAPI VarI1FromDate(DATE dateIn, CHAR *pcOut);
  335. WINOLEAUTAPI VarI1FromCy(CY cyIn, CHAR *pcOut);
  336. WINOLEAUTAPI VarI1FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CHAR *pcOut);
  337. WINOLEAUTAPI VarI1FromDisp(IDispatch *pdispIn, LCID lcid, CHAR *pcOut);
  338. WINOLEAUTAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR *pcOut);
  339. WINOLEAUTAPI VarI1FromUI2(USHORT uiIn, CHAR *pcOut);
  340. WINOLEAUTAPI VarI1FromUI4(ULONG ulIn, CHAR *pcOut);
  341. WINOLEAUTAPI VarI1FromDec(DECIMAL *pdecIn, CHAR *pcOut);
  342.  
  343. WINOLEAUTAPI VarUI2FromUI1(BYTE bIn, USHORT *puiOut);
  344. WINOLEAUTAPI VarUI2FromI2(SHORT uiIn, USHORT *puiOut);
  345. WINOLEAUTAPI VarUI2FromI4(LONG lIn, USHORT *puiOut);
  346. WINOLEAUTAPI VarUI2FromR4(FLOAT fltIn, USHORT *puiOut);
  347. WINOLEAUTAPI VarUI2FromR8(DOUBLE dblIn, USHORT *puiOut);
  348. WINOLEAUTAPI VarUI2FromDate(DATE dateIn, USHORT *puiOut);
  349. WINOLEAUTAPI VarUI2FromCy(CY cyIn, USHORT *puiOut);
  350. WINOLEAUTAPI VarUI2FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, USHORT *puiOut);
  351. WINOLEAUTAPI VarUI2FromDisp(IDispatch *pdispIn, LCID lcid, USHORT *puiOut);
  352. WINOLEAUTAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT *puiOut);
  353. WINOLEAUTAPI VarUI2FromI1(CHAR cIn, USHORT *puiOut);
  354. WINOLEAUTAPI VarUI2FromUI4(ULONG ulIn, USHORT *puiOut);
  355. WINOLEAUTAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT *puiOut);
  356.  
  357. WINOLEAUTAPI VarUI4FromUI1(BYTE bIn, ULONG *pulOut);
  358. WINOLEAUTAPI VarUI4FromI2(SHORT uiIn, ULONG *pulOut);
  359. WINOLEAUTAPI VarUI4FromI4(LONG lIn, ULONG *pulOut);
  360. WINOLEAUTAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut);
  361. WINOLEAUTAPI VarUI4FromR8(DOUBLE dblIn, ULONG *pulOut);
  362. WINOLEAUTAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut);
  363. WINOLEAUTAPI VarUI4FromCy(CY cyIn, ULONG *pulOut);
  364. WINOLEAUTAPI VarUI4FromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut);
  365. WINOLEAUTAPI VarUI4FromDisp(IDispatch *pdispIn, LCID lcid, ULONG *pulOut);
  366. WINOLEAUTAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG *pulOut);
  367. WINOLEAUTAPI VarUI4FromI1(CHAR cIn, ULONG *pulOut);
  368. WINOLEAUTAPI VarUI4FromUI2(USHORT uiIn, ULONG *pulOut);
  369. WINOLEAUTAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut);
  370.  
  371. WINOLEAUTAPI VarDecFromUI1(BYTE bIn, DECIMAL *pdecOut);
  372. WINOLEAUTAPI VarDecFromI2(SHORT uiIn, DECIMAL *pdecOut);
  373. WINOLEAUTAPI VarDecFromI4(LONG lIn, DECIMAL *pdecOut);
  374. WINOLEAUTAPI VarDecFromR4(FLOAT fltIn, DECIMAL *pdecOut);
  375. WINOLEAUTAPI VarDecFromR8(DOUBLE dblIn, DECIMAL *pdecOut);
  376. WINOLEAUTAPI VarDecFromDate(DATE dateIn, DECIMAL *pdecOut);
  377. WINOLEAUTAPI VarDecFromCy(CY cyIn, DECIMAL *pdecOut);
  378. WINOLEAUTAPI VarDecFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, DECIMAL *pdecOut);
  379. WINOLEAUTAPI VarDecFromDisp(IDispatch *pdispIn, LCID lcid, DECIMAL *pdecOut);
  380. WINOLEAUTAPI VarDecFromBool(VARIANT_BOOL boolIn, DECIMAL *pdecOut);
  381. WINOLEAUTAPI VarDecFromI1(CHAR cIn, DECIMAL *pdecOut);
  382. WINOLEAUTAPI VarDecFromUI2(USHORT uiIn, DECIMAL *pdecOut);
  383. WINOLEAUTAPI VarDecFromUI4(ULONG ulIn, DECIMAL *pdecOut);
  384.  
  385. #define VarUI4FromUI4(in, pOut) (*(pOut) = (in))
  386. #define VarI4FromI4(in, pOut)   (*(pOut) = (in))
  387.  
  388. #define VarUI1FromInt       VarUI1FromI4
  389. #define VarUI1FromUint      VarUI1FromUI4
  390. #define VarI2FromInt        VarI2FromI4
  391. #define VarI2FromUint       VarI2FromUI4
  392. #define VarI4FromInt        VarI4FromI4
  393. #define VarI4FromUint       VarI4FromUI4
  394. #define VarR4FromInt        VarR4FromI4
  395. #define VarR4FromUint       VarR4FromUI4
  396. #define VarR8FromInt        VarR8FromI4
  397. #define VarR8FromUint       VarR8FromUI4
  398. #define VarDateFromInt      VarDateFromI4
  399. #define VarDateFromUint     VarDateFromUI4
  400. #define VarCyFromInt        VarCyFromI4
  401. #define VarCyFromUint       VarCyFromUI4
  402. #define VarBstrFromInt      VarBstrFromI4
  403. #define VarBstrFromUint     VarBstrFromUI4
  404. #define VarBoolFromInt      VarBoolFromI4
  405. #define VarBoolFromUint     VarBoolFromUI4
  406. #define VarI1FromInt        VarI1FromI4
  407. #define VarI1FromUint       VarI1FromUI4
  408. #define VarUI2FromInt       VarUI2FromI4
  409. #define VarUI2FromUint      VarUI2FromUI4
  410. #define VarUI4FromInt       VarUI4FromI4
  411. #define VarUI4FromUint      VarUI4FromUI4
  412. #define VarDecFromInt       VarDecFromI4
  413. #define VarDecFromUint      VarDecFromUI4
  414. #define VarIntFromUI1       VarI4FromUI1
  415. #define VarIntFromI2        VarI4FromI2
  416. #define VarIntFromI4        VarI4FromI4
  417. #define VarIntFromR4        VarI4FromR4
  418. #define VarIntFromR8        VarI4FromR8
  419. #define VarIntFromDate      VarI4FromDate
  420. #define VarIntFromCy        VarI4FromCy
  421. #define VarIntFromStr       VarI4FromStr
  422. #define VarIntFromDisp      VarI4FromDisp
  423. #define VarIntFromBool      VarI4FromBool
  424. #define VarIntFromI1        VarI4FromI1
  425. #define VarIntFromUI2       VarI4FromUI2
  426. #define VarIntFromUI4       VarI4FromUI4
  427. #define VarIntFromDec       VarI4FromDec
  428. #define VarIntFromUint      VarI4FromUI4
  429. #define VarUintFromUI1      VarUI4FromUI1
  430. #define VarUintFromI2       VarUI4FromI2
  431. #define VarUintFromI4       VarUI4FromI4
  432. #define VarUintFromR4       VarUI4FromR4
  433. #define VarUintFromR8       VarUI4FromR8
  434. #define VarUintFromDate     VarUI4FromDate
  435. #define VarUintFromCy       VarUI4FromCy
  436. #define VarUintFromStr      VarUI4FromStr
  437. #define VarUintFromDisp     VarUI4FromDisp
  438. #define VarUintFromBool     VarUI4FromBool
  439. #define VarUintFromI1       VarUI4FromI1
  440. #define VarUintFromUI2      VarUI4FromUI2
  441. #define VarUintFromUI4      VarUI4FromUI4
  442. #define VarUintFromDec      VarUI4FromDec
  443. #define VarUintFromInt      VarUI4FromI4
  444.  
  445. /* Mac Note: On the Mac, the coersion functions support the
  446.  * Symantec C++ calling convention for float/double. To support
  447.  * float/double arguments compiled with the MPW C compiler,
  448.  * use the following APIs to move MPW float/double values into
  449.  * a VARIANT.
  450.  */
  451.  
  452. /*---------------------------------------------------------------------*/
  453. /*            New VARIANT <-> string parsing functions                 */
  454. /*---------------------------------------------------------------------*/
  455.  
  456. typedef struct {
  457.     INT   cDig;
  458.     ULONG dwInFlags;
  459.     ULONG dwOutFlags;
  460.     INT   cchUsed;
  461.     INT   nBaseShift;
  462.     INT   nPwr10;
  463. } NUMPARSE;
  464.  
  465. /* flags used by both dwInFlags and dwOutFlags:
  466.  */
  467. #define NUMPRS_LEADING_WHITE    0x0001
  468. #define NUMPRS_TRAILING_WHITE   0x0002
  469. #define NUMPRS_LEADING_PLUS     0x0004
  470. #define NUMPRS_TRAILING_PLUS    0x0008
  471. #define NUMPRS_LEADING_MINUS    0x0010
  472. #define NUMPRS_TRAILING_MINUS   0x0020
  473. #define NUMPRS_HEX_OCT          0x0040
  474. #define NUMPRS_PARENS           0x0080
  475. #define NUMPRS_DECIMAL          0x0100
  476. #define NUMPRS_THOUSANDS        0x0200
  477. #define NUMPRS_CURRENCY         0x0400
  478. #define NUMPRS_EXPONENT         0x0800
  479. #define NUMPRS_USE_ALL          0x1000
  480. #define NUMPRS_STD              0x1FFF
  481.  
  482. /* flags used by dwOutFlags only:
  483.  */
  484. #define NUMPRS_NEG              0x10000
  485. #define NUMPRS_INEXACT          0x20000
  486.  
  487. /* flags used by VarNumFromParseNum to indicate acceptable result types:
  488.  */
  489. #define VTBIT_I1        (1 << VT_I1)
  490. #define VTBIT_UI1       (1 << VT_UI1)
  491. #define VTBIT_I2        (1 << VT_I2)
  492. #define VTBIT_UI2       (1 << VT_UI2)
  493. #define VTBIT_I4        (1 << VT_I4)
  494. #define VTBIT_UI4       (1 << VT_UI4)
  495. #define VTBIT_R4        (1 << VT_R4)
  496. #define VTBIT_R8        (1 << VT_R8)
  497. #define VTBIT_CY        (1 << VT_CY)
  498. #define VTBIT_DECIMAL   (1 << VT_DECIMAL)
  499.  
  500.  
  501. WINOLEAUTAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
  502.             NUMPARSE * pnumprs, BYTE * rgbDig);
  503.  
  504. WINOLEAUTAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
  505.             ULONG dwVtBits, VARIANT * pvar);
  506.  
  507. /*---------------------------------------------------------------------*/
  508. /*                     VARTYPE Math API                                */
  509. /*---------------------------------------------------------------------*/
  510.  
  511. STDAPI VarAdd(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  512. STDAPI VarAnd(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  513. STDAPI VarCat(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  514. STDAPI VarDiv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  515. STDAPI VarEqv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  516. STDAPI VarIdiv(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  517. STDAPI VarImp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  518. STDAPI VarMod(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  519. STDAPI VarMul(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  520. STDAPI VarOr(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  521. STDAPI VarPow(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  522. STDAPI VarSub(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  523. STDAPI VarXor(LPVARIANT pvarLeft, LPVARIANT pvarRight, LPVARIANT pvarResult);
  524.  
  525. STDAPI VarAbs(LPVARIANT pvarIn, LPVARIANT pvarResult);
  526. STDAPI VarFix(LPVARIANT pvarIn, LPVARIANT pvarResult);
  527. STDAPI VarInt(LPVARIANT pvarIn, LPVARIANT pvarResult);
  528. STDAPI VarNeg(LPVARIANT pvarIn, LPVARIANT pvarResult);
  529. STDAPI VarNot(LPVARIANT pvarIn, LPVARIANT pvarResult);
  530.  
  531. STDAPI VarRound(LPVARIANT pvarIn, int cDecimals, LPVARIANT pvarResult);
  532. // dwFlags passed to CompareString if a string compare
  533. STDAPI VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, ULONG dwFlags);
  534.  
  535. #ifdef __cplusplus
  536. extern "C++" {
  537. // Add wrapper for old ATL headers to call
  538. __inline
  539. HRESULT
  540. STDAPICALLTYPE
  541. VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid) {
  542.     return VarCmp(pvarLeft, pvarRight, lcid, 0);
  543. }
  544. } // extern "C++"
  545. #endif
  546.  
  547.  
  548. // Decimal math
  549. //
  550. STDAPI VarDecAdd(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
  551. STDAPI VarDecDiv(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
  552. STDAPI VarDecMul(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
  553. STDAPI VarDecSub(LPDECIMAL pdecLeft, LPDECIMAL pdecRight, LPDECIMAL pdecResult);
  554.  
  555. STDAPI VarDecAbs(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
  556. STDAPI VarDecFix(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
  557. STDAPI VarDecInt(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
  558. STDAPI VarDecNeg(LPDECIMAL pdecIn, LPDECIMAL pdecResult);
  559.  
  560. STDAPI VarDecRound(LPDECIMAL pdecIn, int cDecimals, LPDECIMAL pdecResult);
  561.  
  562. STDAPI VarDecCmp(LPDECIMAL pdecLeft, LPDECIMAL pdecRight);
  563. STDAPI VarDecCmpR8(LPDECIMAL pdecLeft, double dblRight);
  564.  
  565.  
  566. // Currency math
  567. //
  568. STDAPI VarCyAdd(CY cyLeft, CY cyRight, LPCY pcyResult);
  569. STDAPI VarCyMul(CY cyLeft, CY cyRight, LPCY pcyResult);
  570. STDAPI VarCyMulI4(CY cyLeft, long lRight, LPCY pcyResult);
  571. STDAPI VarCySub(CY cyLeft, CY cyRight, LPCY pcyResult);
  572.  
  573. STDAPI VarCyAbs(CY cyIn, LPCY pcyResult);
  574. STDAPI VarCyFix(CY cyIn, LPCY pcyResult);
  575. STDAPI VarCyInt(CY cyIn, LPCY pcyResult);
  576. STDAPI VarCyNeg(CY cyIn, LPCY pcyResult);
  577.  
  578. STDAPI VarCyRound(CY cyIn, int cDecimals, LPCY pcyResult);
  579.  
  580. STDAPI VarCyCmp(CY cyLeft, CY cyRight);
  581. STDAPI VarCyCmpR8(CY cyLeft, double dblRight);
  582.  
  583.  
  584. // Misc support functions
  585. //
  586. STDAPI VarBstrCat(BSTR bstrLeft, BSTR bstrRight, LPBSTR pbstrResult);
  587. STDAPI VarBstrCmp(BSTR bstrLeft, BSTR bstrRight, LCID lcid, ULONG dwFlags); // dwFlags passed to CompareString
  588. STDAPI VarR8Pow(double dblLeft, double dblRight, double *pdblResult);
  589. STDAPI VarR4CmpR8(float fltLeft, double dblRight);
  590. STDAPI VarR8Round(double dblIn, int cDecimals, double *pdblResult);
  591.  
  592.  
  593. // Compare results.  These are returned as a SUCCESS HResult.  Subtracting
  594. // one gives the usual values of -1 for Less Than, 0 for Equal To, +1 for
  595. // Greater Than.
  596. //
  597. #define VARCMP_LT   0
  598. #define VARCMP_EQ   1
  599. #define VARCMP_GT   2
  600. #define VARCMP_NULL 3
  601.  
  602. // VT_HARDTYPE tells the compare routine that the argument is a literal or
  603. // otherwise declared of that specific type.  It causes comparison rules to
  604. // change. For example, if a hard-type string is compared to a variant (not hard
  605. // -type) number, the number is converted to string.  If a hard-type number is
  606. // compared to a variant string, the string is converted to number.  If they're
  607. // both variant, then number < string.
  608. #define VT_HARDTYPE VT_RESERVED
  609.  
  610. /*---------------------------------------------------------------------*/
  611. /*                   New date functions                                */
  612. /*---------------------------------------------------------------------*/
  613.  
  614. /* The UDATE structure is used with VarDateFromUdate() and VarUdateFromDate().
  615.  * It represents an "unpacked date".
  616.  */
  617. typedef struct {
  618.     SYSTEMTIME st;
  619.     USHORT  wDayOfYear;
  620. } UDATE;
  621.  
  622. /* APIs to "pack" and "unpack" dates.
  623.  * NOTE: Ex version of VarDateFromUdate obeys 2 digit year setting in
  624.  * control panel.
  625.  */
  626. WINOLEAUTAPI VarDateFromUdate(UDATE *pudateIn, ULONG dwFlags, DATE *pdateOut);
  627. WINOLEAUTAPI VarDateFromUdateEx(UDATE *pudateIn, LCID lcid, ULONG dwFlags, DATE *pdateOut);
  628. WINOLEAUTAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *pudateOut);
  629.  
  630. /* API to retrieve the secondary(altername) month names
  631.    Useful for Hijri, Polish and Russian alternate month names
  632. */
  633. WINOLEAUTAPI GetAltMonthNames(LCID lcid, LPOLESTR * * prgp);
  634.  
  635. /*---------------------------------------------------------------------*/
  636. /*                 Format                                              */
  637. /*---------------------------------------------------------------------*/
  638.  
  639. WINOLEAUTAPI VarFormat(LPVARIANT pvarIn, LPOLESTR pstrFormat, int iFirstDay, int iFirstWeek, ULONG dwFlags, BSTR *pbstrOut);
  640. WINOLEAUTAPI VarFormatDateTime(LPVARIANT pvarIn, int iNamedFormat, ULONG dwFlags, BSTR *pbstrOut);
  641. WINOLEAUTAPI VarFormatNumber(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
  642. WINOLEAUTAPI VarFormatPercent(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
  643. WINOLEAUTAPI VarFormatCurrency(LPVARIANT pvarIn, int iNumDig, int iIncLead, int iUseParens, int iGroup, ULONG dwFlags, BSTR *pbstrOut);
  644.  
  645. WINOLEAUTAPI VarWeekdayName(int iWeekday, int fAbbrev, int iFirstDay, ULONG dwFlags, BSTR *pbstrOut);
  646. WINOLEAUTAPI VarMonthName(int iMonth, int fAbbrev, ULONG dwFlags, BSTR *pbstrOut);
  647.  
  648. WINOLEAUTAPI VarFormatFromTokens(LPVARIANT pvarIn, LPOLESTR pstrFormat, LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut, LCID lcid);
  649. WINOLEAUTAPI VarTokenizeFormatString(LPOLESTR pstrFormat, LPBYTE rgbTok, int cbTok, int iFirstDay, int iFirstWeek, LCID lcid, int *pcbActual);
  650.  
  651. /*---------------------------------------------------------------------*/
  652. /*                 ITypeLib                                            */
  653. /*---------------------------------------------------------------------*/
  654.  
  655. typedef ITypeLib * LPTYPELIB;
  656.  
  657.  
  658. /*---------------------------------------------------------------------*/
  659. /*                ITypeInfo                                            */
  660. /*---------------------------------------------------------------------*/
  661.  
  662.  
  663. typedef LONG DISPID;
  664. typedef DISPID MEMBERID;
  665.  
  666. #define MEMBERID_NIL DISPID_UNKNOWN
  667. #define ID_DEFAULTINST  -2
  668.  
  669.  
  670. /* Flags for IDispatch::Invoke */
  671. #define DISPATCH_METHOD         0x1
  672. #define DISPATCH_PROPERTYGET    0x2
  673. #define DISPATCH_PROPERTYPUT    0x4
  674. #define DISPATCH_PROPERTYPUTREF 0x8
  675.  
  676. typedef ITypeInfo * LPTYPEINFO;
  677.  
  678.  
  679. /*---------------------------------------------------------------------*/
  680. /*                ITypeComp                                            */
  681. /*---------------------------------------------------------------------*/
  682.  
  683. typedef ITypeComp * LPTYPECOMP;
  684.  
  685.  
  686. /*---------------------------------------------------------------------*/
  687. /*             ICreateTypeLib                                          */
  688. /*---------------------------------------------------------------------*/
  689.  
  690. typedef ICreateTypeLib * LPCREATETYPELIB;
  691.  
  692. typedef ICreateTypeInfo * LPCREATETYPEINFO;
  693.  
  694. /*---------------------------------------------------------------------*/
  695. /*             TypeInfo API                                            */
  696. /*---------------------------------------------------------------------*/
  697.  
  698. /* compute a 16bit hash value for the given name
  699.  */
  700. #ifdef _WIN32
  701. WINOLEAUTAPI_(ULONG) LHashValOfNameSysA(SYSKIND syskind, LCID lcid,
  702.             LPCSTR szName);
  703. #endif
  704.  
  705. WINOLEAUTAPI_(ULONG)
  706. LHashValOfNameSys(SYSKIND syskind, LCID lcid, const OLECHAR * szName);
  707.  
  708. #define LHashValOfName(lcid, szName) \
  709.             LHashValOfNameSys(SYS_WIN32, lcid, szName)
  710.  
  711. #define WHashValOfLHashVal(lhashval) \
  712.             ((USHORT) (0x0000ffff & (lhashval)))
  713.  
  714. #define IsHashValCompatible(lhashval1, lhashval2) \
  715.             ((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2))))
  716.  
  717. /* load the typelib from the file with the given filename
  718.  */
  719. WINOLEAUTAPI LoadTypeLib(const OLECHAR  *szFile, ITypeLib ** pptlib);
  720.  
  721. /* Control how a type library is registered
  722.  */
  723. typedef enum tagREGKIND
  724. {
  725.     REGKIND_DEFAULT,
  726.     REGKIND_REGISTER,
  727.     REGKIND_NONE
  728. } REGKIND;
  729.  
  730. WINOLEAUTAPI LoadTypeLibEx(LPCOLESTR szFile, REGKIND regkind,
  731.             ITypeLib ** pptlib);
  732.  
  733. /* load registered typelib
  734.  */
  735. WINOLEAUTAPI LoadRegTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor,
  736.             LCID lcid, ITypeLib ** pptlib);
  737.  
  738. /* get path to registered typelib
  739.  */
  740. WINOLEAUTAPI QueryPathOfRegTypeLib(REFGUID guid, USHORT wMaj, USHORT wMin,
  741.             LCID lcid, LPBSTR lpbstrPathName);
  742.  
  743. /* add typelib to registry
  744.  */
  745. WINOLEAUTAPI RegisterTypeLib(ITypeLib * ptlib, OLECHAR  *szFullPath,
  746.             OLECHAR  *szHelpDir);
  747.  
  748. /* remove typelib from registry
  749.  */
  750.  
  751. WINOLEAUTAPI UnRegisterTypeLib(REFGUID libID, WORD wVerMajor,
  752.             WORD wVerMinor, LCID lcid, SYSKIND syskind);
  753.  
  754. WINOLEAUTAPI CreateTypeLib(SYSKIND syskind, const OLECHAR  *szFile,
  755.             ICreateTypeLib ** ppctlib);
  756.  
  757. WINOLEAUTAPI CreateTypeLib2(SYSKIND syskind, LPCOLESTR szFile,
  758.             ICreateTypeLib2 **ppctlib);
  759.  
  760.  
  761. /*---------------------------------------------------------------------*/
  762. /*           IDispatch implementation support                          */
  763. /*---------------------------------------------------------------------*/
  764.  
  765. typedef IDispatch * LPDISPATCH;
  766.  
  767. typedef struct tagPARAMDATA {
  768.     OLECHAR * szName;   /* parameter name */
  769.     VARTYPE vt;         /* parameter type */
  770. } PARAMDATA, * LPPARAMDATA;
  771.  
  772. typedef struct tagMETHODDATA {
  773.     OLECHAR * szName;   /* method name */
  774.     PARAMDATA * ppdata; /* pointer to an array of PARAMDATAs */
  775.     DISPID dispid;      /* method ID */
  776.     UINT iMeth;         /* method index */
  777.     CALLCONV cc;        /* calling convention */
  778.     UINT cArgs;         /* count of arguments */
  779.     WORD wFlags;        /* same wFlags as on IDispatch::Invoke() */
  780.     VARTYPE vtReturn;
  781. } METHODDATA, * LPMETHODDATA;
  782.  
  783. typedef struct tagINTERFACEDATA {
  784.     METHODDATA * pmethdata;  /* pointer to an array of METHODDATAs */
  785.     UINT cMembers;      /* count of members */
  786. } INTERFACEDATA, * LPINTERFACEDATA;
  787.  
  788.  
  789.  
  790. /* Locate the parameter indicated by the given position, and
  791.  * return it coerced to the given target VARTYPE (vtTarg).
  792.  */
  793. WINOLEAUTAPI DispGetParam(DISPPARAMS * pdispparams, UINT position,
  794.             VARTYPE vtTarg, VARIANT * pvarResult, UINT * puArgErr);
  795.  
  796. /* Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames()
  797.  */
  798. WINOLEAUTAPI DispGetIDsOfNames(ITypeInfo * ptinfo, OLECHAR ** rgszNames,
  799.             UINT cNames, DISPID * rgdispid);
  800.  
  801. /* Automatic TypeInfo driven implementation of IDispatch::Invoke()
  802.  */
  803. WINOLEAUTAPI DispInvoke(void * _this, ITypeInfo * ptinfo, DISPID dispidMember,
  804.             WORD wFlags, DISPPARAMS * pparams, VARIANT * pvarResult,
  805.             EXCEPINFO * pexcepinfo, UINT * puArgErr);
  806.  
  807. /* Construct a TypeInfo from an interface data description
  808.  */
  809. WINOLEAUTAPI CreateDispTypeInfo(INTERFACEDATA * pidata, LCID lcid,
  810.             ITypeInfo ** pptinfo);
  811.  
  812. /* Create an instance of the standard TypeInfo driven IDispatch
  813.  * implementation.
  814.  */
  815. WINOLEAUTAPI CreateStdDispatch(IUnknown * punkOuter, void * pvThis,
  816.             ITypeInfo * ptinfo, IUnknown ** ppunkStdDisp);
  817.  
  818. /* Low-level helper for IDispatch::Invoke() provides machine independence
  819.  * for customized Invoke().
  820.  */
  821. WINOLEAUTAPI DispCallFunc(void * pvInstance, ULONG oVft, CALLCONV cc,
  822.             VARTYPE vtReturn, UINT  cActuals, VARTYPE * prgvt,
  823.             VARIANTARG ** prgpvarg, VARIANT * pvargResult);
  824.  
  825.  
  826. /*---------------------------------------------------------------------*/
  827. /*            Active Object Registration API                           */
  828. /*---------------------------------------------------------------------*/
  829.  
  830. /* flags for RegisterActiveObject */
  831. #define ACTIVEOBJECT_STRONG 0x0
  832. #define ACTIVEOBJECT_WEAK 0x1
  833.  
  834. WINOLEAUTAPI RegisterActiveObject(IUnknown * punk, REFCLSID rclsid,
  835.             DWORD dwFlags, DWORD * pdwRegister);
  836.  
  837. WINOLEAUTAPI RevokeActiveObject(DWORD dwRegister, void * pvReserved);
  838.  
  839. WINOLEAUTAPI GetActiveObject(REFCLSID rclsid, void * pvReserved,
  840.             IUnknown ** ppunk);
  841.  
  842. /*---------------------------------------------------------------------*/
  843. /*                           ErrorInfo API                             */
  844. /*---------------------------------------------------------------------*/
  845.  
  846. WINOLEAUTAPI SetErrorInfo(ULONG dwReserved, IErrorInfo * perrinfo);
  847. WINOLEAUTAPI GetErrorInfo(ULONG dwReserved, IErrorInfo ** pperrinfo);
  848. WINOLEAUTAPI CreateErrorInfo(ICreateErrorInfo ** pperrinfo);
  849.  
  850. /*---------------------------------------------------------------------*/
  851. /*           User Defined Data types support                           */
  852. /*---------------------------------------------------------------------*/
  853.  
  854. WINOLEAUTAPI GetRecordInfoFromTypeInfo(ITypeInfo * pTypeInfo,
  855.             IRecordInfo ** ppRecInfo);
  856.  
  857. WINOLEAUTAPI GetRecordInfoFromGuids(REFGUID rGuidTypeLib,
  858.             ULONG uVerMajor, ULONG uVerMinor, LCID lcid,
  859.             REFGUID rGuidTypeInfo, IRecordInfo ** ppRecInfo);
  860.  
  861. /*---------------------------------------------------------------------*/
  862. /*                           MISC API                                  */
  863. /*---------------------------------------------------------------------*/
  864.  
  865. WINOLEAUTAPI_(ULONG) OaBuildVersion(void);
  866.  
  867. WINOLEAUTAPI_(void) ClearCustData(LPCUSTDATA pCustData);
  868.  
  869. // Declare variant access functions.
  870.  
  871. #if __STDC__ || defined(NONAMELESSUNION)
  872. #define V_UNION(X, Y)   ((X)->n1.n2.n3.Y)
  873. #define V_VT(X)         ((X)->n1.n2.vt)
  874. #define V_RECORDINFO(X) ((X)->n1.n2.n3.brecVal.pRecInfo)
  875. #define V_RECORD(X)     ((X)->n1.n2.n3.brecVal.pvRecord)
  876. #else
  877. #define V_UNION(X, Y)   ((X)->Y)
  878. #define V_VT(X)         ((X)->vt)
  879. #define V_RECORDINFO(X) ((X)->pRecInfo)
  880. #define V_RECORD(X)     ((X)->pvRecord)
  881. #endif
  882.  
  883. /* Variant access macros
  884.  */
  885. #define V_ISBYREF(X)     (V_VT(X)&VT_BYREF)
  886. #define V_ISARRAY(X)     (V_VT(X)&VT_ARRAY)
  887. #define V_ISVECTOR(X)    (V_VT(X)&VT_VECTOR)
  888. #define V_NONE(X)        V_I2(X)
  889.  
  890. #define V_UI1(X)         V_UNION(X, bVal)
  891. #define V_UI1REF(X)      V_UNION(X, pbVal)
  892. #define V_I2(X)          V_UNION(X, iVal)
  893. #define V_I2REF(X)       V_UNION(X, piVal)
  894. #define V_I4(X)          V_UNION(X, lVal)
  895. #define V_I4REF(X)       V_UNION(X, plVal)
  896. #define V_I8(X)          V_UNION(X, llVal)
  897. #define V_I8REF(X)       V_UNION(X, pllVal)
  898. #define V_R4(X)          V_UNION(X, fltVal)
  899. #define V_R4REF(X)       V_UNION(X, pfltVal)
  900. #define V_R8(X)          V_UNION(X, dblVal)
  901. #define V_R8REF(X)       V_UNION(X, pdblVal)
  902. #define V_I1(X)          V_UNION(X, cVal)
  903. #define V_I1REF(X)       V_UNION(X, pcVal)
  904. #define V_UI2(X)         V_UNION(X, uiVal)
  905. #define V_UI2REF(X)      V_UNION(X, puiVal)
  906. #define V_UI4(X)         V_UNION(X, ulVal)
  907. #define V_UI4REF(X)      V_UNION(X, pulVal)
  908. #define V_UI8(X)         V_UNION(X, ullVal)
  909. #define V_UI8REF(X)      V_UNION(X, pullVal)
  910. #define V_INT(X)         V_UNION(X, intVal)
  911. #define V_INTREF(X)      V_UNION(X, pintVal)
  912. #define V_UINT(X)        V_UNION(X, uintVal)
  913. #define V_UINTREF(X)     V_UNION(X, puintVal)
  914. #define V_CY(X)          V_UNION(X, cyVal)
  915. #define V_CYREF(X)       V_UNION(X, pcyVal)
  916. #define V_DATE(X)        V_UNION(X, date)
  917. #define V_DATEREF(X)     V_UNION(X, pdate)
  918. #define V_BSTR(X)        V_UNION(X, bstrVal)
  919. #define V_BSTRREF(X)     V_UNION(X, pbstrVal)
  920. #define V_DISPATCH(X)    V_UNION(X, pdispVal)
  921. #define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
  922. #define V_ERROR(X)       V_UNION(X, scode)
  923. #define V_ERRORREF(X)    V_UNION(X, pscode)
  924. #define V_BOOL(X)        V_UNION(X, boolVal)
  925. #define V_BOOLREF(X)     V_UNION(X, pboolVal)
  926. #define V_UNKNOWN(X)     V_UNION(X, punkVal)
  927. #define V_UNKNOWNREF(X)  V_UNION(X, ppunkVal)
  928. #define V_VARIANTREF(X)  V_UNION(X, pvarVal)
  929. #define V_ARRAY(X)       V_UNION(X, parray)
  930. #define V_ARRAYREF(X)    V_UNION(X, pparray)
  931. #define V_BYREF(X)       V_UNION(X, byref)
  932.  
  933. #define V_DECIMAL(X)     V_UNION(X, decVal)
  934. #define V_DECIMALREF(X)  V_UNION(X, pdecVal)
  935.  
  936. #ifndef RC_INVOKED
  937. #include <poppack.h>
  938. #endif // RC_INVOKED
  939.  
  940. #pragma option pop /*P_O_Pop*/
  941. #endif     // __OLEAUTO_H__
  942.