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