//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1993. // // File: ole2com.h // // Contents: Common definitions shared by com and ole232 // // Classes: // // Functions: // // History: 4-26-94 kevinro Created // 06-16-94 AlexT Add FnAssert prototype // 07-26-94 AlexGo Added CStabilize and CSafeRefCount // 21-Dec-94 BruceMa Wrap mbstowcs and wcstombs // 23-Jan-95 t-ScottH added Dump method to CSafeRefCount // 08-Sep-95 murthys Added declarations for compapi worker // used by com, stg, scm etc // // Notes: // There are two versions of ole2int.h in the project. This is // unfortunate, but would be a major pain in the butt to fix. // What I have done is to extract the share parts of the two files, // and put them in this file. ole2int.h then includes this file. // // Someday, somebody should reconcile all of the differences between the // two ole2int.h files, and rename them. Don't have time for that now, // so I have gone for the path of least resistance. // KevinRo //---------------------------------------------------------------------------- #ifndef _OLE2COM_H_ #define _OLE2COM_H_ #include // // common compobj API worker functions used by com, stg, scm etc // // These definitions are shared between all of the components of OLE that // use the common directory, such as SCM and COMPOBJ // // format for string form of GUID is (leading identifier ????) // ????{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X} #define GUIDSTR_MAX (1+ 8 + 1 + 4 + 1 + 4 + 1 + 4 + 1 + 12 + 1 + 1) #define CLSIDSTR_MAX (GUIDSTR_MAX) #define IIDSTR_MAX (GUIDSTR_MAX) // // Internal values used between OLE32 and SCM // #define APT_THREADED 0 #define FREE_THREADED 1 #define SINGLE_THREADED 2 #define BOTH_THREADED 3 #define NEUTRAL_THREADED 4 #define GOT_FROM_ROT 0x80000000 // // Internal CLSCTX used for loading Proxy/Stub DLLs // #define CLSCTX_PS_DLL 0x80000000 // // The following flags are used to support loading INPROC items into 16-bit DLL's // #define CLSCTX_INPROC_HANDLERS (CLSCTX_INPROC_HANDLER16 | CLSCTX_INPROC_HANDLER | CLSCTX_INPROC_HANDLERX86) #define CLSCTX_INPROC_SERVERS (CLSCTX_INPROC_SERVER16 | CLSCTX_INPROC_SERVER | CLSCTX_INPROC_SERVERX86 | CLSCTX_PS_DLL) // "common" compapi worker functions INTERNAL_(int) wStringFromGUID2(REFGUID rguid, LPWSTR lpsz, int cbMax); INTERNAL wStringFromUUID(REFGUID rguid, LPWSTR lpsz); void FormatHexNumW( unsigned long ulValue, unsigned long chChars, WCHAR *pwcStr); void FormatHexNumA( unsigned long ulValue, unsigned long chChars, char *pchStr); #ifdef _CHICAGO_ INTERNAL_(int) wStringFromGUID2A(REFGUID rguid, LPSTR lpsz, int cbMax); #define wStringFromGUID2T wStringFromGUID2A #else #define wStringFromGUID2T wStringFromGUID2 #endif BOOL wThreadModelMatch(DWORD dwCallerThreadModel,DWORD dwDllThreadModel,DWORD dwContext); LONG wQueryStripRegValue(HKEY hkey,LPCWSTR pwszSubKey,LPTSTR pwszValue, PLONG pcbValue); LONG wGetDllInfo(HKEY hClsRegEntry,LPCWSTR pwszKey,LPTSTR pwszDllName,LONG *pclDllName,ULONG *pulDllThreadType); BOOL wCompareDllName(LPCWSTR pwszPath, LPCWSTR pwszDllName, DWORD dwDllNameLen); // compapi worker functions INTERNAL wIsInternalProxyStubIID(REFIID riid, LPCLSID lpclsid); INTERNAL wCoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew); INTERNAL wCLSIDFromOle1Class(LPCWSTR lpsz, LPCLSID lpclsid, BOOL fForceAssign=FALSE); INTERNAL wCLSIDFromString(LPWSTR lpsz, LPCLSID lpclsid); #define wCLSIDFromProgID wCLSIDFromOle1Class INTERNAL_(int) wOle1ClassFromCLSID2(REFCLSID rclsid, LPWSTR lpsz, int cbMax); INTERNAL wCoGetTreatAsClass(REFCLSID clsidOld, LPCLSID lpClsidNew); INTERNAL wRegQueryPSClsid(REFIID riid, LPCLSID lpclsid); INTERNAL wRegQuerySyncIIDFromAsyncIID(REFIID riid, LPCLSID lpiidSync); INTERNAL wRegQueryAsyncIIDFromSyncIID(REFIID riid, LPCLSID lpiidAsync); INTERNAL wCoGetPSClsid(REFIID riid, LPCLSID lpclsid); INTERNAL wCoGetClassExt(LPCWSTR pwszExt, LPCLSID pclsid); INTERNAL wRegGetClassExt(LPCWSTR lpszExt, LPCLSID pclsid); INTERNAL wCoGetClassPattern(HANDLE hfile, CLSID *pclsid); INTERNAL wCoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwContext, REFIID riid, LPVOID FAR* ppv); INTERNAL_(HRESULT) wCoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk, LPSTREAM *ppStm); INTERNAL_(HRESULT) wCoGetInterfaceAndReleaseStream(LPSTREAM pstm, REFIID riid, LPVOID *ppv); INTERNAL_(BOOL) wGUIDFromString(LPCWSTR lpsz, LPGUID pguid); INTERNAL_(BOOL) wUUIDFromString(LPCWSTR lpsz, LPGUID pguid); INTERNAL wStringFromCLSID(REFCLSID rclsid, LPWSTR FAR* lplpsz); INTERNAL wStringFromIID(REFIID rclsid, LPWSTR FAR* lplpsz); INTERNAL wIIDFromString(LPWSTR lpsz, LPIID lpiid); INTERNAL_(BOOL) wCoIsOle1Class(REFCLSID rclsid); INTERNAL wkProgIDFromCLSID(REFCLSID rclsid, LPWSTR FAR* ppszProgID); INTERNAL wRegOpenClassKey(REFCLSID clsid, REGSAM samDesired, HKEY FAR* lphkeyClsid); INTERNAL wRegOpenClassSubkey(REFCLSID rclsid, LPCWSTR lpszSubkey, HKEY *phkeySubkey); INTERNAL wRegOpenFileExtensionKey(LPCWSTR pszFileExt, HKEY FAR* lphkeyClsid); INTERNAL wRegOpenInterfaceKey(REFIID riid, HKEY * lphkeyIID); INTERNAL wRegOpenProgIDKey(LPCWSTR pszProgID, HKEY FAR* lphkeyClsid); INTERNAL wRegQueryClassValue(REFCLSID rclsid, LPCWSTR lpszSubKey, LPWSTR lpszValue, int cbMax); INTERNAL_(LONG) wRegOpenKeyEx( HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult); // // There are two sets of possible keys. There are the 32 bit, as well as // the 16 bit // #ifdef _KEVINROS_CHICAGO_CHANGES_ const WCHAR wszOle32Dll[] = L"OLE32.DLL"; #define OLE32_DLL wszOle32Dll #define OLE32_BYTE_LEN sizeof(OLE32_DLL) #define OLE32_CHAR_LEN (sizeof(OLE32_DLL) / sizeof(WCHAR) - 1) #endif const WCHAR wszCLSID[] = L"CLSID"; const WCHAR wszInprocServer[] = L"InprocServer32"; const WCHAR wszInprocHandler[] = L"InprocHandler32"; const WCHAR wszLocalServer[] = L"LocalServer32"; const WCHAR wszActivateAtBits[] = L"ActivateAtBits"; const WCHAR wszActivateRemote[] = L"Remote"; const WCHAR wszDebug[] = L"Debug"; const WCHAR wszLocalServer16[] = L"LocalServer"; const WCHAR wszInprocServer16[] = L"InprocServer"; const WCHAR wszInprocHandler16[] = L"InprocHandler"; const WCHAR wszOle2Dll[] = L"OLE2.DLL"; #define OLE2_DLL wszOle2Dll #define OLE2_BYTE_LEN sizeof(OLE2_DLL) #define OLE2_CHAR_LEN (sizeof(OLE2_DLL) / sizeof(WCHAR) - 1) const WCHAR wszCLSIDBACK[] = L"CLSID\\"; #define CLSIDBACK wszCLSIDBACK #define CLSIDBACK_BYTE_LEN sizeof(CLSIDBACK) #define CLSIDBACK_CHAR_LEN (sizeof(CLSIDBACK) / sizeof(WCHAR) - 1) #define KEY_LEN 256 // max size of registry key #define VALUE_LEN 256 // max size of registry value #ifdef _CAIRO_ #define _DCOM_ // enable definition of Cairo OLE COM extensions #include #else // These API's are exposed for Cairo but not for Daytona, so we declare // them here for internal users WINOLEAPI OleInitializeEx(LPVOID pvReserved, DWORD); WINOLEAPI CoGetPersistentInstance( REFIID riid, DWORD dwCtrl, DWORD grfMode, OLECHAR *pwszName, struct IStorage *pstg, REFCLSID rclsidOle1, BOOL * pfOle1Loaded, void **ppvUnk); #endif // // No longer in the Cairo DEF file. We want to remove this as soon as // oleutest can be changed to not use it. // WINOLEAPI CoNewPersistentInstance( REFCLSID rclsid, REFIID riid, DWORD dwCtrl, DWORD grfMode, OLECHAR *pwszCreateFrom, struct IStorage *pstgCreateFrom, OLECHAR *pwszNewName, void **ppunk); #if DBG==1 STDAPI FnAssert(LPSTR lpstrExpr, LPSTR lpstrMsg, LPSTR lpstrFileName, UINT iLine); ULONG GetInfoLevel(CHAR *pszKey, ULONG *pulValue, CHAR *pszdefval); void StgDebugInit(void); #endif // // The Storage entry points that are called from OLE entry points. // HRESULT Storage32DllGetClassObject(REFCLSID clsid, REFIID riid, void **ppv); STDAPI Storage32DllRegisterServer(void); #if defined(_M_I86SM) || defined(_M_I86MM) #define _NEARDATA #endif #ifdef WIN32 #define HTASK DWORD // Use Proccess id / Thread id #endif #ifdef WIN32 // we have to define these because they have been deleted from // win32s, where only the ...Ex versions exist anymore. // Now, that's backward compatibility! # define SetWindowOrg(h,x,y) SetWindowOrgEx((h),(x),(y),NULL) # define SetWindowExt(h,x,y) SetWindowExtEx((h),(x),(y),NULL) # define SetViewportOrg(h,x,y) SetViewportOrgEx((h),(x),(y),NULL) # define SetViewportExt(h,x,y) SetViewportExtEx((h),(x),(y),NULL) # define SetBitmapDimension(h,x,y) SetBitmapDimensionEx((h),(x),(y),NULL) #endif #ifdef WIN32 # define _xstrcpy lstrcpyW # define _xstrcat lstrcatW # define _xstrlen lstrlenW # define _xstrchr wcschr # define _xstrcmp lstrcmpW # define _xstricmp lstrcmpiW # define _xstrtok wcstok # define _xisdigit(c) (IsCharAlphaNumericW(c) && !IsCharAlphaW(c)) #else // !WIN32 # define _xstrcpy _fstrcpy # define _xstrcat _fstrcat # define _xstrlen _fstrlen # define _xstrchr _fstrchr # define _xstrcmp _fstrcmp # define _xstricmp _fstricmp # define _xstrtok _fstrtok # define _xisdigit(c) isdigit(c) #endif // WIN32 //+---------------------------------------------------------------------------- // // Macro: // GETPPARENT // // Synopsis: // Given a pointer to something contained by a struct (or // class,) the type name of the containing struct (or class), // and the name of the member being pointed to, return a pointer // to the container. // // Arguments: // [pmemb] -- pointer to member of struct (or class.) // [struc] -- type name of containing struct (or class.) // [membname] - name of member within the struct (or class.) // // Returns: // pointer to containing struct (or class) // // Notes: // Assumes all pointers are FAR. // // History: // 11/10/93 - ChrisWe - created // //----------------------------------------------------------------------------- #define GETPPARENT(pmemb, struc, membname) (\ (struc FAR *)(((char FAR *)(pmemb))-offsetof(struc, membname))) //STDSTATIC is intended to be used for static class methods //only!! #define STDSTATIC_(type) static type EXPORT #define STDSTATICIMP_(type) type EXPORT #ifdef WIN32 # define WEP_FREE_DLL 0 # define WEP_SYSTEM_EXIT 1 #endif #ifdef WIN32 inline UINT GetDriveTypeFromNumber(int i) { TCHAR szDevice[] = TEXT("A:\\"); // Pick off the drive letter from the input path. *szDevice = i + 'A'; #ifdef _UNICODE return(GetDriveTypeW(szDevice)); #else return(GetDriveTypeA(szDevice)); #endif } #endif #ifndef _MAC /* dll's instance and module handles */ extern HMODULE g_hmodOLE2; extern HINSTANCE g_hinst; /* Variables for registered clipboard formats */ extern CLIPFORMAT g_cfObjectLink; extern CLIPFORMAT g_cfOwnerLink; extern CLIPFORMAT g_cfNative; extern CLIPFORMAT g_cfLink; extern CLIPFORMAT g_cfBinary; extern CLIPFORMAT g_cfFileName; extern CLIPFORMAT g_cfFileNameW; extern CLIPFORMAT g_cfNetworkName; extern CLIPFORMAT g_cfDataObject; extern CLIPFORMAT g_cfEmbeddedObject; extern CLIPFORMAT g_cfEmbedSource; extern CLIPFORMAT g_cfLinkSource; extern CLIPFORMAT g_cfOleDraw; extern CLIPFORMAT g_cfLinkSrcDescriptor; extern CLIPFORMAT g_cfObjectDescriptor; extern CLIPFORMAT g_cfCustomLinkSource; extern CLIPFORMAT g_cfPBrush; extern CLIPFORMAT g_cfMSDraw; extern CLIPFORMAT g_cfOlePrivateData; extern CLIPFORMAT g_cfScreenPicture; // used for XL and Word hack // see clipapi.cpp extern CLIPFORMAT g_cfOleClipboardPersistOnFlush; extern CLIPFORMAT g_cfMoreOlePrivateData; #endif // _MAC #include /* * Warning disables: * * We compile with warning level 4, with the following warnings * disabled: * * 4355: 'this' used in base member initializer list * * We don't see the point of this message and we do this all * the time. * * 4505: Unreferenced local function has been removed -- the given * function is local and not referenced in the body of the module. * * Unfortunately, this is generated for every inline function * seen in the header files that is not used in the module. * Since we use a number of inlines, this is a nuisance * warning. It would be nice if the compiler distinguished * between inlines and regular functions. * * 4706: Assignment within conditional expression. * * We use this style of programming extensively, so this * warning is disabled. */ #pragma warning(disable:4355) #pragma warning(disable:4068) /* * MACROS for Mac/PC core code * * The following macros reduce the proliferation of #ifdefs. They * allow tagging a fragment of code as Mac only, PC only, or with * variants which differ on the PC and the Mac. * * Usage: * * * h = GetHandle(); * Mac(DisposeHandle(h)); * * * h = GetHandle(); * MacWin(h2 = h, CopyHandle(h, h2)); * */ #ifdef _MAC #define Mac(x) x #define Win(x) #define MacWin(x,y) x #else #define Mac(x) #define Win(x) x #define MacWin(x,y) y #endif // Define WX86OLE if WX86 hooks are to be included into ole and scm #if defined(WX86) #ifndef WX86OLE #define WX86OLE #endif #endif #ifdef WX86OLE const WCHAR wszInprocServerX86[] = L"InprocServerX86"; const WCHAR wszInprocHandlerX86[] = L"InprocHandlerX86"; #endif // // The following include is for an interface between OLE and Wx86 #ifdef WX86OLE #include extern CWx86 gcwx86; #endif // // The following includes an interface that is common between the // WOW thunk layer, and the 32-bit version of OLE. // #include // WOW thunking interfaces // // A call to CoInitializeWOW will set the following variable. When set, // it points to a VTABLE of functions that we can call in the thunk // DLL. Only used when running in a VDM. // extern LPOLETHUNKWOW g_pOleThunkWOW; // debug versions of interlocked increment/decrement; not accurate // under multi-threading conditions, but better than the return value // of the Interlocked increment/decrement functions. inline DWORD InterlockedAddRef(DWORD *pRefs) { #if DBG==1 DWORD refs = *pRefs + 1; InterlockedIncrement((LPLONG)pRefs); return refs; #else return InterlockedIncrement((LPLONG)pRefs); #endif } inline DWORD InterlockedRelease(DWORD *pRefs) { #if DBG==1 DWORD refs = *pRefs - 1; return InterlockedDecrement((LPLONG)pRefs) == 0 ? 0 : refs; #else return InterlockedDecrement((LPLONG)pRefs); #endif } // helper for getting stable pointers during destruction or other times; // NOTE: not thread safe; must provide higher level synchronization inline void SafeReleaseAndNULL(IUnknown **ppUnk) { if (*ppUnk != NULL) { IUnknown *pUnkSave = *ppUnk; *ppUnk = NULL; pUnkSave->Release(); } } /***********************************************************************/ /* FILE FORMAT RELATED INFO ****/ // Coponent object stream information #define COMPOBJ_STREAM OLESTR("\1CompObj") #define BYTE_ORDER_INDICATOR 0xfffe // for MAC it could be different #define COMPOBJ_STREAM_VERSION 0x0001 // OLE defines values for different OSs #define OS_WIN 0x0000 #define OS_MAC 0x0001 #define OS_NT 0x0002 // HIGH WORD is OS indicator, LOW WORD is OS version number extern DWORD gdwOrgOSVersion; extern DWORD gdwOleVersion; // Ole streams information #define OLE_STREAM OLESTR("\1Ole") #define OLE_PRODUCT_VERSION 0x0200 /* (HIGH BYTE major version) */ #define OLE_STREAM_VERSION 0x0001 #define OLE10_NATIVE_STREAM OLESTR("\1Ole10Native") #define OLE10_ITEMNAME_STREAM OLESTR("\1Ole10ItemName") #define OLE_PRESENTATION_STREAM OLESTR("\2OlePres000") #define OLE_MAX_PRES_STREAMS 1000 #define OLE_CONTENTS_STREAM OLESTR("CONTENTS") #define OLE_INVALID_STREAMNUM (-1) /************************************************************************/ /**** Storage APIs internally used ****/ /************************************************************************/ STDAPI ReadClipformatStm(LPSTREAM lpstream, DWORD FAR* lpdwCf); STDAPI WriteClipformatStm(LPSTREAM lpstream, CLIPFORMAT cf); STDAPI WriteMonikerStm (LPSTREAM pstm, LPMONIKER pmk); STDAPI ReadMonikerStm (LPSTREAM pstm, LPMONIKER FAR* pmk); STDAPI_(LPSTREAM) CreateMemStm(DWORD cb, LPHANDLE phMem); STDAPI_(LPSTREAM) CloneMemStm(HANDLE hMem); STDAPI_(void) ReleaseMemStm (LPHANDLE hMem, BOOL fInternalOnly = FALSE); STDAPI GetClassFileEx( LPCWSTR lpszFileName, CLSID FAR *pcid, REFCLSID clsidOle1); /*************************************************************************/ /*** Initialization code for individual modules ***/ /*************************************************************************/ INTERNAL_(void) DDEWEP ( BOOL fSystemExit ); INTERNAL_(BOOL) DDELibMain ( HANDLE hInst, WORD wDataSeg, WORD cbHeapSize, LPWSTR lpszCmdLine ); BOOL InitializeRunningObjectTable(void); HRESULT GetObjectFromRotByPath( WCHAR *pwszPath, IUnknown **ppvUnk); void DestroyRunningObjectTable(void); /************************************************************************** 'lindex' related macros ***************************************************************************/ #define DEF_LINDEX (-1) //+------------------------------------------------------------------------- // // Function: IsValidLINDEX // // Synopsis: Tests for valid combination of aspect and lindex // // Arguments: [dwAspect] -- aspect (part of FORMATETC) // [lindex] -- lindex (part of FORMATETC) // // Returns: TRUE for valid lindex, else FALSE // // History: 20-Jun-94 AlexT Created // // Notes: Here is the spec for lindex values: // // dwAspect lindex values // -------- ------------- // DVASPECT_CONTENT -1 // DVASPECT_DOCPRINT anything // DVASPECT_ICON -1 // DVASPECT_THUMBNAIL -1 // // So, we test for lindex == -1 or aspect == DOCPRINT // //-------------------------------------------------------------------------- inline BOOL IsValidLINDEX(DWORD dwAspect, LONG lindex) { return((DEF_LINDEX == lindex) || (DVASPECT_DOCPRINT == dwAspect)); } //+------------------------------------------------------------------------- // // Function: HasValidLINDEX // // Synopsis: Tests for valid combination of aspect and lindex // // Arguments: [pFormatEtc] -- pFormatEtc to test // // Returns: TRUE for valid lindex, else FALSE // // History: 20-Jun-94 AlexT Created // // Notes: See IsValidLINDEX, above // //-------------------------------------------------------------------------- inline BOOL HasValidLINDEX(FORMATETC const *pFormatEtc) { return(IsValidLINDEX(pFormatEtc->dwAspect, pFormatEtc->lindex)); } #define INIT_FORETC(foretc) { \ (foretc).ptd = NULL; \ (foretc).lindex = DEF_LINDEX; \ (foretc).dwAspect = DVASPECT_CONTENT; \ } // Only DDE layer will test for these values. And only for advises on cached // formats do we use these values #define ADVFDDE_ONSAVE 0x40000000 #define ADVFDDE_ONCLOSE 0x80000000 // Used in Ole Private Stream typedef enum tagOBJFLAGS { OBJFLAGS_LINK=1L, OBJFLAGS_DOCUMENT=2L, // this bit is owned by container and is // propogated through saves OBJFLAGS_CONVERT=4L, OBJFLAGS_CACHEEMPTY=8L // this bit indicates cache empty status } OBJFLAGS; /***************************************** Prototypes for dde\client\ddemnker.cpp ******************************************/ INTERNAL DdeBindToObject (LPCOLESTR szFile, REFCLSID clsid, BOOL fPackageLink, REFIID iid, LPLPVOID ppv); INTERNAL DdeIsRunning (CLSID clsid, LPCOLESTR szFile, LPBC pbc, LPMONIKER pmkToLeft, LPMONIKER pmkNewlyRunning); /************************************** Prototypes for moniker\mkparse.cpp ***************************************/ INTERNAL Ole10_ParseMoniker (LPMONIKER pmk, LPOLESTR FAR* pszFile, LPOLESTR FAR* pszItem); STDAPI CreateOle1FileMoniker(LPWSTR, REFCLSID, LPMONIKER FAR*); /****************************************************************************/ /* Utility APIs, might get exposed later */ /****************************************************************************/ STDAPI OleGetData(LPDATAOBJECT lpDataObj, LPFORMATETC pformatetcIn, LPSTGMEDIUM pmedium, BOOL fGetOwnership); STDAPI OleSetData(LPDATAOBJECT lpDataObj, LPFORMATETC pformatetc, STGMEDIUM FAR * pmedium, BOOL fRelease); STDAPI OleDuplicateMedium(LPSTGMEDIUM lpMediumSrc, LPSTGMEDIUM lpMediumDest); STDAPI_(BOOL) OleIsDcMeta (HDC hdc); STDAPI SzFixNet( LPBINDCTX pbc, LPOLESTR szUNCName, LPOLESTR FAR * lplpszReturn, UINT FAR * pEndServer, BOOL fForceConnection = TRUE); FARINTERNAL ReadFmtUserTypeProgIdStg (IStorage FAR * pstg, CLIPFORMAT FAR* pcf, LPOLESTR FAR* pszUserType, LPOLESTR szProgID); //+------------------------------------------------------------------------- // // Function: IsWOWProcess(), BOOL inline // // Synopsis: Tests whether or not we are running in a WOW process // // Returns: TRUE if in WOW process, FALSE otherwise // // Algorithm: // // History: dd-mmm-yy Author Comment // 15-Nov-95 murthys created // // Notes: // //-------------------------------------------------------------------------- inline BOOL IsWOWProcess() { return (BOOL) ( NULL == g_pOleThunkWOW ? FALSE : TRUE ); } //+------------------------------------------------------------------------- // // Function: IsWOWThread(), BOOL inline // // Synopsis: Tests whether or not we are running in a 16-bit thread in a // WOW process // // Returns: TRUE if in 16-bit thread in a WOW process, FALSE otherwise // // Algorithm: // // History: dd-mmm-yy Author Comment // 15-Nov-95 murthys created // // Notes: // //-------------------------------------------------------------------------- BOOLEAN TLSIsWOWThread(); inline BOOL IsWOWThread() { return (BOOL) ( IsWOWProcess() ? TLSIsWOWThread(): FALSE ); } //+------------------------------------------------------------------------- // // Function: IsWOWThreadCallable(), BOOL inline // // Synopsis: Tests whether or not we can call into OLETHK32. // // Returns: TRUE if WOW thread is callable, FALSE if not // // Algorithm: Tests the g_pOleThunkWOW pointer to see if it is non-zero // and not set to -1. -1 means we are in wow, but OLETHK32 // has already been unloaded. Also, checks to see if we're in // amidst a DLL_THREAD_DETACH. We will not allow calls to 16-bit // side in this case as it may have already been cleaned up. // // History: dd-mmm-yy Author Comment // 19-mar-95 KevinRo Created // 15-Nov-95 MurthyS Renamed from IsWowCallable // 29-Jan-95 MurthyS Added check for DLL_THREAD_DETACH // // Notes: // Assumes that IsWOWThread() was called and returned TRUE! // //-------------------------------------------------------------------------- BOOLEAN TLSIsThreadDetaching(); inline BOOL IsWOWThreadCallable() { return (BOOL) (( NULL == g_pOleThunkWOW ? FALSE : ( INVALID_HANDLE_VALUE == g_pOleThunkWOW ? FALSE:TRUE)) && !(TLSIsThreadDetaching())); } /****************************************************************************/ /* Stabilization classes */ /* These are used to stabilize objects during re-entrant calls */ /****************************************************************************/ #ifndef CO_E_RELEASED #define CO_E_RELEASED -2147467246L #endif typedef void * IFBuffer; //+------------------------------------------------------------------------- // // Function: GetMarshalledInterfaceBuffer // // Synopsis: marshals the given interface into an allocated buffer. The // buffer is returned // // Effects: // // Arguments: [refiid] -- the iid of the interface to marshal // [punk] -- the IUnknown to marshal // [pIFBuf] -- where to return the buffer // // Requires: // // Returns: HRESULT // // Signals: // // Modifies: // // Algorithm: calls CoMarshalInterface(MSHFLAGS_TABLESTRONG) // // History: dd-mmm-yy Author Comment // 03-Dec-94 alexgo author // // Notes: // //-------------------------------------------------------------------------- HRESULT GetMarshalledInterfaceBuffer( REFIID riid, IUnknown *punk, IFBuffer *pIFBuf); //+------------------------------------------------------------------------- // // Function: ReleaseMarshalledInterfaceBuffer // // Synopsis: releases the buffer allocated by GetMarshalledInterfaceBuffer // // Effects: // // Arguments: [IFBuf] -- the interface buffer to release // // Requires: // // Returns: HRESULT // // Signals: // // Modifies: // // Algorithm: calls CoReleaseMarshalData to undo the TABLE_STRONG // marshalling // // History: dd-mmm-yy Author Comment // 03-Dec-94 alexgo author // // Notes: // //-------------------------------------------------------------------------- HRESULT ReleaseMarshalledInterfaceBuffer( IFBuffer IFBuf ); #define E_UNSPEC E_FAIL #include #include #include #ifdef WIN32 // REVIEW, just using this for tracking # define OLE_E_NOOLE1 MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x00FE) #endif // WIN32 /***********************************************************************/ /* Wrap mbstowcs and wcstombs which are unsafe to use */ /* since they rely on crt.dll */ /* */ /* Note: cCh in both cases is the output buffer size, not a */ /* string length. */ /* */ /***********************************************************************/ #define mbstowcs(x, y, z) DONT_USE_mbstowcs___USE_MultiByteToWideChar_INSTEAD #define wcstombs(x, y, z) DONT_USE_wcstombs___USE_WideCharToMultiByte_INSTEAD //------------------------------------------------------------------ // // Dynamically Loaded System APIs // // OLEs implementations of these system APIs dynamically load the // system DLLs. Since these are rarely used APIs we dynamically // load them to reduce the load time of OLE32.DLL // // The implementations can be found in com\util\dynload.cxx // //------------------------------------------------------------------ // Our own load library helper. BOOL LoadSystemProc(LPSTR szDll, LPCSTR szProc, HINSTANCE *phInst, FARPROC *ppfnProc); // From MPR.DLL #undef WNetGetConnection #define WNetGetConnection(x,y,z) USE_OleWNetGetConnection_INSTEAD DWORD OleWNetGetConnection(LPCWSTR lpLocalName, LPWSTR lpRemoteName, LPDWORD lpnLength); #ifndef _CHICAGO_ #undef WNetGetUniversalName #define WNetGetUniversalName(w,x,y,z) USE_OleWNetGetUniversalName_INSTEAD DWORD OleWNetGetUniversalName(LPCWSTR szLocalPath, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpBufferSize); #endif // From SHELL32.DLL #undef ExtractIcon #define ExtractIcon(x,y,z) USE_OleExtractIcon_INSTEAD HICON OleExtractIcon(HINSTANCE hInst, LPCWSTR lpszFileName, UINT nIconIndex); #undef ExtractAssociatedIcon #define ExtractAssociatedIcon(x,y,z) USE_OleExtractAssociatedIcon_INSTEAD HICON OleExtractAssociatedIcon(HINSTANCE hInst, LPCWSTR lpszFileName, LPWORD pIndex); // From GDI32P.DLL HBRUSH OleGdiConvertBrush(HBRUSH hbrush); HBRUSH OleGdiCreateLocalBrush(HBRUSH hbrushRemote); #undef SHGetFileInfo #define SHGetFileInfo(v,w,x,y,z) USE_OleSHGetFileInfo_INSTEAD DWORD OleSHGetFileInfo(LPCWSTR pszPath, DWORD dwFileAttributes, SHFILEINFO FAR *psfi, UINT cbFileInfo, UINT uFlags); // HOOK OLE macros for wrapping interface pointers #include // ---------------------------------------------------------------------------- // API/Method trace output // ---------------------------------------------------------------------------- #include // ---------------------------------------------------------------------------- // Catalog related declarations: these are defined in ..\..\common\ccompapi.cxx // ---------------------------------------------------------------------------- #include HRESULT InitializeCatalogIfNecessary(); HRESULT UninitializeCatalog(); extern IComCatalog *gpCatalog; extern IComCatalogSCM *gpCatalogSCM; #endif // _OLE2COM_H_