home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / DEV.Z / OLEAUTO.H < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-08  |  23.5 KB  |  710 lines
  1. #if !defined(__TOPLEVEL_NEXT_COMMON_INCLUDE__)
  2. #define __TOPLEVEL_NEXT_COMMON_INCLUDE__
  3. #define __TOPLEVEL_OLEAUTO_H_ 
  4. #include <next_common_defines.h>
  5. #endif /* __TOPLEVEL_NEXT_COMMON_INCLUDE__ */
  6.  
  7. //+---------------------------------------------------------------------------
  8. //
  9. //  Microsoft Windows
  10. //  Copyright (C) Microsoft Corporation, 1992 - 1995.
  11. //
  12. //  File:       oleauto.h
  13. //
  14. //  Contents:   Defines the Ole Automation interfaces and APIs.
  15. //
  16. //  Interfaces:
  17. //      IDispatch;
  18. //      ITypeInfo;
  19. //      ITypeLib;
  20. //      ITypeComp;
  21. //      ICreateTypeInfo;
  22. //      ICreateTypeLib;
  23. //      IErrorInfo;
  24. //      ICreateErrorInfo;
  25. //      ISupportErrorInfo;
  26. //
  27. //  Functions:  SysAllocString         BSTR API
  28. //      SysReAllocString
  29. //      SysAllocStringLen
  30. //      SysReAllocStringLen
  31. //      SysFreeString
  32. //      SysStringLen
  33. //      DosDateTimeToVariantTime    Time API
  34. //      VariantTimeToDosDateTime
  35. //      SafeArrayCreate         Safe Array API
  36. //      SafeArrayDestroy
  37. //      SafeArrayGetDim
  38. //      SafeArrayGetElemsize
  39. //      SafeArrayGetUBound
  40. //      SafeArrayGetLBound
  41. //      SafeArrayLock
  42. //      SafeArrayUnlock
  43. //      SafeArrayAccessData
  44. //      SafeArrayUnaccessData
  45. //      SafeArrayGetElement
  46. //      SafeArrayPutElement
  47. //      SafeArrayCopy
  48. //      VariantInit         Variant API
  49. //      VariantClear
  50. //      VariantCopy
  51. //      VariantCopyInd
  52. //      VariantChangeType
  53. //      LHashValOfName          TypeInfo API
  54. //      LoadTypeLib
  55. //      LoadRegTypeLib
  56. //      RegisterTypeLib
  57. //      DeregisterTypeLib
  58. //      CreateTypeLib
  59. //      DispGetParam            Dispatch API
  60. //      DispGetIDsOfNames
  61. //      DispInvoke
  62. //      CreateDispTypeInfo
  63. //      CreateStdDispatch
  64. //      RegisterActiveObject        Active Object Registration API
  65. //      RevokeActiveObject
  66. //      GetActiveObject
  67. //      OaBuildVersion
  68. //
  69. //----------------------------------------------------------------------------
  70.  
  71. #if !defined( _OLEAUTO_H_ )
  72. #define _OLEAUTO_H_
  73.  
  74. // Set packing to 8 for ISV, and Win95 support
  75. #ifndef RC_INVOKED
  76. #include <pshpack8.h>
  77. #endif // RC_INVOKED
  78.  
  79. //  Definition of the OLE Automation APIs, and macros.
  80.  
  81. #ifdef _OLEAUT32_
  82. #define WINOLEAUTAPI        STDAPI
  83. #define WINOLEAUTAPI_(type) STDAPI_(type)
  84. #else
  85. #define WINOLEAUTAPI        EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
  86. #define WINOLEAUTAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
  87. #endif
  88.  
  89. #define STDOLE_MAJORVERNUM              0x1
  90. #define STDOLE_MINORVERNUM              0x0
  91. #define STDOLE_LCID                     0x0000
  92.  
  93. /* if not already picked up from olenls.h */
  94. #ifndef _LCID_DEFINED
  95. typedef DWORD LCID;
  96. # define _LCID_DEFINED
  97. #endif
  98.  
  99. /* pull in the MIDL generated header */
  100. #include <oaidl.h>
  101.  
  102.  
  103. /*---------------------------------------------------------------------*/
  104. /*                            BSTR API                                 */
  105. /*---------------------------------------------------------------------*/
  106.  
  107. WINOLEAUTAPI_(BSTR) SysAllocString(const OLECHAR FAR*);
  108. WINOLEAUTAPI_(int)  SysReAllocString(BSTR FAR*, const OLECHAR FAR*);
  109. WINOLEAUTAPI_(BSTR) SysAllocStringLen(const OLECHAR FAR*, unsigned int);
  110. WINOLEAUTAPI_(int)  SysReAllocStringLen(BSTR FAR*, const OLECHAR FAR*, unsigned int);
  111. WINOLEAUTAPI_(void) SysFreeString(BSTR);
  112. WINOLEAUTAPI_(unsigned int) SysStringLen(BSTR);
  113.  
  114. #ifdef _WIN32
  115. WINOLEAUTAPI_(unsigned int) SysStringByteLen(BSTR bstr);
  116. WINOLEAUTAPI_(BSTR) SysAllocStringByteLen(const char FAR* psz, unsigned int len);
  117. #endif
  118.  
  119. /*---------------------------------------------------------------------*/
  120. /*                            Time API                                 */
  121. /*---------------------------------------------------------------------*/
  122.  
  123. WINOLEAUTAPI_(int)
  124. DosDateTimeToVariantTime(
  125.     unsigned short wDosDate,
  126.     unsigned short wDosTime,
  127.     double FAR* pvtime);
  128.  
  129. WINOLEAUTAPI_(int)
  130. VariantTimeToDosDateTime(
  131.     double vtime,
  132.     unsigned short FAR* pwDosDate,
  133.     unsigned short FAR* pwDosTime);
  134.  
  135. /*---------------------------------------------------------------------*/
  136. /*                          SafeArray API                              */
  137. /*---------------------------------------------------------------------*/
  138.  
  139. WINOLEAUTAPI
  140. SafeArrayAllocDescriptor(unsigned int cDims, SAFEARRAY FAR* FAR* ppsaOut);
  141.  
  142. WINOLEAUTAPI SafeArrayAllocData(SAFEARRAY FAR* psa);
  143.  
  144. WINOLEAUTAPI_(SAFEARRAY FAR*)
  145. SafeArrayCreate(
  146.     VARTYPE vt,
  147.     unsigned int cDims,
  148.     SAFEARRAYBOUND FAR* rgsabound);
  149.  
  150. WINOLEAUTAPI SafeArrayDestroyDescriptor(SAFEARRAY FAR* psa);
  151.  
  152. WINOLEAUTAPI SafeArrayDestroyData(SAFEARRAY FAR* psa);
  153.  
  154. WINOLEAUTAPI SafeArrayDestroy(SAFEARRAY FAR* psa);
  155.  
  156. WINOLEAUTAPI SafeArrayRedim(SAFEARRAY FAR* psa, SAFEARRAYBOUND FAR* psaboundNew);
  157.  
  158. WINOLEAUTAPI_(unsigned int) SafeArrayGetDim(SAFEARRAY FAR* psa);
  159.  
  160. WINOLEAUTAPI_(unsigned int) SafeArrayGetElemsize(SAFEARRAY FAR* psa);
  161.  
  162. WINOLEAUTAPI
  163. SafeArrayGetUBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plUbound);
  164.  
  165. WINOLEAUTAPI
  166. SafeArrayGetLBound(SAFEARRAY FAR* psa, unsigned int nDim, long FAR* plLbound);
  167.  
  168. WINOLEAUTAPI SafeArrayLock(SAFEARRAY FAR* psa);
  169.  
  170. WINOLEAUTAPI SafeArrayUnlock(SAFEARRAY FAR* psa);
  171.  
  172. WINOLEAUTAPI SafeArrayAccessData(SAFEARRAY FAR* psa, void HUGEP* FAR* ppvData);
  173.  
  174. WINOLEAUTAPI SafeArrayUnaccessData(SAFEARRAY FAR* psa);
  175.  
  176. WINOLEAUTAPI
  177. SafeArrayGetElement(
  178.     SAFEARRAY FAR* psa,
  179.     long FAR* rgIndices,
  180.     void FAR* pv);
  181.  
  182. WINOLEAUTAPI
  183. SafeArrayPutElement(
  184.     SAFEARRAY FAR* psa,
  185.     long FAR* rgIndices,
  186.     void FAR* pv);
  187.  
  188. WINOLEAUTAPI
  189. SafeArrayCopy(
  190.     SAFEARRAY FAR* psa,
  191.     SAFEARRAY FAR* FAR* ppsaOut);
  192.  
  193. WINOLEAUTAPI
  194. SafeArrayPtrOfIndex(
  195.     SAFEARRAY FAR* psa,
  196.     long FAR* rgIndices,
  197.     void HUGEP* FAR* ppvData);
  198.  
  199.  
  200. /*---------------------------------------------------------------------*/
  201. /*                           VARIANT API                               */
  202. /*---------------------------------------------------------------------*/
  203.  
  204. WINOLEAUTAPI_(void)
  205. VariantInit(VARIANTARG FAR* pvarg);
  206.  
  207. WINOLEAUTAPI
  208. VariantClear(VARIANTARG FAR* pvarg);
  209.  
  210. WINOLEAUTAPI
  211. VariantCopy(
  212.     VARIANTARG FAR* pvargDest,
  213.     VARIANTARG FAR* pvargSrc);
  214.  
  215. WINOLEAUTAPI
  216. VariantCopyInd(
  217.     VARIANT FAR* pvarDest,
  218.     VARIANTARG FAR* pvargSrc);
  219.  
  220. WINOLEAUTAPI
  221. VariantChangeType(
  222.     VARIANTARG FAR* pvargDest,
  223.     VARIANTARG FAR* pvarSrc,
  224.     unsigned short wFlags,
  225.     VARTYPE vt);
  226.  
  227. WINOLEAUTAPI
  228. VariantChangeTypeEx(
  229.     VARIANTARG FAR* pvargDest,
  230.     VARIANTARG FAR* pvarSrc,
  231.     LCID lcid,
  232.     unsigned short wFlags,
  233.     VARTYPE vt);
  234.  
  235. #define VARIANT_NOVALUEPROP 1
  236.  
  237.  
  238. /*---------------------------------------------------------------------*/
  239. /*                     VARTYPE Coercion API                            */
  240. /*---------------------------------------------------------------------*/
  241.  
  242. /* Note: The routines that convert *from* a string are defined
  243.  * to take a OLECHAR* rather than a BSTR because no allocation is
  244.  * required, and this makes the routines a bit more generic.
  245.  * They may of course still be passed a BSTR as the strIn param.
  246.  */
  247.  
  248.  
  249. /* Any of the coersion functions that converts either from or to a string
  250.  * takes an additional lcid and dwFlags arguments. The lcid argument allows
  251.  * locale specific parsing to occur.  The dwFlags allow additional function
  252.  * specific condition to occur.  All function that accept the dwFlags argument
  253.  * can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  254.  * VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and
  255.  * VAR_DATEVALUEONLY flags
  256.  */
  257.  
  258. #define VAR_TIMEVALUEONLY            0x0001    /* return time value */
  259. #define VAR_DATEVALUEONLY            0x0002    /* return date value */
  260.  
  261.  
  262. WINOLEAUTAPI VarUI1FromI2(short sIn, unsigned char FAR* pbOut);
  263. WINOLEAUTAPI VarUI1FromI4(long lIn, unsigned char FAR* pbOut);
  264. WINOLEAUTAPI VarUI1FromR4(float fltIn, unsigned char FAR* pbOut);
  265. WINOLEAUTAPI VarUI1FromR8(double dblIn, unsigned char FAR* pbOut);
  266. WINOLEAUTAPI VarUI1FromCy(CY cyIn, unsigned char FAR* pbOut);
  267. WINOLEAUTAPI VarUI1FromDate(DATE dateIn, unsigned char FAR* pbOut);
  268. WINOLEAUTAPI VarUI1FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, unsigned char FAR* pbOut);
  269. WINOLEAUTAPI VarUI1FromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned char FAR* pbOut);
  270. WINOLEAUTAPI VarUI1FromBool(VARIANT_BOOL boolIn, unsigned char FAR* pbOut);
  271.  
  272. WINOLEAUTAPI VarI2FromUI1(unsigned char bIn, short FAR* psOut);
  273. WINOLEAUTAPI VarI2FromI4(long lIn, short FAR* psOut);
  274. WINOLEAUTAPI VarI2FromR4(float fltIn, short FAR* psOut);
  275. WINOLEAUTAPI VarI2FromR8(double dblIn, short FAR* psOut);
  276. WINOLEAUTAPI VarI2FromCy(CY cyIn, short FAR* psOut);
  277. WINOLEAUTAPI VarI2FromDate(DATE dateIn, short FAR* psOut);
  278. WINOLEAUTAPI VarI2FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, short FAR* psOut);
  279. WINOLEAUTAPI VarI2FromDisp(IDispatch FAR* pdispIn, LCID lcid, short FAR* psOut);
  280. WINOLEAUTAPI VarI2FromBool(VARIANT_BOOL boolIn, short FAR* psOut);
  281.  
  282. WINOLEAUTAPI VarI4FromUI1(unsigned char bIn, long FAR* plOut);
  283. WINOLEAUTAPI VarI4FromI2(short sIn, long FAR* plOut);
  284. WINOLEAUTAPI VarI4FromR4(float fltIn, long FAR* plOut);
  285. WINOLEAUTAPI VarI4FromR8(double dblIn, long FAR* plOut);
  286. WINOLEAUTAPI VarI4FromCy(CY cyIn, long FAR* plOut);
  287. WINOLEAUTAPI VarI4FromDate(DATE dateIn, long FAR* plOut);
  288. WINOLEAUTAPI VarI4FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, long FAR* plOut);
  289. WINOLEAUTAPI VarI4FromDisp(IDispatch FAR* pdispIn, LCID lcid, long FAR* plOut);
  290. WINOLEAUTAPI VarI4FromBool(VARIANT_BOOL boolIn, long FAR* plOut);
  291.  
  292. WINOLEAUTAPI VarR4FromUI1(unsigned char bIn, float FAR* pfltOut);
  293. WINOLEAUTAPI VarR4FromI2(short sIn, float FAR* pfltOut);
  294. WINOLEAUTAPI VarR4FromI4(long lIn, float FAR* pfltOut);
  295. WINOLEAUTAPI VarR4FromR8(double dblIn, float FAR* pfltOut);
  296. WINOLEAUTAPI VarR4FromCy(CY cyIn, float FAR* pfltOut);
  297. WINOLEAUTAPI VarR4FromDate(DATE dateIn, float FAR* pfltOut);
  298. WINOLEAUTAPI VarR4FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, float FAR* pfltOut);
  299. WINOLEAUTAPI VarR4FromDisp(IDispatch FAR* pdispIn, LCID lcid, float FAR* pfltOut);
  300. WINOLEAUTAPI VarR4FromBool(VARIANT_BOOL boolIn, float FAR* pfltOut);
  301.  
  302. WINOLEAUTAPI VarR8FromUI1(unsigned char bIn, double FAR* pdblOut);
  303. WINOLEAUTAPI VarR8FromI2(short sIn, double FAR* pdblOut);
  304. WINOLEAUTAPI VarR8FromI4(long lIn, double FAR* pdblOut);
  305. WINOLEAUTAPI VarR8FromR4(float fltIn, double FAR* pdblOut);
  306. WINOLEAUTAPI VarR8FromCy(CY cyIn, double FAR* pdblOut);
  307. WINOLEAUTAPI VarR8FromDate(DATE dateIn, double FAR* pdblOut);
  308. WINOLEAUTAPI VarR8FromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, double FAR* pdblOut);
  309. WINOLEAUTAPI VarR8FromDisp(IDispatch FAR* pdispIn, LCID lcid, double FAR* pdblOut);
  310. WINOLEAUTAPI VarR8FromBool(VARIANT_BOOL boolIn, double FAR* pdblOut);
  311.  
  312. WINOLEAUTAPI VarDateFromUI1(unsigned char bIn, DATE FAR* pdateOut);
  313. WINOLEAUTAPI VarDateFromI2(short sIn, DATE FAR* pdateOut);
  314. WINOLEAUTAPI VarDateFromI4(long lIn, DATE FAR* pdateOut);
  315. WINOLEAUTAPI VarDateFromR4(float fltIn, DATE FAR* pdateOut);
  316. WINOLEAUTAPI VarDateFromR8(double dblIn, DATE FAR* pdateOut);
  317. WINOLEAUTAPI VarDateFromCy(CY cyIn, DATE FAR* pdateOut);
  318. WINOLEAUTAPI VarDateFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, DATE FAR* pdateOut);
  319. WINOLEAUTAPI VarDateFromDisp(IDispatch FAR* pdispIn, LCID lcid, DATE FAR* pdateOut);
  320. WINOLEAUTAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE FAR* pdateOut);
  321.  
  322. WINOLEAUTAPI VarCyFromUI1(unsigned char bIn, CY FAR* pcyOut);
  323. WINOLEAUTAPI VarCyFromI2(short sIn, CY FAR* pcyOut);
  324. WINOLEAUTAPI VarCyFromI4(long lIn, CY FAR* pcyOut);
  325. WINOLEAUTAPI VarCyFromR4(float fltIn, CY FAR* pcyOut);
  326. WINOLEAUTAPI VarCyFromR8(double dblIn, CY FAR* pcyOut);
  327. WINOLEAUTAPI VarCyFromDate(DATE dateIn, CY FAR* pcyOut);
  328. WINOLEAUTAPI VarCyFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, CY FAR* pcyOut);
  329. WINOLEAUTAPI VarCyFromDisp(IDispatch FAR* pdispIn, LCID lcid, CY FAR* pcyOut);
  330. WINOLEAUTAPI VarCyFromBool(VARIANT_BOOL boolIn, CY FAR* pcyOut);
  331.  
  332. WINOLEAUTAPI VarBstrFromUI1(unsigned char bVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  333. WINOLEAUTAPI VarBstrFromI2(short iVal, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  334. WINOLEAUTAPI VarBstrFromI4(long lIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  335. WINOLEAUTAPI VarBstrFromR4(float fltIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  336. WINOLEAUTAPI VarBstrFromR8(double dblIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  337. WINOLEAUTAPI VarBstrFromCy(CY cyIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  338. WINOLEAUTAPI VarBstrFromDate(DATE dateIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  339. WINOLEAUTAPI VarBstrFromDisp(IDispatch FAR* pdispIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  340. WINOLEAUTAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, unsigned long dwFlags, BSTR FAR* pbstrOut);
  341.  
  342. WINOLEAUTAPI VarBoolFromUI1(unsigned char bIn, VARIANT_BOOL FAR* pboolOut);
  343. WINOLEAUTAPI VarBoolFromI2(short sIn, VARIANT_BOOL FAR* pboolOut);
  344. WINOLEAUTAPI VarBoolFromI4(long lIn, VARIANT_BOOL FAR* pboolOut);
  345. WINOLEAUTAPI VarBoolFromR4(float fltIn, VARIANT_BOOL FAR* pboolOut);
  346. WINOLEAUTAPI VarBoolFromR8(double dblIn, VARIANT_BOOL FAR* pboolOut);
  347. WINOLEAUTAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL FAR* pboolOut);
  348. WINOLEAUTAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL FAR* pboolOut);
  349. WINOLEAUTAPI VarBoolFromStr(OLECHAR FAR* strIn, LCID lcid, unsigned long dwFlags, VARIANT_BOOL FAR* pboolOut);
  350. WINOLEAUTAPI VarBoolFromDisp(IDispatch FAR* pdispIn, LCID lcid, VARIANT_BOOL FAR* pboolOut);
  351.  
  352.  
  353. /* Mac Note: On the Mac, the coersion functions support the
  354.  * Symantec C++ calling convention for float/double. To support
  355.  * float/double arguments compiled with the MPW C compiler,
  356.  * use the following APIs to move MPW float/double values into
  357.  * a VARIANT.
  358.  */
  359.  
  360. /*---------------------------------------------------------------------*/
  361. /*                 ITypeLib                    */
  362. /*---------------------------------------------------------------------*/
  363.  
  364.  
  365. #ifndef __GNUC__
  366. typedef ITypeLib FAR* LPTYPELIB;
  367. #endif /* __GNUC__ */
  368.  
  369.  
  370. /*---------------------------------------------------------------------*/
  371. /*                ITypeInfo                    */
  372. /*---------------------------------------------------------------------*/
  373.  
  374.  
  375. #ifndef __GNUC__
  376. typedef LONG DISPID;
  377. typedef DISPID MEMBERID;
  378. #endif /* __GNUC__ */
  379.  
  380. #define MEMBERID_NIL DISPID_UNKNOWN
  381. #define ID_DEFAULTINST  -2
  382.  
  383.  
  384. #define IDLFLAG_NONE    0
  385. #define IDLFLAG_FIN     0x1
  386. #define IDLFLAG_FOUT    0x2
  387. #define IDLFLAG_FLCID   0x4
  388. #define IDLFLAG_FRETVAL 0x8
  389.  
  390.  
  391. /* Flags for IDispatch::Invoke */
  392. #define DISPATCH_METHOD     0x1
  393. #define DISPATCH_PROPERTYGET    0x2
  394. #define DISPATCH_PROPERTYPUT    0x4
  395. #define DISPATCH_PROPERTYPUTREF 0x8
  396.  
  397.  
  398. #ifndef __GNUC__
  399. typedef ITypeInfo FAR* LPTYPEINFO;
  400. #endif /* __GNUC__ */
  401.  
  402.  
  403. /*---------------------------------------------------------------------*/
  404. /*                ITypeComp                    */
  405. /*---------------------------------------------------------------------*/
  406.  
  407. #ifndef __GNUC__
  408. typedef ITypeComp FAR* LPTYPECOMP;
  409. #endif /* __GNUC__ */
  410.  
  411.  
  412. /*---------------------------------------------------------------------*/
  413. /*             ICreateTypeLib                  */
  414. /*---------------------------------------------------------------------*/
  415.  
  416. #ifndef __GNUC__
  417. typedef ICreateTypeLib FAR* LPCREATETYPELIB;
  418. #endif /* __GNUC__ */
  419.  
  420.  
  421. #ifndef __GNUC__
  422. typedef ICreateTypeInfo FAR* LPCREATETYPEINFO;
  423. #endif /* __GNUC__ */
  424.  
  425. /*---------------------------------------------------------------------*/
  426. /*             TypeInfo API                    */
  427. /*---------------------------------------------------------------------*/
  428.  
  429. /* compute a 16bit hash value for the given name
  430.  */
  431. #ifdef _WIN32
  432. WINOLEAUTAPI_(ULONG)
  433. LHashValOfNameSysA(SYSKIND syskind, LCID lcid, const char FAR* szName);
  434. #endif
  435.  
  436. WINOLEAUTAPI_(ULONG)
  437. LHashValOfNameSys(SYSKIND syskind, LCID lcid, const OLECHAR FAR* szName);
  438.  
  439. #define LHashValOfName(lcid, szName) \
  440.         LHashValOfNameSys(SYS_WIN32, lcid, szName)
  441.  
  442. #define WHashValOfLHashVal(lhashval) \
  443.         ((unsigned short) (0x0000ffff & (lhashval)))
  444.  
  445. #define IsHashValCompatible(lhashval1, lhashval2) \
  446.         ((BOOL) ((0x00ff0000 & (lhashval1)) == (0x00ff0000 & (lhashval2))))
  447.  
  448. /* load the typelib from the file with the given filename
  449.  */
  450. WINOLEAUTAPI
  451. LoadTypeLib(const OLECHAR FAR *szFile, ITypeLib FAR* FAR* pptlib);
  452.  
  453. /* load registered typelib
  454.  */
  455. WINOLEAUTAPI
  456. LoadRegTypeLib(
  457.     REFGUID rguid,
  458.     WORD wVerMajor,
  459.     WORD wVerMinor,
  460.     LCID lcid,
  461.     ITypeLib FAR* FAR* pptlib);
  462.  
  463. /* get path to registered typelib
  464.  */
  465. WINOLEAUTAPI
  466. QueryPathOfRegTypeLib(
  467.     REFGUID guid,
  468.     unsigned short wMaj,
  469.     unsigned short wMin,
  470.     LCID lcid,
  471.     LPBSTR lpbstrPathName);
  472.  
  473. /* add typelib to registry
  474.  */
  475. WINOLEAUTAPI
  476. RegisterTypeLib(ITypeLib FAR* ptlib, OLECHAR FAR *szFullPath,
  477.         OLECHAR FAR *szHelpDir);
  478.  
  479. /* remove typelib from registry
  480.  */
  481. WINOLEAUTAPI
  482. DeregisterTypeLib(REFGUID rguid, WORD wVerMajor, WORD wVerMinor, LCID lcid);
  483.  
  484. WINOLEAUTAPI
  485. CreateTypeLib(SYSKIND syskind, const OLECHAR FAR *szFile,
  486.         ICreateTypeLib FAR* FAR* ppctlib);
  487.  
  488. /*---------------------------------------------------------------------*/
  489.  
  490. /*---------------------------------------------------------------------*/
  491. /*                 IDispatch                   */
  492. /*---------------------------------------------------------------------*/
  493.  
  494. #ifndef __GNUC__
  495. typedef IDispatch FAR* LPDISPATCH;
  496. #endif /* __GNUC__ */
  497.  
  498.  
  499.  
  500. /*---------------------------------------------------------------------*/
  501. /*           IDispatch implementation support              */
  502. /*---------------------------------------------------------------------*/
  503.  
  504. typedef struct FARSTRUCT tagPARAMDATA {
  505.     OLECHAR FAR* szName;    /* parameter name */
  506.     VARTYPE vt;         /* parameter type */
  507. } PARAMDATA, FAR* LPPARAMDATA;
  508.  
  509. typedef struct FARSTRUCT tagMETHODDATA {
  510.     OLECHAR FAR* szName;    /* method name */
  511.     PARAMDATA FAR* ppdata;  /* pointer to an array of PARAMDATAs */
  512.     DISPID dispid;      /* method ID */
  513.     UINT iMeth;         /* method index */
  514.     CALLCONV cc;        /* calling convention */
  515.     UINT cArgs;         /* count of arguments */
  516.     WORD wFlags;        /* same wFlags as on IDispatch::Invoke() */
  517.     VARTYPE vtReturn;
  518. } METHODDATA, FAR* LPMETHODDATA;
  519.  
  520. typedef struct FARSTRUCT tagINTERFACEDATA {
  521.     METHODDATA FAR* pmethdata;  /* pointer to an array of METHODDATAs */
  522.     UINT cMembers;      /* count of members */
  523. } INTERFACEDATA, FAR* LPINTERFACEDATA;
  524.  
  525.  
  526.  
  527. /* Locate the parameter indicated by the given position, and
  528.  * return it coerced to the given target VARTYPE (vtTarg).
  529.  */
  530. WINOLEAUTAPI
  531. DispGetParam(
  532.     DISPPARAMS FAR* pdispparams,
  533.     UINT position,
  534.     VARTYPE vtTarg,
  535.     VARIANT FAR* pvarResult,
  536.     UINT FAR* puArgErr);
  537.  
  538. /* Automatic TypeInfo driven implementation of IDispatch::GetIDsOfNames()
  539.  */
  540. WINOLEAUTAPI
  541. DispGetIDsOfNames(
  542.     ITypeInfo FAR* ptinfo,
  543.     OLECHAR FAR* FAR* rgszNames,
  544.     UINT cNames,
  545.     DISPID FAR* rgdispid);
  546.  
  547. /* Automatic TypeInfo driven implementation of IDispatch::Invoke()
  548.  */
  549. WINOLEAUTAPI
  550. DispInvoke(
  551.     void FAR* _this,
  552.     ITypeInfo FAR* ptinfo,
  553.     DISPID dispidMember,
  554.     WORD wFlags,
  555.     DISPPARAMS FAR* pparams,
  556.     VARIANT FAR* pvarResult,
  557.     EXCEPINFO FAR* pexcepinfo,
  558.     UINT FAR* puArgErr);
  559.  
  560. /* Construct a TypeInfo from an interface data description
  561.  */
  562. WINOLEAUTAPI
  563. CreateDispTypeInfo(
  564.     INTERFACEDATA FAR* pidata,
  565.     LCID lcid,
  566.     ITypeInfo FAR* FAR* pptinfo);
  567.  
  568. /* Create an instance of the standard TypeInfo driven IDispatch
  569.  * implementation.
  570.  */
  571. WINOLEAUTAPI
  572. CreateStdDispatch(
  573.     IUnknown FAR* punkOuter,
  574.     void FAR* pvThis,
  575.     ITypeInfo FAR* ptinfo,
  576.     IUnknown FAR* FAR* ppunkStdDisp);
  577.  
  578.  
  579. /*---------------------------------------------------------------------*/
  580. /*            Active Object Registration API               */
  581. /*---------------------------------------------------------------------*/
  582.  
  583. /* flags for RegisterActiveObject */
  584. #define ACTIVEOBJECT_STRONG 0x0
  585. #define ACTIVEOBJECT_WEAK 0x1
  586.  
  587. WINOLEAUTAPI
  588. RegisterActiveObject(
  589.    IUnknown FAR* punk,
  590.    REFCLSID rclsid,
  591.    DWORD dwFlags,
  592.    DWORD FAR* pdwRegister);
  593.  
  594. WINOLEAUTAPI
  595. RevokeActiveObject(
  596.     DWORD dwRegister,
  597.     void FAR* pvReserved);
  598.  
  599. WINOLEAUTAPI
  600. GetActiveObject(
  601.     REFCLSID rclsid,
  602.     void FAR* pvReserved,
  603.     IUnknown FAR* FAR* ppunk);
  604.  
  605. /*---------------------------------------------------------------------*/
  606. /*                           ErrorInfo API                             */
  607. /*---------------------------------------------------------------------*/
  608.  
  609. WINOLEAUTAPI SetErrorInfo(unsigned long dwReserved, IErrorInfo FAR* perrinfo);
  610. WINOLEAUTAPI GetErrorInfo(unsigned long dwReserved, IErrorInfo FAR* FAR* pperrinfo);
  611. WINOLEAUTAPI CreateErrorInfo(ICreateErrorInfo FAR* FAR* pperrinfo);
  612.  
  613. /*---------------------------------------------------------------------*/
  614. /*                           MISC API                                  */
  615. /*---------------------------------------------------------------------*/
  616.  
  617. WINOLEAUTAPI_(unsigned long) OaBuildVersion(void);
  618.  
  619. // Declare variant access functions.
  620.  
  621.  
  622.  
  623. #ifdef NONAMELESSUNION
  624. # define V_UNION(X, Y) ((X)->u.Y)
  625. #else
  626. # define V_UNION(X, Y) ((X)->Y)
  627. #endif
  628.  
  629. /* Variant access macros */
  630. #define V_VT(X)          ((X)->vt)
  631. #define V_ISBYREF(X)     (V_VT(X)&VT_BYREF)
  632. #define V_ISARRAY(X)     (V_VT(X)&VT_ARRAY)
  633. #define V_ISVECTOR(X)    (V_VT(X)&VT_VECTOR)
  634.  
  635. #define V_NONE(X)        V_I2(X)
  636.  
  637. #define V_UI1(X)         V_UNION(X, bVal)
  638. #define V_UI1REF(X)      V_UNION(X, pbVal)
  639.  
  640. #define V_I2(X)          V_UNION(X, iVal)
  641. #define V_I2REF(X)       V_UNION(X, piVal)
  642.  
  643. #define V_I4(X)          V_UNION(X, lVal)
  644. #define V_I4REF(X)       V_UNION(X, plVal)
  645.  
  646. #define V_I8(X)          V_UNION(X, hVal)
  647. #define V_I8REF(X)       V_UNION(X, phVal)
  648.  
  649. #define V_R4(X)          V_UNION(X, fltVal)
  650. #define V_R4REF(X)       V_UNION(X, pfltVal)
  651.  
  652. #define V_R8(X)          V_UNION(X, dblVal)
  653. #define V_R8REF(X)       V_UNION(X, pdblVal)
  654.  
  655. #define V_CY(X)          V_UNION(X, cyVal)
  656. #define V_CYREF(X)       V_UNION(X, pcyVal)
  657.  
  658. #define V_DATE(X)        V_UNION(X, date)
  659. #define V_DATEREF(X)     V_UNION(X, pdate)
  660.  
  661. #define V_BSTR(X)        V_UNION(X, bstrVal)
  662. #define V_BSTRREF(X)     V_UNION(X, pbstrVal)
  663.  
  664. #define V_DISPATCH(X)    V_UNION(X, pdispVal)
  665. #define V_DISPATCHREF(X) V_UNION(X, ppdispVal)
  666.  
  667. #define V_ERROR(X)       V_UNION(X, scode)
  668. #define V_ERRORREF(X)    V_UNION(X, pscode)
  669.  
  670. #define V_BOOL(X)        V_UNION(X, boolVal)
  671. #define V_BOOLREF(X)     V_UNION(X, pbool)
  672.  
  673. #define V_UNKNOWN(X)     V_UNION(X, punkVal)
  674. #define V_UNKNOWNREF(X)  V_UNION(X, ppunkVal)
  675.  
  676.  
  677. #define V_VARIANTREF(X)  V_UNION(X, pvarVal)
  678.  
  679. #define V_LPSTR(X)        V_UNION(X, pszVal)
  680. #define V_LPSTRREF(X)     V_UNION(X, ppszVal)
  681.  
  682. #define V_LPWSTR(X)        V_UNION(X, pwszVal)
  683. #define V_LPWSTRREF(X)     V_UNION(X, ppwszVal)
  684.  
  685. #define V_FILETIME(X)        V_UNION(X, filetime)
  686. #define V_FILETIMEREF(X)        V_UNION(X, pfiletime)
  687.  
  688. #define V_BLOB(X)        V_UNION(X, blob)
  689.  
  690. #define V_UUID(X)        V_UNION(X, puuid)
  691. #define V_CLSID(X)       V_UNION(X, puuid)
  692.  
  693. #define V_ARRAY(X)       V_UNION(X, parray)
  694. #define V_ARRAYREF(X)    V_UNION(X, pparray)
  695.  
  696. #define V_BYREF(X)       V_UNION(X, byref)
  697.  
  698. #ifndef RC_INVOKED
  699. #include <poppack.h>
  700. #endif // RC_INVOKED
  701.  
  702. #endif     // __OLEAUTO_H__
  703.  
  704. #if defined(__TOPLEVEL_OLEAUTO_H_)
  705. #undef __TOPLEVEL_NEXT_COMMON_INCLUDE__
  706. #undef __TOPLEVEL_OLEAUTO_H_
  707. #include <next_common_undefines.h>
  708. #endif /* __TOPLEVEL_OLEAUTO_H_ */
  709.  
  710.