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