home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1997 May / Pcwk0597.iso / borland / cb / setup / cbuilder / data.z / OBJBASE.H < prev    next >
C/C++ Source or Header  |  1997-02-28  |  31KB  |  878 lines
  1. #pragma option -b
  2. //+---------------------------------------------------------------------------
  3. //
  4. //  Microsoft Windows
  5. //  Copyright (C) Microsoft Corporation, 1992 - 1996.
  6. //
  7. //  File:       objbase.h
  8. //
  9. //  Contents:   Component object model defintions.
  10. //
  11. //----------------------------------------------------------------------------
  12.  
  13. #pragma option -b.
  14. #include <rpc.h>
  15. #pragma option -b
  16. #pragma option -b.
  17. #include <rpcndr.h>
  18. #pragma option -b
  19.  
  20. #if !defined( _OBJBASE_H_ )
  21. #define _OBJBASE_H_
  22.  
  23. #pragma option -b.
  24. #include <pshpack8.h>
  25. #pragma option -b
  26.  
  27. #ifdef _MAC
  28. #ifndef _WLM_NOFORCE_LIBS
  29.  
  30. #ifdef _WLMDLL
  31.         #ifdef _DEBUG
  32.                 #pragma comment(lib, "oledlgd.lib")
  33.                 #pragma comment(lib, "msvcoled.lib")
  34.         #else
  35.                 #pragma comment(lib, "oledlg.lib")
  36.                 #pragma comment(lib, "msvcole.lib")
  37.         #endif
  38. #else
  39.         #ifdef _DEBUG
  40.                 #pragma comment(lib, "wlmoled.lib")
  41.                 #pragma comment(lib, "ole2uid.lib")
  42.         #else
  43.                 #pragma comment(lib, "wlmole.lib")
  44.                 #pragma comment(lib, "ole2ui.lib")
  45.         #endif
  46.         #pragma data_seg(".drectve")
  47.         static char _gszWlmOLEUIResourceDirective[] = "/macres:ole2ui.rsc";
  48.         #pragma data_seg()
  49. #endif
  50.  
  51. #pragma comment(lib, "uuid.lib")
  52.  
  53. #ifdef _DEBUG
  54.     #pragma comment(lib, "ole2d.lib")
  55.     #pragma comment(lib, "ole2autd.lib")
  56. #else
  57.     #pragma comment(lib, "ole2.lib")
  58.     #pragma comment(lib, "ole2auto.lib")
  59. #endif
  60.  
  61. #endif // !_WLM_NOFORCE_LIBS
  62. #endif // _MAC
  63.  
  64. // Component Object Model defines, and macros
  65.  
  66. #ifdef __cplusplus
  67.     #define EXTERN_C    extern "C"
  68. #else
  69.     #define EXTERN_C    extern
  70. #endif
  71.  
  72. #if defined(_WIN32) || defined(_MPPC_)
  73.  
  74. // Win32 doesn't support __export
  75.  
  76. #ifdef _68K_
  77. #define STDMETHODCALLTYPE       __cdecl
  78. #else
  79. #define STDMETHODCALLTYPE       __stdcall
  80. #endif
  81. #define STDMETHODVCALLTYPE      __cdecl
  82.  
  83. #define STDAPICALLTYPE          __stdcall
  84. #define STDAPIVCALLTYPE         __cdecl
  85.  
  86. #else
  87.  
  88. #define STDMETHODCALLTYPE       __export __stdcall
  89. #define STDMETHODVCALLTYPE      __export __cdecl
  90.  
  91. #define STDAPICALLTYPE          __export __stdcall
  92. #define STDAPIVCALLTYPE         __export __cdecl
  93.  
  94. #endif
  95.  
  96.  
  97. #define STDAPI                  EXTERN_C HRESULT STDAPICALLTYPE
  98. #define STDAPI_(type)           EXTERN_C type STDAPICALLTYPE
  99.  
  100. #define STDMETHODIMP            HRESULT STDMETHODCALLTYPE
  101. #define STDMETHODIMP_(type)     type STDMETHODCALLTYPE
  102.  
  103. // The 'V' versions allow Variable Argument lists.
  104.  
  105. #define STDAPIV                 EXTERN_C HRESULT STDAPIVCALLTYPE
  106. #define STDAPIV_(type)          EXTERN_C type STDAPIVCALLTYPE
  107.  
  108. #define STDMETHODIMPV           HRESULT STDMETHODVCALLTYPE
  109. #define STDMETHODIMPV_(type)    type STDMETHODVCALLTYPE
  110.  
  111. #ifdef _OLE32_
  112. #define WINOLEAPI        STDAPI
  113. #define WINOLEAPI_(type) STDAPI_(type)
  114. #else
  115.  
  116. #ifdef _68K_
  117. #ifndef REQUIRESAPPLEPASCAL
  118. #define WINOLEAPI        EXTERN_C DECLSPEC_IMPORT HRESULT PASCAL
  119. #define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT type PASCAL
  120. #else
  121. #define WINOLEAPI        EXTERN_C DECLSPEC_IMPORT PASCAL HRESULT
  122. #define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT PASCAL type
  123. #endif
  124. #else
  125. #define WINOLEAPI        EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
  126. #define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
  127. #endif
  128.  
  129. #endif
  130.  
  131. /****** Interface Declaration ***********************************************/
  132.  
  133. /*
  134.  *      These are macros for declaring interfaces.  They exist so that
  135.  *      a single definition of the interface is simulataneously a proper
  136.  *      declaration of the interface structures (C++ abstract classes)
  137.  *      for both C and C++.
  138.  *
  139.  *      DECLARE_INTERFACE(iface) is used to declare an interface that does
  140.  *      not derive from a base interface.
  141.  *      DECLARE_INTERFACE_(iface, baseiface) is used to declare an interface
  142.  *      that does derive from a base interface.
  143.  *
  144.  *      By default if the source file has a .c extension the C version of
  145.  *      the interface declaratations will be expanded; if it has a .cpp
  146.  *      extension the C++ version will be expanded. if you want to force
  147.  *      the C version expansion even though the source file has a .cpp
  148.  *      extension, then define the macro "CINTERFACE".
  149.  *      eg.     cl -DCINTERFACE file.cpp
  150.  *
  151.  *      Example Interface declaration:
  152.  *
  153.  *          #undef  INTERFACE
  154.  *          #define INTERFACE   IClassFactory
  155.  *
  156.  *          DECLARE_INTERFACE_(IClassFactory, IUnknown)
  157.  *          {
  158.  *              // *** IUnknown methods ***
  159.  *              STDMETHOD(QueryInterface) (THIS_
  160.  *                                        REFIID riid,
  161.  *                                        LPVOID FAR* ppvObj) PURE;
  162.  *              STDMETHOD_(ULONG,AddRef) (THIS) PURE;
  163.  *              STDMETHOD_(ULONG,Release) (THIS) PURE;
  164.  *
  165.  *              // *** IClassFactory methods ***
  166.  *              STDMETHOD(CreateInstance) (THIS_
  167.  *                                        LPUNKNOWN pUnkOuter,
  168.  *                                        REFIID riid,
  169.  *                                        LPVOID FAR* ppvObject) PURE;
  170.  *          };
  171.  *
  172.  *      Example C++ expansion:
  173.  *
  174.  *          struct FAR IClassFactory : public IUnknown
  175.  *          {
  176.  *              virtual HRESULT STDMETHODCALLTYPE QueryInterface(
  177.  *                                                  IID FAR& riid,
  178.  *                                                  LPVOID FAR* ppvObj) = 0;
  179.  *              virtual HRESULT STDMETHODCALLTYPE AddRef(void) = 0;
  180.  *              virtual HRESULT STDMETHODCALLTYPE Release(void) = 0;
  181.  *              virtual HRESULT STDMETHODCALLTYPE CreateInstance(
  182.  *                                              LPUNKNOWN pUnkOuter,
  183.  *                                              IID FAR& riid,
  184.  *                                              LPVOID FAR* ppvObject) = 0;
  185.  *          };
  186.  *
  187.  *          NOTE: Our documentation says '#define interface class' but we use
  188.  *          'struct' instead of 'class' to keep a lot of 'public:' lines
  189.  *          out of the interfaces.  The 'FAR' forces the 'this' pointers to
  190.  *          be far, which is what we need.
  191.  *
  192.  *      Example C expansion:
  193.  *
  194.  *          typedef struct IClassFactory
  195.  *          {
  196.  *              const struct IClassFactoryVtbl FAR* lpVtbl;
  197.  *          } IClassFactory;
  198.  *
  199.  *          typedef struct IClassFactoryVtbl IClassFactoryVtbl;
  200.  *
  201.  *          struct IClassFactoryVtbl
  202.  *          {
  203.  *              HRESULT (STDMETHODCALLTYPE * QueryInterface) (
  204.  *                                                  IClassFactory FAR* This,
  205.  *                                                  IID FAR* riid,
  206.  *                                                  LPVOID FAR* ppvObj) ;
  207.  *              HRESULT (STDMETHODCALLTYPE * AddRef) (IClassFactory FAR* This) ;
  208.  *              HRESULT (STDMETHODCALLTYPE * Release) (IClassFactory FAR* This) ;
  209.  *              HRESULT (STDMETHODCALLTYPE * CreateInstance) (
  210.  *                                                  IClassFactory FAR* This,
  211.  *                                                  LPUNKNOWN pUnkOuter,
  212.  *                                                  IID FAR* riid,
  213.  *                                                  LPVOID FAR* ppvObject);
  214.  *              HRESULT (STDMETHODCALLTYPE * LockServer) (
  215.  *                                                  IClassFactory FAR* This,
  216.  *                                                  BOOL fLock);
  217.  *          };
  218.  */
  219.  
  220. #if defined(__cplusplus) && !defined(CINTERFACE)
  221. //#define interface               struct FAR
  222. #define interface struct
  223. #define STDMETHOD(method)       virtual HRESULT STDMETHODCALLTYPE method
  224. #define STDMETHOD_(type,method) virtual type STDMETHODCALLTYPE method
  225. #define PURE                    = 0
  226. #define THIS_
  227. #define THIS                    void
  228. #define DECLARE_INTERFACE(iface)    interface iface
  229. #define DECLARE_INTERFACE_(iface, baseiface)    interface iface : public baseiface
  230.  
  231.  
  232. #if !defined(BEGIN_INTERFACE)
  233. #if defined(_MPPC_)  && \
  234.     ( (defined(_MSC_VER) || defined(__SC__) || defined(__MWERKS__)) && \
  235.     !defined(NO_NULL_VTABLE_ENTRY) )
  236.    #define BEGIN_INTERFACE virtual void a() {}
  237.    #define END_INTERFACE
  238. #else
  239.    #define BEGIN_INTERFACE
  240.    #define END_INTERFACE
  241. #endif
  242. #endif
  243.  
  244. #else
  245.  
  246. #define interface               struct
  247.  
  248. #define STDMETHOD(method)       HRESULT (STDMETHODCALLTYPE * method)
  249. #define STDMETHOD_(type,method) type (STDMETHODCALLTYPE * method)
  250.  
  251. #if !defined(BEGIN_INTERFACE)
  252. #if defined(_MPPC_)
  253.     #define BEGIN_INTERFACE       void    *b;
  254.     #define END_INTERFACE
  255. #else
  256.     #define BEGIN_INTERFACE
  257.     #define END_INTERFACE
  258. #endif
  259. #endif
  260.  
  261.  
  262. #define PURE
  263. #define THIS_                   INTERFACE FAR* This,
  264. #define THIS                    INTERFACE FAR* This
  265. #ifdef CONST_VTABLE
  266. #undef CONST_VTBL
  267. #define CONST_VTBL const
  268. #define DECLARE_INTERFACE(iface)    typedef interface iface { \
  269.                                     const struct iface##Vtbl FAR* lpVtbl; \
  270.                                 } iface; \
  271.                                 typedef const struct iface##Vtbl iface##Vtbl; \
  272.                                 const struct iface##Vtbl
  273. #else
  274. #undef CONST_VTBL
  275. #define CONST_VTBL
  276. #define DECLARE_INTERFACE(iface)    typedef interface iface { \
  277.                                     struct iface##Vtbl FAR* lpVtbl; \
  278.                                 } iface; \
  279.                                 typedef struct iface##Vtbl iface##Vtbl; \
  280.                                 struct iface##Vtbl
  281. #endif
  282. #define DECLARE_INTERFACE_(iface, baseiface)    DECLARE_INTERFACE(iface)
  283.  
  284. #endif
  285.  
  286.  
  287.  
  288.  
  289. /****** Additional basic types **********************************************/
  290.  
  291.  
  292. #ifndef FARSTRUCT
  293. #ifdef __cplusplus
  294. #define FARSTRUCT   FAR
  295. #else
  296. #define FARSTRUCT
  297. #endif  // __cplusplus
  298. #endif  // FARSTRUCT
  299.  
  300.  
  301.  
  302. #ifndef HUGEP
  303. #if defined(_WIN32) || defined(_MPPC_)
  304. #define HUGEP
  305. #else
  306. #define HUGEP __huge
  307. #endif // WIN32
  308. #endif // HUGEP
  309.  
  310.  
  311. #ifdef _MAC
  312. #if !defined(OLE2ANSI)
  313. #define OLE2ANSI
  314. #endif
  315. #endif
  316.  
  317. #pragma option -b.
  318. #include <stdlib.h>
  319. #pragma option -b
  320.  
  321. #if defined(_ANONYMOUS_STRUCT)
  322. #define LISet32(li, v) ((li).HighPart = (v) < 0 ? -1 : 0, (li).LowPart = (v))
  323. #define ULISet32(li, v) ((li).HighPart = 0, (li).LowPart = (v))
  324. #else
  325. #define LISet32(li, v) ((li).u.HighPart = (v) < 0 ? -1 : 0, (li).u.LowPart = (v))
  326. #define ULISet32(li, v) ((li).u.HighPart = 0, (li).u.LowPart = (v))
  327. #endif
  328.  
  329.  
  330. #define CLSCTX_INPROC           (CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER)
  331.  
  332. // With DCOM, CLSCTX_REMOTE_SERVER should be included
  333. #if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  334. #define CLSCTX_ALL              (CLSCTX_INPROC_SERVER| \
  335.                                  CLSCTX_INPROC_HANDLER| \
  336.                                  CLSCTX_LOCAL_SERVER| \
  337.                                  CLSCTX_REMOTE_SERVER)
  338.  
  339. #define CLSCTX_SERVER           (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER)
  340. #else
  341. #define CLSCTX_ALL              (CLSCTX_INPROC_SERVER| \
  342.                                  CLSCTX_INPROC_HANDLER| \
  343.                                  CLSCTX_LOCAL_SERVER )
  344.  
  345. #define CLSCTX_SERVER           (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER)
  346. #endif
  347.  
  348.  
  349. // class registration flags; passed to CoRegisterClassObject
  350. typedef enum tagREGCLS
  351. {
  352.     REGCLS_SINGLEUSE = 0,       // class object only generates one instance
  353.     REGCLS_MULTIPLEUSE = 1,     // same class object genereates multiple inst.
  354.                                 // and local automatically goes into inproc tbl.
  355.     REGCLS_MULTI_SEPARATE = 2,  // multiple use, but separate control over each
  356.                                 // context.
  357.     REGCLS_SUSPENDED      = 4   // register is as suspended, will be activated
  358.                                 // when app calls CoResumeClassObjects
  359. } REGCLS;
  360.  
  361. // interface marshaling definitions
  362. #define MARSHALINTERFACE_MIN 500 // minimum number of bytes for interface marshl
  363.  
  364.  
  365. //
  366. // Common typedefs for paramaters used in Storage API's, gleamed from storage.h
  367. // Also contains Storage error codes, which should be moved into the storage
  368. // idl files.
  369. //
  370.  
  371.  
  372. #define CWCSTORAGENAME 32
  373.  
  374. /* Storage instantiation modes */
  375. #define STGM_DIRECT             0x00000000L
  376. #define STGM_TRANSACTED         0x00010000L
  377. #define STGM_SIMPLE             0x08000000L
  378.  
  379. #define STGM_READ               0x00000000L
  380. #define STGM_WRITE              0x00000001L
  381. #define STGM_READWRITE          0x00000002L
  382.  
  383. #define STGM_SHARE_DENY_NONE    0x00000040L
  384. #define STGM_SHARE_DENY_READ    0x00000030L
  385. #define STGM_SHARE_DENY_WRITE   0x00000020L
  386. #define STGM_SHARE_EXCLUSIVE    0x00000010L
  387.  
  388. #define STGM_PRIORITY           0x00040000L
  389. #define STGM_DELETEONRELEASE    0x04000000L
  390. #if (WINVER >= 400)
  391. #define STGM_NOSCRATCH          0x00100000L
  392. #endif /* WINVER */
  393.  
  394. #define STGM_CREATE             0x00001000L
  395. #define STGM_CONVERT            0x00020000L
  396. #define STGM_FAILIFTHERE        0x00000000L
  397.  
  398. #define STGM_NOSNAPSHOT         0x00200000L
  399.  
  400. /*  flags for internet asyncronous and layout docfile */
  401. #define ASYNC_MODE_COMPATIBILITY    0x00000001L
  402. #define ASYNC_MODE_DEFAULT          0x00000000L
  403.  
  404. #define STGTY_REPEAT                0x00000100L
  405. #define STG_TOEND                   0xFFFFFFFFL
  406.  
  407. #define STG_LAYOUT_SEQUENTIAL       0x00000000L
  408. #define STG_LAYOUT_INTERLEAVED      0x00000001L
  409.  
  410.  
  411.  
  412.  
  413. /* here is where we pull in the MIDL generated headers for the interfaces */
  414. typedef interface    IRpcStubBuffer     IRpcStubBuffer;
  415. typedef interface    IRpcChannelBuffer  IRpcChannelBuffer;
  416.  
  417. #pragma option -b.
  418. #include <wtypes.h>
  419. #pragma option -b
  420. #pragma option -b.
  421. #include <unknwn.h>
  422. #pragma option -b
  423. #pragma option -b.
  424. #include <objidl.h>
  425. #pragma option -b
  426.  
  427.  
  428. // macros to define byte pattern for a GUID.
  429. //      Example: DEFINE_GUID(GUID_XXX, a, b, c, ...);
  430. //
  431. // Each dll/exe must initialize the GUIDs once.  This is done in one of
  432. // two ways.  If you are not using precompiled headers for the file(s) which
  433. // initializes the GUIDs, define INITGUID before including objbase.h.  This
  434. // is how OLE builds the initialized versions of the GUIDs which are included
  435. // in ole2.lib.  The GUIDs in ole2.lib are all defined in the same text
  436. // segment GUID_TEXT.
  437. //
  438. // The alternative (which some versions of the compiler don't handle properly;
  439. // they wind up with the initialized GUIDs in a data, not a text segment),
  440. // is to use a precompiled version of objbase.h and then include initguid.h
  441. // after objbase.h followed by one or more of the guid defintion files.
  442.  
  443. #ifndef INITGUID
  444. #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
  445.     EXTERN_C const GUID FAR name
  446. #else
  447.  
  448. #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
  449.         EXTERN_C const GUID name \
  450.                 = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
  451. #endif // INITGUID
  452.  
  453. #define DEFINE_OLEGUID(name, l, w1, w2) \
  454.     DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46)
  455.  
  456. #ifdef _OLE32_
  457.  
  458.  
  459. // Faster (but makes code fatter) inline version...use sparingly
  460. #ifdef __cplusplus
  461. inline BOOL  InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2)
  462. {
  463.    return (
  464.       ((PLONG) &rguid1)[0] == ((PLONG) &rguid2)[0] &&
  465.       ((PLONG) &rguid1)[1] == ((PLONG) &rguid2)[1] &&
  466.       ((PLONG) &rguid1)[2] == ((PLONG) &rguid2)[2] &&
  467.       ((PLONG) &rguid1)[3] == ((PLONG) &rguid2)[3]);
  468. }
  469. #else   // ! __cplusplus
  470. #define InlineIsEqualGUID(rguid1, rguid2)  \
  471.         (((PLONG) rguid1)[0] == ((PLONG) rguid2)[0] &&   \
  472.         ((PLONG) rguid1)[1] == ((PLONG) rguid2)[1] &&    \
  473.         ((PLONG) rguid1)[2] == ((PLONG) rguid2)[2] &&    \
  474.         ((PLONG) rguid1)[3] == ((PLONG) rguid2)[3])
  475. #endif  // __cplusplus
  476.  
  477. #ifdef _OLE32PRIV_
  478. BOOL _fastcall wIsEqualGUID(REFGUID rguid1, REFGUID rguid2);
  479. #define IsEqualGUID(rguid1, rguid2) wIsEqualGUID(rguid1, rguid2)
  480. #else
  481. #define IsEqualGUID(rguid1, rguid2) InlineIsEqualGUID(rguid1, rguid2)
  482. #endif  // _OLE32PRIV_
  483.  
  484. #else   // ! _OLE32_
  485. #ifdef __cplusplus
  486. inline BOOL IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
  487. {
  488.     return !memcmp(&rguid1, &rguid2, sizeof(GUID));
  489. }
  490. #else   //  ! __cplusplus
  491. #define IsEqualGUID(rguid1, rguid2) (!memcmp(rguid1, rguid2, sizeof(GUID)))
  492. #endif  //  __cplusplus
  493. #endif  //  _OLE32_
  494.  
  495. #define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2)
  496. #define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2)
  497.  
  498. #ifdef __cplusplus
  499.  
  500. // because GUID is defined elsewhere in WIN32 land, the operator == and !=
  501. // are moved outside the class to global scope.
  502.  
  503. #ifdef _OLE32_
  504. inline BOOL operator==(const GUID& guidOne, const GUID& guidOther)
  505. {
  506.     return IsEqualGUID(guidOne,guidOther);
  507. }
  508. #else   // !_OLE32_
  509. inline BOOL operator==(const GUID& guidOne, const GUID& guidOther)
  510. {
  511. #ifdef _WIN32
  512.     return !memcmp(&guidOne,&guidOther,sizeof(GUID));
  513. #else
  514.     return !_fmemcmp(&guidOne,&guidOther,sizeof(GUID)); }
  515. #endif
  516. }
  517. #endif // _OLE32_
  518.  
  519. inline BOOL operator!=(const GUID& guidOne, const GUID& guidOther)
  520. {
  521.     return !(guidOne == guidOther);
  522. }
  523.  
  524. #endif // __cpluscplus
  525.  
  526.  
  527. #ifndef INITGUID
  528. #pragma option -b.
  529. #include <cguid.h>
  530. #pragma option -b
  531. #endif
  532.  
  533. // COM initialization flags; passed to CoInitialize.
  534. typedef enum tagCOINIT
  535. {
  536.   COINIT_APARTMENTTHREADED  = 0x2,      // Apartment model
  537.  
  538. #if  (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  539.   // These constants are only valid on Windows NT 4.0
  540.   COINIT_MULTITHREADED      = 0x0,      // OLE calls objects on any thread.
  541.   COINIT_DISABLE_OLE1DDE    = 0x4,      // Don't use DDE for Ole1 support.
  542.   COINIT_SPEED_OVER_MEMORY  = 0x8,      // Trade memory for speed.
  543. #endif // DCOM
  544. } COINIT;
  545.  
  546.  
  547.  
  548.  
  549.  
  550. /****** STD Object API Prototypes *****************************************/
  551.  
  552. WINOLEAPI_(DWORD) CoBuildVersion( VOID );
  553.  
  554. /* init/uninit */
  555.  
  556. WINOLEAPI  CoInitialize(LPVOID pvReserved);
  557. WINOLEAPI_(void)  CoUninitialize(void);
  558. WINOLEAPI  CoGetMalloc(DWORD dwMemContext, LPMALLOC FAR* ppMalloc);
  559. WINOLEAPI_(DWORD) CoGetCurrentProcess(void);
  560. WINOLEAPI  CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy);
  561. WINOLEAPI  CoRevokeMallocSpy(void);
  562. WINOLEAPI  CoCreateStandardMalloc(DWORD memctx, IMalloc FAR* FAR* ppMalloc);
  563.  
  564. #if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  565. WINOLEAPI  CoInitializeEx(LPVOID pvReserved, DWORD dwCoInit);
  566. #endif // DCOM
  567.  
  568. #if DBG == 1
  569. WINOLEAPI_(ULONG) DebugCoGetRpcFault( void );
  570. WINOLEAPI_(void) DebugCoSetRpcFault( ULONG );
  571. #endif
  572.  
  573. /* register/revoke/get class objects */
  574.  
  575. WINOLEAPI  CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved,
  576.                     REFIID riid, LPVOID FAR* ppv);
  577. WINOLEAPI  CoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk,
  578.                     DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister);
  579. WINOLEAPI  CoRevokeClassObject(DWORD dwRegister);
  580. WINOLEAPI  CoResumeClassObjects(void);
  581. WINOLEAPI  CoSuspendClassObjects(void);
  582. WINOLEAPI_(ULONG) CoAddRefServerProcess(void);
  583. WINOLEAPI_(ULONG) CoReleaseServerProcess(void);
  584. WINOLEAPI  CoGetPSClsid(REFIID riid, CLSID *pClsid);
  585. WINOLEAPI  CoRegisterPSClsid(REFIID riid, REFCLSID rclsid);
  586.  
  587. /* marshaling interface pointers */
  588.  
  589. WINOLEAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, LPUNKNOWN pUnk,
  590.                     DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
  591. WINOLEAPI CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk,
  592.                     DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
  593. WINOLEAPI CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID FAR* ppv);
  594. WINOLEAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult);
  595. WINOLEAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT FAR * phresult);
  596. WINOLEAPI CoReleaseMarshalData(LPSTREAM pStm);
  597. WINOLEAPI CoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved);
  598. WINOLEAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
  599. WINOLEAPI CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk,
  600.                     DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags,
  601.                     LPMARSHAL FAR* ppMarshal);
  602.  
  603. WINOLEAPI_(BOOL) CoIsHandlerConnected(LPUNKNOWN pUnk);
  604. WINOLEAPI_(BOOL) CoHasStrongExternalConnections(LPUNKNOWN pUnk);
  605.  
  606. // Apartment model inter-thread interface passing helpers
  607. WINOLEAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk,
  608.                     LPSTREAM *ppStm);
  609.  
  610. WINOLEAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid,
  611.                     LPVOID FAR* ppv);
  612.  
  613. WINOLEAPI CoCreateFreeThreadedMarshaler(LPUNKNOWN  punkOuter,
  614.                     LPUNKNOWN *ppunkMarshal);
  615.  
  616. /* dll loading helpers; keeps track of ref counts and unloads all on exit */
  617.  
  618. WINOLEAPI_(HINSTANCE) CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
  619. WINOLEAPI_(void) CoFreeLibrary(HINSTANCE hInst);
  620. WINOLEAPI_(void) CoFreeAllLibraries(void);
  621. WINOLEAPI_(void) CoFreeUnusedLibraries(void);
  622.  
  623.  
  624. #if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  625.  
  626. /* Call Security. */
  627.  
  628. WINOLEAPI CoInitializeSecurity(
  629.                     PSECURITY_DESCRIPTOR         pSecDesc,
  630.                     LONG                         cAuthSvc,
  631.                     SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
  632.                     void                        *pReserved1,
  633.                     DWORD                        dwAuthnLevel,
  634.                     DWORD                        dwImpLevel,
  635.                     void                        *pReserved2,
  636.                     DWORD                        dwCapabilities,
  637.                     void                        *pReserved3 );
  638. WINOLEAPI CoGetCallContext( REFIID riid, void **ppInterface );
  639. WINOLEAPI CoQueryProxyBlanket(
  640.     IUnknown                  *pProxy,
  641.     DWORD                     *pwAuthnSvc,
  642.     DWORD                     *pAuthzSvc,
  643.     OLECHAR                  **pServerPrincName,
  644.     DWORD                     *pAuthnLevel,
  645.     DWORD                     *pImpLevel,
  646.     RPC_AUTH_IDENTITY_HANDLE  *pAuthInfo,
  647.     DWORD                     *pCapabilites );
  648. WINOLEAPI CoSetProxyBlanket(
  649.     IUnknown                 *pProxy,
  650.     DWORD                     dwAuthnSvc,
  651.     DWORD                     dwAuthzSvc,
  652.     OLECHAR                  *pServerPrincName,
  653.     DWORD                     dwAuthnLevel,
  654.     DWORD                     dwImpLevel,
  655.     RPC_AUTH_IDENTITY_HANDLE  pAuthInfo,
  656.     DWORD                     dwCapabilities );
  657. WINOLEAPI CoCopyProxy(
  658.     IUnknown    *pProxy,
  659.     IUnknown   **ppCopy );
  660. WINOLEAPI CoQueryClientBlanket(
  661.     DWORD             *pAuthnSvc,
  662.     DWORD             *pAuthzSvc,
  663.     OLECHAR          **pServerPrincName,
  664.     DWORD             *pAuthnLevel,
  665.     DWORD             *pImpLevel,
  666.     RPC_AUTHZ_HANDLE  *pPrivs,
  667.     DWORD             *pCapabilities );
  668. WINOLEAPI CoImpersonateClient();
  669. WINOLEAPI CoRevertToSelf();
  670. WINOLEAPI CoQueryAuthenticationServices(
  671.     DWORD *pcAuthSvc,
  672.     SOLE_AUTHENTICATION_SERVICE **asAuthSvc );
  673. WINOLEAPI CoSwitchCallContext( IUnknown *pNewObject, IUnknown **ppOldObject );
  674.  
  675. #define COM_RIGHTS_EXECUTE 1
  676.  
  677. #endif // DCOM
  678.  
  679. /* helper for creating instances */
  680.  
  681. WINOLEAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
  682.                     DWORD dwClsContext, REFIID riid, LPVOID FAR* ppv);
  683.  
  684.  
  685. #if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  686.  
  687. WINOLEAPI CoGetInstanceFromFile(
  688.     COSERVERINFO *              pServerInfo,
  689.     CLSID       *               pClsid,
  690.     IUnknown    *               punkOuter, // only relevant locally
  691.     DWORD                       dwClsCtx,
  692.     DWORD                       grfMode,
  693.     OLECHAR *                   pwszName,
  694.     DWORD                       dwCount,
  695.     MULTI_QI        *           pResults );
  696.  
  697. WINOLEAPI CoGetInstanceFromIStorage(
  698.     COSERVERINFO *              pServerInfo,
  699.     CLSID       *               pClsid,
  700.     IUnknown    *               punkOuter, // only relevant locally
  701.     DWORD                       dwClsCtx,
  702.     struct IStorage *           pstg,
  703.     DWORD                       dwCount,
  704.     MULTI_QI        *           pResults );
  705.  
  706. WINOLEAPI CoCreateInstanceEx(
  707.     REFCLSID                    Clsid,
  708.     IUnknown    *               punkOuter, // only relevant locally
  709.     DWORD                       dwClsCtx,
  710.     COSERVERINFO *              pServerInfo,
  711.     DWORD                       dwCount,
  712.     MULTI_QI        *           pResults );
  713.  
  714. #endif // DCOM
  715.  
  716.  
  717. /* other helpers */
  718.  
  719. WINOLEAPI StringFromCLSID(REFCLSID rclsid, LPOLESTR FAR* lplpsz);
  720. WINOLEAPI CLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid);
  721. WINOLEAPI StringFromIID(REFIID rclsid, LPOLESTR FAR* lplpsz);
  722. WINOLEAPI IIDFromString(LPOLESTR lpsz, LPIID lpiid);
  723. WINOLEAPI_(BOOL) CoIsOle1Class(REFCLSID rclsid);
  724. WINOLEAPI ProgIDFromCLSID (REFCLSID clsid, LPOLESTR FAR* lplpszProgID);
  725. WINOLEAPI CLSIDFromProgID (LPCOLESTR lpszProgID, LPCLSID lpclsid);
  726. WINOLEAPI_(int) StringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax);
  727.  
  728. WINOLEAPI CoCreateGuid(GUID FAR *pguid);
  729.  
  730. WINOLEAPI_(BOOL) CoFileTimeToDosDateTime(
  731.                  FILETIME FAR* lpFileTime, LPWORD lpDosDate, LPWORD lpDosTime);
  732. WINOLEAPI_(BOOL) CoDosDateTimeToFileTime(
  733.                        WORD nDosDate, WORD nDosTime, FILETIME FAR* lpFileTime);
  734. WINOLEAPI  CoFileTimeNow( FILETIME FAR* lpFileTime );
  735.  
  736.  
  737. WINOLEAPI CoRegisterMessageFilter( LPMESSAGEFILTER lpMessageFilter,
  738.                                 LPMESSAGEFILTER FAR* lplpMessageFilter );
  739.  
  740. #if (_WIN32_WINNT >= 0x0400 ) || defined(_WIN32_DCOM) // DCOM
  741. WINOLEAPI CoRegisterChannelHook( REFGUID ExtensionUuid, IChannelHook *pChannelHook );
  742. #endif // DCOM
  743.  
  744.  
  745. /* TreatAs APIS */
  746.  
  747. WINOLEAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pClsidNew);
  748. WINOLEAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew);
  749.  
  750.  
  751. /* the server dlls must define their DllGetClassObject and DllCanUnloadNow
  752.  * to match these; the typedefs are located here to ensure all are changed at
  753.  * the same time.
  754.  */
  755.  
  756. //#ifdef _MAC
  757. //typedef STDAPICALLTYPE HRESULT (* LPFNGETCLASSOBJECT) (REFCLSID, REFIID, LPVOID *);
  758. //#else
  759. typedef HRESULT (STDAPICALLTYPE * LPFNGETCLASSOBJECT) (REFCLSID, REFIID, LPVOID *);
  760. //#endif
  761.  
  762. //#ifdef _MAC
  763. //typedef STDAPICALLTYPE HRESULT (* LPFNCANUNLOADNOW)(void);
  764. //#else
  765. typedef HRESULT (STDAPICALLTYPE * LPFNCANUNLOADNOW)(void);
  766. //#endif
  767.  
  768. STDAPI  DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID FAR* ppv);
  769.  
  770. STDAPI  DllCanUnloadNow(void);
  771.  
  772.  
  773. /****** Default Memory Allocation ******************************************/
  774. WINOLEAPI_(LPVOID) CoTaskMemAlloc(ULONG cb);
  775. WINOLEAPI_(LPVOID) CoTaskMemRealloc(LPVOID pv, ULONG cb);
  776. WINOLEAPI_(void)   CoTaskMemFree(LPVOID pv);
  777.  
  778. /****** DV APIs ***********************************************************/
  779.  
  780.  
  781. WINOLEAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder);
  782.  
  783. WINOLEAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid,
  784.                                         REFIID iid, LPVOID FAR* ppv);
  785.  
  786.  
  787.  
  788.  
  789. /****** Storage API Prototypes ********************************************/
  790.  
  791.  
  792. WINOLEAPI StgCreateDocfile(const OLECHAR FAR* pwcsName,
  793.             DWORD grfMode,
  794.             DWORD reserved,
  795.             IStorage FAR * FAR *ppstgOpen);
  796.  
  797. WINOLEAPI StgCreateDocfileOnILockBytes(ILockBytes FAR *plkbyt,
  798.                     DWORD grfMode,
  799.                     DWORD reserved,
  800.                     IStorage FAR * FAR *ppstgOpen);
  801.  
  802. WINOLEAPI StgOpenStorage(const OLECHAR FAR* pwcsName,
  803.               IStorage FAR *pstgPriority,
  804.               DWORD grfMode,
  805.               SNB snbExclude,
  806.               DWORD reserved,
  807.               IStorage FAR * FAR *ppstgOpen);
  808. WINOLEAPI StgOpenStorageOnILockBytes(ILockBytes FAR *plkbyt,
  809.                   IStorage FAR *pstgPriority,
  810.                   DWORD grfMode,
  811.                   SNB snbExclude,
  812.                   DWORD reserved,
  813.                   IStorage FAR * FAR *ppstgOpen);
  814.  
  815. WINOLEAPI StgIsStorageFile(const OLECHAR FAR* pwcsName);
  816. WINOLEAPI StgIsStorageILockBytes(ILockBytes FAR* plkbyt);
  817.  
  818. WINOLEAPI StgSetTimes(OLECHAR const FAR* lpszName,
  819.                    FILETIME const FAR* pctime,
  820.                    FILETIME const FAR* patime,
  821.                    FILETIME const FAR* pmtime);
  822.  
  823. WINOLEAPI StgOpenAsyncDocfileOnIFillLockBytes( IFillLockBytes *pflb,
  824.              DWORD grfMode,
  825.              DWORD asyncFlags,
  826.              IStorage **ppstgOpen);
  827.  
  828. WINOLEAPI StgGetIFillLockBytesOnILockBytes( ILockBytes *pilb,
  829.              IFillLockBytes **ppflb);
  830.  
  831. WINOLEAPI StgGetIFillLockBytesOnFile(OLECHAR const *pwcsName,
  832.              IFillLockBytes **ppflb);
  833.  
  834.  
  835. WINOLEAPI StgOpenLayoutDocfile(OLECHAR const *pwcsDfName,
  836.              DWORD grfMode,
  837.              DWORD reserved,
  838.              IStorage **ppstgOpen);
  839.  
  840.  
  841.  
  842. //
  843. //  Moniker APIs
  844. //
  845.  
  846. WINOLEAPI  BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult, LPVOID FAR* ppvResult);
  847. WINOLEAPI  CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, void **ppv);
  848. WINOLEAPI  MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName,
  849.                 ULONG FAR * pchEaten, LPMONIKER FAR * ppmk);
  850. WINOLEAPI  MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest, LPMONIKER
  851.                 FAR* ppmkRelPath, BOOL dwReserved);
  852. WINOLEAPI  MonikerCommonPrefixWith(LPMONIKER pmkThis, LPMONIKER pmkOther,
  853.                 LPMONIKER FAR* ppmkCommon);
  854. WINOLEAPI  CreateBindCtx(DWORD reserved, LPBC FAR* ppbc);
  855. WINOLEAPI  CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest,
  856.     LPMONIKER FAR* ppmkComposite);
  857. WINOLEAPI  GetClassFile (LPCOLESTR szFilename, CLSID FAR* pclsid);
  858.  
  859. WINOLEAPI  CreateClassMoniker(REFCLSID rclsid, LPMONIKER FAR* ppmk);
  860.  
  861. WINOLEAPI  CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk);
  862.  
  863. WINOLEAPI  CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem,
  864.     LPMONIKER FAR* ppmk);
  865. WINOLEAPI  CreateAntiMoniker(LPMONIKER FAR* ppmk);
  866. WINOLEAPI  CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER FAR* ppmk);
  867.  
  868. WINOLEAPI  GetRunningObjectTable( DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot);
  869.  
  870. #ifndef RC_INVOKED
  871. #pragma option -b.
  872. #include <poppack.h>
  873. #pragma option -b
  874. #endif // RC_INVOKED
  875.  
  876. #endif     // __OBJBASE_H__
  877. #pragma option -b.
  878.