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