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