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