953 lines
29 KiB
C
953 lines
29 KiB
C
//+---------------------------------------------------------------------------
|
|
//
|
|
// 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 <memapi.hxx>
|
|
|
|
//
|
|
// 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 <oleext.h>
|
|
|
|
#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 <utstream.h>
|
|
|
|
/*
|
|
* 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 <wx86grpa.hxx>
|
|
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 <thunkapi.hxx> // 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 <widewrap.h>
|
|
|
|
#include <stkswtch.h>
|
|
#include <shellapi.h>
|
|
|
|
#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 <hkole32.h>
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// API/Method trace output
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#include <trace.hxx>
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Catalog related declarations: these are defined in ..\..\common\ccompapi.cxx
|
|
// ----------------------------------------------------------------------------
|
|
|
|
#include <catalog.h>
|
|
|
|
HRESULT InitializeCatalogIfNecessary();
|
|
HRESULT UninitializeCatalog();
|
|
extern IComCatalog *gpCatalog;
|
|
extern IComCatalogSCM *gpCatalogSCM;
|
|
|
|
|
|
#endif // _OLE2COM_H_
|