//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1995. // // File: objbase.h // // Contents: Component object model defintions. // //---------------------------------------------------------------------------- #ifndef __RPCBASE_H__ #include "rpcbase.h" #endif /* ___RPCBASE_H__ */ #ifndef NORPC #ifndef __RPC_H__ #include #endif /* ___RPC_H__ */ #ifndef __RPCNDR_H__ #include #endif /* __RPCNDR_H_ */ #endif /* NORPC */ #if !defined( _OBJBASE_H_ ) #define _OBJBASE_H_ #include // Component Object Model defines, and macros #ifdef __cplusplus #define EXTERN_C extern "C" #else #define EXTERN_C extern #endif #ifdef _WIN32 // Win32 doesn't support __export #define STDMETHODCALLTYPE __stdcall #define STDMETHODVCALLTYPE __cdecl #define STDAPICALLTYPE __stdcall #define STDAPIVCALLTYPE __cdecl #else #define STDMETHODCALLTYPE __export __stdcall #define STDMETHODVCALLTYPE __export __cdecl #define STDAPICALLTYPE __export __stdcall #define STDAPIVCALLTYPE __export __cdecl #endif #define STDAPI EXTERN_C HRESULT STDAPICALLTYPE #define STDAPI_(type) EXTERN_C type STDAPICALLTYPE #define STDMETHODIMP HRESULT STDMETHODCALLTYPE #define STDMETHODIMP_(type) type STDMETHODCALLTYPE // The 'V' versions allow Variable Argument lists. #define STDAPIV EXTERN_C HRESULT STDAPIVCALLTYPE #define STDAPIV_(type) EXTERN_C type STDAPIVCALLTYPE #define STDMETHODIMPV HRESULT STDMETHODVCALLTYPE #define STDMETHODIMPV_(type) type STDMETHODVCALLTYPE #ifdef _OLE32_ #define WINOLEAPI STDAPI #define WINOLEAPI_(type) STDAPI_(type) #else #define WINOLEAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE #define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE #endif /****** Interface Declaration ***********************************************/ /* * These are macros for declaring interfaces. They exist so that * a single definition of the interface is simulataneously a proper * declaration of the interface structures (C++ abstract classes) * for both C and C++. * * DECLARE_INTERFACE(iface) is used to declare an interface that does * not derive from a base interface. * DECLARE_INTERFACE_(iface, baseiface) is used to declare an interface * that does derive from a base interface. * * By default if the source file has a .c extension the C version of * the interface declaratations will be expanded; if it has a .cpp * extension the C++ version will be expanded. if you want to force * the C version expansion even though the source file has a .cpp * extension, then define the macro "CINTERFACE". * eg. cl -DCINTERFACE file.cpp * * Example Interface declaration: * * #undef INTERFACE * #define INTERFACE IClassFactory * * DECLARE_INTERFACE_(IClassFactory, IUnknown) * { * // *** IUnknown methods *** * STDMETHOD(QueryInterface) (THIS_ * REFIID riid, * LPVOID FAR* ppvObj) PURE; * STDMETHOD_(ULONG,AddRef) (THIS) PURE; * STDMETHOD_(ULONG,Release) (THIS) PURE; * * // *** IClassFactory methods *** * STDMETHOD(CreateInstance) (THIS_ * LPUNKNOWN pUnkOuter, * REFIID riid, * LPVOID FAR* ppvObject) PURE; * }; * * Example C++ expansion: * * struct FAR IClassFactory : public IUnknown * { * virtual HRESULT STDMETHODCALLTYPE QueryInterface( * IID FAR& riid, * LPVOID FAR* ppvObj) = 0; * virtual HRESULT STDMETHODCALLTYPE AddRef(void) = 0; * virtual HRESULT STDMETHODCALLTYPE Release(void) = 0; * virtual HRESULT STDMETHODCALLTYPE CreateInstance( * LPUNKNOWN pUnkOuter, * IID FAR& riid, * LPVOID FAR* ppvObject) = 0; * }; * * NOTE: Our documentation says '#define interface class' but we use * 'struct' instead of 'class' to keep a lot of 'public:' lines * out of the interfaces. The 'FAR' forces the 'this' pointers to * be far, which is what we need. * * Example C expansion: * * typedef struct IClassFactory * { * const struct IClassFactoryVtbl FAR* lpVtbl; * } IClassFactory; * * typedef struct IClassFactoryVtbl IClassFactoryVtbl; * * struct IClassFactoryVtbl * { * HRESULT (STDMETHODCALLTYPE * QueryInterface) ( * IClassFactory FAR* This, * IID FAR* riid, * LPVOID FAR* ppvObj) ; * HRESULT (STDMETHODCALLTYPE * AddRef) (IClassFactory FAR* This) ; * HRESULT (STDMETHODCALLTYPE * Release) (IClassFactory FAR* This) ; * HRESULT (STDMETHODCALLTYPE * CreateInstance) ( * IClassFactory FAR* This, * LPUNKNOWN pUnkOuter, * IID FAR* riid, * LPVOID FAR* ppvObject); * HRESULT (STDMETHODCALLTYPE * LockServer) ( * IClassFactory FAR* This, * BOOL fLock); * }; */ #if defined(__cplusplus) && !defined(CINTERFACE) //#define interface struct FAR #define interface struct #define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method #define STDMETHOD_(type,method) virtual type STDMETHODCALLTYPE method #define PURE = 0 #define THIS_ #define THIS void #define DECLARE_INTERFACE(iface) interface iface #define DECLARE_INTERFACE_(iface, baseiface) interface iface : public baseiface #else #define interface struct #define STDMETHOD(method) HRESULT (STDMETHODCALLTYPE * method) #define STDMETHOD_(type,method) type (STDMETHODCALLTYPE * method) #define PURE #define THIS_ INTERFACE FAR* This, #define THIS INTERFACE FAR* This #ifdef CONST_VTABLE #define CONST_VTBL const #define DECLARE_INTERFACE(iface) typedef interface iface { \ const struct iface##Vtbl FAR* lpVtbl; \ } iface; \ typedef const struct iface##Vtbl iface##Vtbl; \ const struct iface##Vtbl #else #define CONST_VTBL #define DECLARE_INTERFACE(iface) typedef interface iface { \ struct iface##Vtbl FAR* lpVtbl; \ } iface; \ typedef struct iface##Vtbl iface##Vtbl; \ struct iface##Vtbl #endif #define DECLARE_INTERFACE_(iface, baseiface) DECLARE_INTERFACE(iface) #endif /****** Additional basic types **********************************************/ #ifndef FARSTRUCT #ifdef __cplusplus #define FARSTRUCT FAR #else #define FARSTRUCT #endif // __cplusplus #endif // FARSTRUCT #ifndef HUGEP #ifdef _WIN32 #define HUGEP #else #define HUGEP __huge #endif // WIN32 #endif // HUGEP #include #define LISet32(li, v) ((li).HighPart = (v) < 0 ? -1 : 0, (li).LowPart = (v)) #define ULISet32(li, v) ((li).HighPart = 0, (li).LowPart = (v)) #define CLSCTX_ALL (CLSCTX_INPROC_SERVER| \ CLSCTX_INPROC_HANDLER| \ CLSCTX_LOCAL_SERVER) #define CLSCTX_INPROC (CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER) #define CLSCTX_SERVER (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER) // class registration flags; passed to CoRegisterClassObject typedef enum tagREGCLS { REGCLS_SINGLEUSE = 0, // class object only generates one instance REGCLS_MULTIPLEUSE = 1, // same class object genereates multiple inst. // and local automatically goes into inproc tbl. REGCLS_MULTI_SEPARATE = 2 // multiple use, but separate control over each // context. } REGCLS; // interface marshaling definitions #define MARSHALINTERFACE_MIN 500 // minimum number of bytes for interface marshl // // Common typedefs for paramaters used in Storage API's, gleamed from storage.h // Also contains Storage error codes, which should be moved into the storage // idl files. // #define CWCSTORAGENAME 32 /* Storage instantiation modes */ #define STGM_DIRECT 0x00000000L #define STGM_TRANSACTED 0x00010000L #define STGM_SIMPLE 0x08000000L #define STGM_READ 0x00000000L #define STGM_WRITE 0x00000001L #define STGM_READWRITE 0x00000002L #define STGM_SHARE_DENY_NONE 0x00000040L #define STGM_SHARE_DENY_READ 0x00000030L #define STGM_SHARE_DENY_WRITE 0x00000020L #define STGM_SHARE_EXCLUSIVE 0x00000010L #define STGM_PRIORITY 0x00040000L #define STGM_DELETEONRELEASE 0x04000000L #if (WINVER >= 400) #define STGM_NOSCRATCH 0x00100000L #endif /* WINVER */ #define STGM_CREATE 0x00001000L #define STGM_CONVERT 0x00020000L #define STGM_FAILIFTHERE 0x00000000L /* here is where we pull in the MIDL generated headers for the interfaces */ typedef interface IRpcStubBuffer IRpcStubBuffer; typedef interface IRpcChannelBuffer IRpcChannelBuffer; #ifndef __wtypes_h__ #include #endif /* __wtypes_h__ */ #ifndef __unknwn_h__ #include #endif /* __unknwn_h__ */ #ifndef __objidl_h__ #include #endif /* __objidl_h__ */ // macros to define byte pattern for a GUID. // Example: DEFINE_GUID(GUID_XXX, a, b, c, ...); // // Each dll/exe must initialize the GUIDs once. This is done in one of // two ways. If you are not using precompiled headers for the file(s) which // initializes the GUIDs, define INITGUID before including objbase.h. This // is how OLE builds the initialized versions of the GUIDs which are included // in ole2.lib. The GUIDs in ole2.lib are all defined in the same text // segment GUID_TEXT. // // The alternative (which some versions of the compiler don't handle properly; // they wind up with the initialized GUIDs in a data, not a text segment), // is to use a precompiled version of objbase.h and then include initguid.h // after objbase.h followed by one or more of the guid defintion files. #ifndef INITGUID #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ EXTERN_C const GUID CDECL FAR name #else #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ EXTERN_C const GUID CDECL name \ = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } #endif // INITGUID #define DEFINE_OLEGUID(name, l, w1, w2) \ DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46) #ifdef __cplusplus inline BOOL IsEqualGUID(REFGUID rguid1, REFGUID rguid2) { return !memcmp(&rguid1, &rguid2, sizeof(GUID)); } #else // ! __cplusplus #define IsEqualGUID(rguid1, rguid2) (!memcmp(rguid1, rguid2, sizeof(GUID))) #endif // __cplusplus #define IsEqualIID(riid1, riid2) IsEqualGUID(riid1, riid2) #define IsEqualCLSID(rclsid1, rclsid2) IsEqualGUID(rclsid1, rclsid2) #ifdef __cplusplus // because GUID is defined elsewhere in WIN32 land, the operator == and != // are moved outside the class to global scope. inline BOOL operator==(const GUID& guidOne, const GUID& guidOther) { #ifdef _WIN32 return !memcmp(&guidOne,&guidOther,sizeof(GUID)); #else return !_fmemcmp(&guidOne,&guidOther,sizeof(GUID)); } #endif } inline BOOL operator!=(const GUID& guidOne, const GUID& guidOther) { return !(guidOne == guidOther); } #endif // __cpluscplus #ifndef INITGUID #include #endif /****** STD Object API Prototypes *****************************************/ WINOLEAPI_(DWORD) CoBuildVersion( VOID ); /* init/uninit */ WINOLEAPI CoInitialize(LPVOID pvReserved); WINOLEAPI_(void) CoUninitialize(void); WINOLEAPI CoGetMalloc(DWORD dwMemContext, LPMALLOC FAR* ppMalloc); WINOLEAPI_(DWORD) CoGetCurrentProcess(void); WINOLEAPI CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy); WINOLEAPI CoRevokeMallocSpy(void); WINOLEAPI CoCreateStandardMalloc(DWORD memctx, IMalloc FAR* FAR* ppMalloc); #if DBG == 1 WINOLEAPI_(ULONG) DebugCoGetRpcFault( void ); WINOLEAPI_(void) DebugCoSetRpcFault( ULONG ); #endif /* register/revoke/get class objects */ WINOLEAPI CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved, REFIID riid, LPVOID FAR* ppv); WINOLEAPI CoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister); WINOLEAPI CoRevokeClassObject(DWORD dwRegister); /* marshaling interface pointers */ WINOLEAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags); WINOLEAPI CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags); WINOLEAPI CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID FAR* ppv); WINOLEAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult); WINOLEAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT FAR * phresult); WINOLEAPI CoReleaseMarshalData(LPSTREAM pStm); WINOLEAPI CoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved); WINOLEAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases); WINOLEAPI CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk, DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags, LPMARSHAL FAR* ppMarshal); WINOLEAPI_(BOOL) CoIsHandlerConnected(LPUNKNOWN pUnk); WINOLEAPI_(BOOL) CoHasStrongExternalConnections(LPUNKNOWN pUnk); // Apartment model inter-thread interface passing helpers WINOLEAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM *ppStm); WINOLEAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid, LPVOID FAR* ppv); WINOLEAPI CoCreateFreeThreadedMarshaler(LPUNKNOWN punkOuter, LPUNKNOWN *ppunkMarshal); /* dll loading helpers; keeps track of ref counts and unloads all on exit */ WINOLEAPI_(HINSTANCE) CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree); WINOLEAPI_(void) CoFreeLibrary(HINSTANCE hInst); WINOLEAPI_(void) CoFreeAllLibraries(void); WINOLEAPI_(void) CoFreeUnusedLibraries(void); /* helper for creating instances */ WINOLEAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID riid, LPVOID FAR* ppv); /* other helpers */ WINOLEAPI StringFromCLSID(REFCLSID rclsid, LPOLESTR FAR* lplpsz); WINOLEAPI CLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid); WINOLEAPI StringFromIID(REFIID rclsid, LPOLESTR FAR* lplpsz); WINOLEAPI IIDFromString(LPOLESTR lpsz, LPIID lpiid); WINOLEAPI_(BOOL) CoIsOle1Class(REFCLSID rclsid); WINOLEAPI ProgIDFromCLSID (REFCLSID clsid, LPOLESTR FAR* lplpszProgID); WINOLEAPI CLSIDFromProgID (LPCOLESTR lpszProgID, LPCLSID lpclsid); WINOLEAPI_(int) StringFromGUID2(REFGUID rguid, LPOLESTR lpsz, int cbMax); WINOLEAPI CoCreateGuid(GUID FAR *pguid); WINOLEAPI_(BOOL) CoFileTimeToDosDateTime( FILETIME FAR* lpFileTime, LPWORD lpDosDate, LPWORD lpDosTime); WINOLEAPI_(BOOL) CoDosDateTimeToFileTime( WORD nDosDate, WORD nDosTime, FILETIME FAR* lpFileTime); WINOLEAPI CoFileTimeNow( FILETIME FAR* lpFileTime ); WINOLEAPI CoRegisterMessageFilter( LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER FAR* lplpMessageFilter ); /* TreatAs APIS */ WINOLEAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pClsidNew); WINOLEAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew); /* the server dlls must define their DllGetClassObject and DllCanUnloadNow * to match these; the typedefs are located here to ensure all are changed at * the same time. */ #ifdef _MAC typedef STDAPICALLTYPE HRESULT (* LPFNGETCLASSOBJECT) (REFCLSID, REFIID, LPVOID *); #else typedef HRESULT (STDAPICALLTYPE * LPFNGETCLASSOBJECT) (REFCLSID, REFIID, LPVOID *); #endif #ifdef _MAC typedef STDAPICALLTYPE HRESULT (* LPFNCANUNLOADNOW)(void); #else typedef HRESULT (STDAPICALLTYPE * LPFNCANUNLOADNOW)(void); #endif STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID FAR* ppv); STDAPI DllCanUnloadNow(void); /****** Default Memory Allocation ******************************************/ WINOLEAPI_(LPVOID) CoTaskMemAlloc(ULONG cb); WINOLEAPI_(LPVOID) CoTaskMemRealloc(LPVOID pv, ULONG cb); WINOLEAPI_(void) CoTaskMemFree(LPVOID pv); /****** DV APIs ***********************************************************/ WINOLEAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder); WINOLEAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid, REFIID iid, LPVOID FAR* ppv); /****** Storage API Prototypes ********************************************/ WINOLEAPI StgCreateDocfile(const OLECHAR FAR* pwcsName, DWORD grfMode, DWORD reserved, IStorage FAR * FAR *ppstgOpen); WINOLEAPI StgCreateDocfileOnILockBytes(ILockBytes FAR *plkbyt, DWORD grfMode, DWORD reserved, IStorage FAR * FAR *ppstgOpen); WINOLEAPI StgOpenStorage(const OLECHAR FAR* pwcsName, IStorage FAR *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage FAR * FAR *ppstgOpen); WINOLEAPI StgOpenStorageOnILockBytes(ILockBytes FAR *plkbyt, IStorage FAR *pstgPriority, DWORD grfMode, SNB snbExclude, DWORD reserved, IStorage FAR * FAR *ppstgOpen); WINOLEAPI StgIsStorageFile(const OLECHAR FAR* pwcsName); WINOLEAPI StgIsStorageILockBytes(ILockBytes FAR* plkbyt); WINOLEAPI StgSetTimes(OLECHAR const FAR* lpszName, FILETIME const FAR* pctime, FILETIME const FAR* patime, FILETIME const FAR* pmtime); // // Moniker APIs // WINOLEAPI BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult, LPVOID FAR* ppvResult); WINOLEAPI MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName, ULONG FAR * pchEaten, LPMONIKER FAR * ppmk); WINOLEAPI MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest, LPMONIKER FAR* ppmkRelPath, BOOL dwReserved); WINOLEAPI MonikerCommonPrefixWith(LPMONIKER pmkThis, LPMONIKER pmkOther, LPMONIKER FAR* ppmkCommon); WINOLEAPI CreateBindCtx(DWORD reserved, LPBC FAR* ppbc); WINOLEAPI CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest, LPMONIKER FAR* ppmkComposite); WINOLEAPI GetClassFile (LPCOLESTR szFilename, CLSID FAR* pclsid); WINOLEAPI CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk); WINOLEAPI CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem, LPMONIKER FAR* ppmk); WINOLEAPI CreateAntiMoniker(LPMONIKER FAR* ppmk); WINOLEAPI CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER FAR* ppmk); WINOLEAPI GetRunningObjectTable( DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot); #ifndef RC_INVOKED #include #endif // RC_INVOKED #endif // __OBJBASE_H__