|
|
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1996.
//
// File: create.cpp
//
// Contents: creation and miscellaneous APIs
//
// Classes:
//
// Functions: OleCreate
// OleCreateEx
// OleCreateFromData
// OleCreateFromDataEx
// OleCreateLinkFromData
// OleCreateLinkFromDataEx
// OleCreateLink
// OleCreateLinkEx
// OleCreateLinkToFile
// OleCreateLinkToFileEx
// OleCreateFromFile
// OleCreateFromFileEx
// OleDoAutoConvert
// OleLoad
// OleCreateStaticFromData
// OleQueryCreateFromData
// OleQueryLinkFromData
// CoIsHashedOle1Class (internal)
// EnsureCLSIDIsRegistered (internal)
//
// History: dd-mmm-yy Author Comment
// 26-Apr-96 davidwor Moved validation into separate function.
// 01-Mar-96 davidwor Added extended create functions.
// 16-Dec-94 alexgo added call tracing
// 07-Jul-94 KevinRo Changed RegQueryValue to RegOpenKey in
// strategic places.
// 10-May-94 KevinRo Reimplemented OLE 1.0 interop
// 24-Jan-94 alexgo first pass at converting to Cairo-style
// memory allocation
// 11-Jan-94 alexgo added VDATEHEAP macros to every function
// 10-Dec-93 AlexT header clean up - include ole1cls.h
// 08-Dec-93 ChrisWe added necessary casts to GlobalLock() calls
// resulting from removing bogus GlobalLock() macros in
// le2int.h
// 29-Nov-93 ChrisWe changed call to UtIsFormatSupported to
// take a single DWORD of direction flags
// 22-Nov-93 ChrisWe replaced overloaded == with IsEqualxID
// 28-Oct-93 alexgo 32bit port
// 24-Aug-92 srinik created
//
//--------------------------------------------------------------------------
#include <le2int.h>
#pragma SEG(create)
#include <create.h>
#include <ole1cls.h> // Only needed to get CLSID_WordDocument
// HACK ALERT!! This is needed for the MFC OleQueryCreateFromData hack
#include <clipdata.h>
NAME_SEG(Create)ASSERTDATA
//used in wCreateObject
#define STG_NONE 0
#define STG_INITNEW 1
#define STG_LOAD 2
#define QUERY_CREATE_NONE 0
#define QUERY_CREATE_OLE 1
#define QUERY_CREATE_STATIC 2
INTERNAL wDoUpdate(IUnknown FAR* lpUnknown);
//+-------------------------------------------------------------------------
//
// Function: wGetEnumFormatEtc
//
// Synopsis: retrieves a FormatEtc enumerator
//
// Effects:
//
// Arguments: [pDataObj] -- the data object
// [dwDirection] -- direction
// [ppenum] -- where to put the enumerator
//
// Requires:
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm: asks the data object for the enumerator
// if it returns OLE_S_USEREG, then get try to get the
// clsid from IOleObject::GetUserClassID and enumerate
// the formats from the registry.
//
// History: dd-mmm-yy Author Comment
// 24-Apr-94 alexgo author
// 13-Mar-95 scottsk Added hack for the Bob Calendar
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT wGetEnumFormatEtc( IDataObject *pDataObj, DWORD dwDirection, IEnumFORMATETC **ppIEnum){ HRESULT hresult; IOleObject * pOleObject; CLSID clsid;
VDATEHEAP();
LEDebugOut((DEB_ITRACE, "%p _IN wGetEnumFormatEtc ( %p , %p , %lx )" "\n", NULL, pDataObj, ppIEnum, dwDirection));
hresult = pDataObj->EnumFormatEtc(dwDirection, ppIEnum);
if( hresult == ResultFromScode(OLE_S_USEREG) ) { hresult = pDataObj->QueryInterface(IID_IOleObject, (void **)&pOleObject);
if( hresult != NOERROR ) { // return E_FAIL vs E_NOINTERFACE
hresult = ResultFromScode(E_FAIL); goto errRtn; }
hresult = pOleObject->GetUserClassID(&clsid);
if( hresult == NOERROR ) { hresult = OleRegEnumFormatEtc(clsid, dwDirection, ppIEnum); }
pOleObject->Release(); } else if (*ppIEnum == NULL && hresult == NOERROR) { // HACK ALERT: NT Bug #8350. MS Bob Calendar returns success from
// IDO::EnumFormatEtc and sets *ppIEnum = NULL on the IDO used during
// drag-drop. Massage the return value to be failure.
hresult = E_FAIL; }
errRtn:
LEDebugOut((DEB_ITRACE, "%p OUT wGetEnumFormatEtc ( %lx ) [ %p ]\n", NULL, hresult, *ppIEnum));
return hresult;}
//+-------------------------------------------------------------------------
//
// Function: OleCreate
//
// Synopsis: Creates and runs an object of the requested CLSID
//
// Effects:
//
// Arguments: [rclsid] -- the CLSID of the object to create
// [iid] -- the interface to request on the object
// [renderopt] -- render options, such as OLERENDER_DRAW
// [lpFormatEtc] -- rendering format, if OLERENDER_FORMAT is
// specified in renderopt.
// [lpClientSite] -- the client site for the object
// [lpStg] -- the object's storage
// [lplpObj] -- where to put the pointer to the created
// object
//
// Requires: HRESULT
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 05-May-94 alexgo fixed error case if cache initialization
// fails.
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreate)
STDAPI OleCreate( REFCLSID rclsid, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateEx(rclsid, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateEx
//
// Synopsis: Creates and runs an object of the requested CLSID
//
// Effects:
//
// Arguments: [rclsid] -- the CLSID of the object to create
// [iid] -- the interface to request on the object
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- the client site for the object
// [lpStg] -- the object's storage
// [lplpObj] -- where to put the pointer to the created
// object
//
// Requires: HRESULT
//
// Returns:
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 05-May-94 alexgo fixed error case if cache initialization
// fails.
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateEx)
STDAPI OleCreateEx( REFCLSID rclsid, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateEx, PARAMFMT("rclsid= %I, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), &rclsid, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
HRESULT error; FORMATETC formatEtc; LPFORMATETC lpFormatEtc; BOOL fAlloced = FALSE;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateEx ( %p , %p , %lx , %lx , %lx ," "%p , %p , %p , %p , %p , %p , %p )\n", 0, &rclsid, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, errRtn, error ); *lplpObj = NULL;
VDATEIID_LABEL( iid, errRtn, error);
error = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (error != NOERROR) goto errRtn;
if ((error = wValidateFormatEtcEx(renderopt, &cFormats, rgFormatEtc, &formatEtc, &lpFormatEtc, &fAlloced)) != NOERROR) goto LExit;
if ((error = wCreateObject(rclsid, FALSE, iid, lpClientSite, lpStg, STG_INITNEW, lplpObj)) != NOERROR) goto LExit;
// No need to Run the object if no caches are requested.
if ((renderopt != OLERENDER_NONE) && (renderopt != OLERENDER_ASIS)) { if ((error = OleRun((LPUNKNOWN) *lplpObj)) != NOERROR) goto LExit;
if ((error = wInitializeCacheEx(NULL, rclsid, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, *lplpObj)) != NOERROR) { // if this fails, we need to call Close
// to shut down the embedding (the reverse of Run).
// the final release below will be the final
// one to nuke the memory image.
IOleObject * lpOleObject;
if( ((IUnknown *)*lplpObj)->QueryInterface( IID_IOleObject, (void **)&lpOleObject) == NOERROR ) { Assert(lpOleObject); lpOleObject->Close(OLECLOSE_NOSAVE); lpOleObject->Release(); } } }
LExit:
if (fAlloced) PubMemFree(lpFormatEtc);
if (error != NOERROR && *lplpObj) { ((IUnknown FAR*) *lplpObj)->Release(); *lplpObj = NULL; }
LEDebugOut((DEB_TRACE, "%p OUT OleCreateEx ( %lx ) [ %p ]\n", 0, error, *lplpObj));
error = wReturnCreationError(error);
errRtn: OLETRACEOUT((API_OleCreateEx, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleCreateFromData
//
// Synopsis: Creates an embedded object from an IDataObject pointer
// (such as an data object from the clipboard or from a drag
// and drop operation)
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object from which
// the object should be created
// [iid] -- interface ID to request
// [renderopt] -- rendering options (same as OleCreate)
// [lpFormatEtc] -- render format options (same as OleCreate)
// [lpClientSite] -- client site for the object
// [lpStg] -- storage for the object
// [lplpObj] -- where to put the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateFromData)
STDAPI OleCreateFromData( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateFromDataEx(lpSrcDataObj, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateFromDataEx
//
// Synopsis: Creates an embedded object from an IDataObject pointer
// (such as an data object from the clipboard or from a drag
// and drop operation)
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object from which
// the object should be created
// [iid] -- interface ID to request
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- client site for the object
// [lpStg] -- storage for the object
// [lplpObj] -- where to put the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateFromDataEx)
STDAPI OleCreateFromDataEx( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ HRESULT hresult; CLIPFORMAT cfFormat; WORD wStatus;
OLETRACEIN((API_OleCreateFromDataEx, PARAMFMT("lpSrcDataObj= %p, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), lpSrcDataObj, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
LEDebugOut((DEB_TRACE, "%p _IN OleCreateFromDataEx ( %p , %p , %lx , %lx ," " %lx , %p , %p , %p , %p , %p , %p , %p )\n", 0, lpSrcDataObj, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, safeRtn, hresult ); *lplpObj = NULL;
VDATEIFACE_LABEL( lpSrcDataObj, errRtn, hresult ); VDATEIID_LABEL( iid, errRtn, hresult );
hresult = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (hresult != NOERROR) goto errRtn;
wStatus = wQueryEmbedFormats(lpSrcDataObj, &cfFormat);
if (!(wStatus & QUERY_CREATE_OLE)) { if (wStatus & QUERY_CREATE_STATIC) { hresult = OLE_E_STATIC; } else { hresult = DV_E_FORMATETC; }
goto errRtn; }
// We can create an OLE object.
// See whether we have to create a package
if (cfFormat == g_cfFileName || cfFormat == g_cfFileNameW) { hresult = wCreatePackageEx(lpSrcDataObj, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, FALSE /*fLink*/, lplpObj); } else { hresult = wCreateFromDataEx(lpSrcDataObj, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj); }
errRtn:
LEDebugOut((DEB_TRACE, "%p OUT OleCreateFromDataEx ( %lx ) [ %p ]\n", 0, hresult, *lplpObj));
safeRtn:
OLETRACEOUT((API_OleCreateFromDataEx, hresult));
return hresult;}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLinkFromData
//
// Synopsis: Creates a link from a data object (e.g. for Paste->Link)
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
// [iid] -- requested interface ID
// [renderopt] -- rendering options
// [lpFormatEtc] -- format to render (if renderopt ==
// OLERENDER_FORMAT)
// [lpClientSite] -- pointer to the client site
// [lpStg] -- pointer to the storage
// [lplpObj] -- where to put the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLinkFromData)
STDAPI OleCreateLinkFromData( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateLinkFromDataEx(lpSrcDataObj, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLinkFromDataEx
//
// Synopsis: Creates a link from a data object (e.g. for Paste->Link)
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
// [iid] -- requested interface ID
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site
// [lpStg] -- pointer to the storage
// [lplpObj] -- where to put the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLinkFromDataEx)
STDAPI OleCreateLinkFromDataEx( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateLinkFromDataEx, PARAMFMT("lpSrcDataObj= %p, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), lpSrcDataObj, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
HRESULT error; FORMATETC formatEtc; LPFORMATETC lpFormatEtc; BOOL fAlloced = FALSE; CLIPFORMAT cfFormat;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateLinkFromDataEx ( %p , %p , %lx," " %lx, %lx , %p , %p , %p, %p , %p , %p, %p )\n", NULL, lpSrcDataObj, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, safeRtn, error ); *lplpObj = NULL;
VDATEIFACE_LABEL( lpSrcDataObj, errRtn, error ); VDATEIID_LABEL( iid, errRtn, error );
error = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (error != NOERROR) goto errRtn;
cfFormat = wQueryLinkFormats(lpSrcDataObj);
if (cfFormat == g_cfLinkSource) { CLSID clsidLast; LPMONIKER lpmkSrc; LPDATAOBJECT lpBoundDataObj = NULL;
// we are going to create a normal link
if ((error = wValidateFormatEtcEx(renderopt, &cFormats, rgFormatEtc, &formatEtc, &lpFormatEtc, &fAlloced)) != NOERROR) { goto errRtn; }
if ((error = wGetMonikerAndClassFromObject(lpSrcDataObj, &lpmkSrc, &clsidLast)) != NOERROR) { goto errRtn; }
if (wQueryUseCustomLink(clsidLast)) { // the object supports Custom Link Source, so bind
// to the object and pass its IDataObject pointer
// to wCreateLinkEx()
if (BindMoniker(lpmkSrc, NULL /*grfOpt*/, IID_IDataObject, (LPLPVOID) &lpBoundDataObj) == NOERROR) { lpSrcDataObj = lpBoundDataObj; } }
// otherwise continue to use StdOleLink implementation
error = wCreateLinkEx(lpmkSrc, clsidLast, lpSrcDataObj, iid, dwFlags, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
// we don't need the moniker anymore
lpmkSrc->Release();
// we would have bound in the custom link source case,
// release the pointer
if (lpBoundDataObj) { if (error == NOERROR && (dwFlags & OLECREATE_LEAVERUNNING)) OleRun((LPUNKNOWN)*lplpObj);
lpBoundDataObj->Release(); }
} else if (cfFormat == g_cfFileName || cfFormat == g_cfFileNameW) { // See whether we have to create a packaged link
error = wCreatePackageEx(lpSrcDataObj, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, TRUE /*fLink*/, lplpObj); } else { error = DV_E_FORMATETC; }
errRtn:
if (fAlloced) PubMemFree(lpFormatEtc);
LEDebugOut((DEB_TRACE, "%p OUT OleCreateLinkFromDataEx ( %lx ) [ %p ]\n", NULL, error, *lplpObj));
safeRtn:
OLETRACEOUT((API_OleCreateLinkFromDataEx, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLink
//
// Synopsis: Create a link to the object referred to by a moniker
//
// Effects:
//
// Arguments: [lpmkSrc] -- source of the link
// [iid] -- interface requested
// [renderopt] -- rendering options
// [lpFormatEtc] -- rendering format (if needed)
// [lpClientSite] -- pointer to the client site for the link
// [lpStg] -- storage for the link
// [lplpObj] -- where to put the link object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLink)
STDAPI OleCreateLink( IMoniker FAR* lpmkSrc, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateLinkEx(lpmkSrc, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLinkEx
//
// Synopsis: Create a link to the object referred to by a moniker
//
// Effects:
//
// Arguments: [lpmkSrc] -- source of the link
// [iid] -- interface requested
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site for the link
// [lpStg] -- storage for the link
// [lplpObj] -- where to put the link object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLinkEx)
STDAPI OleCreateLinkEx( IMoniker FAR* lpmkSrc, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateLinkEx, PARAMFMT("lpmkSrc= %p, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), lpmkSrc, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
FORMATETC formatEtc; LPFORMATETC lpFormatEtc; BOOL fAlloced = FALSE; HRESULT error;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateLinkEx ( %p , %p , %lx, %lx," " %lx , %p , %p , %p, %p , %p , %p , %p )\n", NULL, lpmkSrc, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, errRtn, error ); *lplpObj = NULL;
VDATEIFACE_LABEL( lpmkSrc, errRtn, error); VDATEIID_LABEL( iid, errRtn, error );
error = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (error != NOERROR) goto errRtn;
if ((error = wValidateFormatEtcEx(renderopt, &cFormats, rgFormatEtc, &formatEtc, &lpFormatEtc, &fAlloced)) == NOERROR) { error = wCreateLinkEx(lpmkSrc, CLSID_NULL, NULL /* lpSrcDataObj */, iid, dwFlags, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
if (fAlloced) PubMemFree(lpFormatEtc); }
LEDebugOut((DEB_TRACE, "%p OUT OleCreateLinkEx ( %lx ) [ %p ]\n", NULL, error, *lplpObj));
errRtn: OLETRACEOUT((API_OleCreateLinkEx, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLinkToFile
//
// Synopsis: Creates a link object to the file specified in [lpszFileName]
//
// Effects:
//
// Arguments: [lpszFileName] -- the name of the file
// [iid] -- interface ID requested
// [renderopt] -- rendering options
// [lpFormatEtc] -- format in which to render (if [renderopt]
// == OLERENDER_FORMAT);
// [lpClientSite] -- pointer to the client site for the link
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put a pointer to new link object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port, fixed memory leak in error
// case
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLinkToFile)
STDAPI OleCreateLinkToFile( LPCOLESTR lpszFileName, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateLinkToFileEx(lpszFileName, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateLinkToFileEx
//
// Synopsis: Creates a link object to the file specified in [lpszFileName]
//
// Effects:
//
// Arguments: [lpszFileName] -- the name of the file
// [iid] -- interface ID requested
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site for the link
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put a pointer to new link object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port, fixed memory leak in error
// case
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateLinkToFileEx)
STDAPI OleCreateLinkToFileEx( LPCOLESTR lpszFileName, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateLinkToFileEx, PARAMFMT("lpszFileName= %ws, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), lpszFileName, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
LPMONIKER lpmkFile = NULL; LPDATAOBJECT lpDataObject = NULL; HRESULT error; BOOL fPackagerMoniker = FALSE; CLSID clsidFile;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateLinkToFileEx ( \"%s\" , %p , %lx ," " %lx , %lx , %p , %p , %p, %p , %p , %p , %p )\n", NULL, lpszFileName, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, safeRtn, error ); *lplpObj = NULL;
VDATEPTRIN_LABEL( (LPVOID)lpszFileName, OLECHAR, logRtn, error ); VDATEIID_LABEL( iid, logRtn, error );
error = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (error != NOERROR) goto logRtn;
if (((error = wGetMonikerAndClassFromFile(lpszFileName, TRUE /*fLink*/, &lpmkFile, &fPackagerMoniker, &clsidFile,&lpDataObject)) != NOERROR)) { goto logRtn; }
Verify(lpmkFile);
if (fPackagerMoniker) { // wValidateFormatEtc() will be done in wCreateFromFile()
Assert(NULL == lpDataObject); // Shouldn't be a BoundDataObject for Packager.
error = wCreateFromFileEx(lpmkFile,lpDataObject, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
} else { FORMATETC formatEtc; LPFORMATETC lpFormatEtc; BOOL fAlloced = FALSE;
if ((error = wValidateFormatEtcEx(renderopt, &cFormats, rgFormatEtc, &formatEtc, &lpFormatEtc, &fAlloced)) != NOERROR) { goto ErrRtn; }
error = wCreateLinkEx(lpmkFile, clsidFile, lpDataObject, iid, dwFlags, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
if (fAlloced) PubMemFree(lpFormatEtc); }
ErrRtn:
if (lpmkFile) { lpmkFile->Release(); }
// if the moniker was bound in CreateFromFile, release it now.
if (lpDataObject) { lpDataObject->Release(); }
if (error == NOERROR && !lpAdviseSink) { wStuffIconOfFileEx(lpszFileName, TRUE /*fAddLabel*/, renderopt, cFormats, rgFormatEtc, (LPUNKNOWN) *lplpObj); }
logRtn:
LEDebugOut((DEB_TRACE, "%p OUT OleCreateLinkToFileEx ( %lx ) [ %p ]\n", NULL, error, *lplpObj));
safeRtn: OLETRACEOUT((API_OleCreateLinkToFileEx, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleCreateFromFile
//
// Synopsis: Creates an ole object for embedding from a file (for
// InstertObject->From File type things)
//
// Effects:
//
// Arguments: [rclsid] -- CLSID to use for creating the object
// [lpszFileName] -- the filename
// [iid] -- the requested interface ID
// [renderopt] -- rendering options
// [lpFormatEtc] -- rendering format (if needed)
// [lpClientSite] -- pointer to the object's client site
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put the pointer to the new object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateFromFile)
STDAPI OleCreateFromFile( REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtc, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ DWORD advf = ADVF_PRIMEFIRST;
return OleCreateFromFileEx(rclsid, lpszFileName, iid, 0, renderopt, (lpFormatEtc ? 1 : 0), (lpFormatEtc ? &advf : NULL), lpFormatEtc, NULL, NULL, lpClientSite, lpStg, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateFromFileEx
//
// Synopsis: Creates an ole object for embedding from a file (for
// InstertObject->From File type things)
//
// Effects:
//
// Arguments: [rclsid] -- CLSID to use for creating the object
// [lpszFileName] -- the filename
// [iid] -- the requested interface ID
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the object's client site
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put the pointer to the new object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateFromFileEx)
STDAPI OleCreateFromFileEx( REFCLSID rclsid, LPCOLESTR lpszFileName, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateFromFileEx, PARAMFMT("rclsid= %I, lpszFileName= %ws, iid= %I, dwFlags= %x, renderopt= %x, cFormats= %x, rgAdvf= %te, rgFormatEtc= %p, lpAdviseSink= %p, rgdwConnection= %p, lpClientSite= %p, lpStg= %p, lplpObj= %p"), &rclsid, lpszFileName, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
LPMONIKER lpmkFile = NULL; LPDATAOBJECT lpDataObject = NULL; HRESULT error; CLSID clsid;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateFromFileEx ( %p , \"%s\" , %p ," " %lx , %lx , %lx , %p , %p , %p , %p , %p , %p , %p )\n", NULL, &rclsid, lpszFileName, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL( lplpObj, LPVOID, safeRtn, error ); *lplpObj = NULL;
VDATEPTRIN_LABEL( (LPVOID)lpszFileName, char, errRtn, error ); VDATEIID_LABEL( iid, errRtn, error );
error = wValidateCreateParams(dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg); if (error != NOERROR) goto errRtn;
if (((error = wGetMonikerAndClassFromFile(lpszFileName, FALSE /*fLink*/, &lpmkFile, NULL /*lpfPackagerMoniker*/, &clsid,&lpDataObject)) != NOERROR)) { goto errRtn; }
Verify(lpmkFile);
// wValidateFormatEtc() will be done in wCreateFromFile()
error = wCreateFromFileEx(lpmkFile,lpDataObject, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
if (lpDataObject) { lpDataObject->Release(); }
if (lpmkFile) { lpmkFile->Release(); }
if (error == NOERROR && !lpAdviseSink) { wStuffIconOfFileEx(lpszFileName, FALSE /*fAddLabel*/, renderopt, cFormats, rgFormatEtc, (LPUNKNOWN) *lplpObj); }
errRtn:
LEDebugOut((DEB_TRACE, "%p OUT OleCreateFromFileEx ( %lx ) [ %p ]\n", NULL, error, *lplpObj));
safeRtn:
OLETRACEOUT((API_OleCreateFromFileEx, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleDoAutoConvert
//
// Synopsis: Converts the storage to use the clsid given in
// [pClsidNew]. Private ole streams are updated with the new
// info
//
// Effects:
//
// Arguments: [pStg] -- storage to modify
// [pClsidNew] -- pointer to the new class ID
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
// Notes: REVIEW32: this function should be rewritten to use
// the new internal API for writing to ole-private streams
//
//--------------------------------------------------------------------------
#pragma SEG(OleDoAutoConvert)
STDAPI OleDoAutoConvert(LPSTORAGE pStg, LPCLSID pClsidNew){ OLETRACEIN((API_OleDoAutoConvert, PARAMFMT("pStg= %p, pClsidNew= %I"), pStg, pClsidNew));
VDATEHEAP();
HRESULT error; CLSID clsidOld; CLIPFORMAT cfOld; LPOLESTR lpszOld = NULL; LPOLESTR lpszNew = NULL;
if ((error = ReadClassStg(pStg, &clsidOld)) != NOERROR) { clsidOld = CLSID_NULL; goto errRtn; }
if ((error = OleGetAutoConvert(clsidOld, pClsidNew)) != NOERROR) goto errRtn;
// read old fmt/old user type; sets out params to NULL on error
error = ReadFmtUserTypeStg(pStg, &cfOld, &lpszOld); Assert(error == NOERROR || (cfOld == NULL && lpszOld == NULL));
// get new user type name; if error, set to NULL string
if ((error = OleRegGetUserType(*pClsidNew, USERCLASSTYPE_FULL, &lpszNew)) != NOERROR) lpszNew = NULL;
// write class stg
if ((error = WriteClassStg(pStg, *pClsidNew)) != NOERROR) goto errRtn;
// write old fmt/new user type;
if ((error = WriteFmtUserTypeStg(pStg, cfOld, lpszNew)) != NOERROR) goto errRewriteInfo;
// set convert bit
if ((error = SetConvertStg(pStg, TRUE)) != NOERROR) goto errRewriteInfo;
goto okRtn;
errRewriteInfo: (void)WriteClassStg(pStg, clsidOld); (void)WriteFmtUserTypeStg(pStg, cfOld, lpszOld);
errRtn: *pClsidNew = clsidOld;
okRtn: PubMemFree(lpszOld); PubMemFree(lpszNew);
OLETRACEOUT((API_OleDoAutoConvert, error)); return error;}
//+-------------------------------------------------------------------------
//
// Function: OleLoad
//
// Synopsis: Loads an object from the given storage
//
// Effects:
//
// Arguments: [lpStg] -- the storage to load from
// [iid] -- the requested interface ID
// [lpClientSite] -- client site for the object
// [lplpObj] -- where to put the pointer to the
// new object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleLoad)
STDAPI OleLoad( IStorage FAR* lpStg, REFIID iid, IOleClientSite FAR* lpClientSite, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleLoad, PARAMFMT("lpStg= %p, iid= %I, lpClientSite= %p, lplpObj= %p"), lpStg, &iid, lpClientSite, lplpObj));
VDATEHEAP();
HRESULT error;
LEDebugOut((DEB_TRACE, "%p _IN OleLoad ( %p , %p , %p , %p )\n", NULL, lpStg, &iid, lpClientSite, lplpObj));
if ((error = OleLoadWithoutBinding(lpStg, FALSE, iid, lpClientSite, lplpObj)) == NOERROR) { // The caller specify that he want a disconnected object by
// passing NULL for pClientSite
if (lpClientSite != NULL) wBindIfRunning((LPUNKNOWN) *lplpObj); }
LEDebugOut((DEB_TRACE, "%p OUT OleLoad ( %lx ) [ %p ]\n", NULL, error, (error == NOERROR ? *lplpObj : NULL)));
OLETRACEOUT((API_OleLoad, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleLoadWithoutBinding
//
// Synopsis: Internal function to load/create an object from a storage
// called by OleLoad, etc.
//
// Effects:
//
// Arguments: [lpStg] -- storage to load from
// [iid] -- requested interface ID
// [lpClientSite] -- pointer to the client site
// [lplpObj] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
// Notes: REVIEW32: this function is only used in a few, known
// places. we can maybe get rid of the VDATEPTR's.
//
//--------------------------------------------------------------------------
INTERNAL OleLoadWithoutBinding( IStorage FAR* lpStg, BOOL fPermitCodeDownload, //new parameter to control whether code download occurs or not -RahulTh (11/20/97)
REFIID iid, IOleClientSite FAR* lpClientSite, void FAR* FAR* lplpObj){ VDATEHEAP();
HRESULT error; CLSID clsid;
VDATEPTROUT( lplpObj, LPVOID ); *lplpObj = NULL; VDATEIID( iid ); VDATEIFACE( lpStg );
if (lpClientSite) VDATEIFACE( lpClientSite );
error = OleDoAutoConvert(lpStg, &clsid);
// error only used when clsid could not be read (when CLSID_NULL)
if (IsEqualCLSID(clsid, CLSID_NULL)) return error;
return wCreateObject (clsid, fPermitCodeDownload, iid, lpClientSite, lpStg, STG_LOAD, lplpObj);}
//+-------------------------------------------------------------------------
//
// Function: OleCreateStaticFromData
//
// Synopsis: Creates a static ole object from the data in [lpSrcDataObject]
// If [lpFormatEtcIn] is NULL, then the best possible
// presentation is extracted.
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
// [iid] -- requested interface ID for the new object
// [renderopt] -- redering options
// [lpClientSite] -- pointer to the client site
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 16-Dec-94 alexgo added call tracing
// 08-Jun-94 davepl Added EMF support
// 28-Oct-93 alexgo 32bit port
//
//--------------------------------------------------------------------------
#pragma SEG(OleCreateStaticFromData)
STDAPI OleCreateStaticFromData( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD renderopt, LPFORMATETC lpFormatEtcIn, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ OLETRACEIN((API_OleCreateStaticFromData, PARAMFMT("lpSrcDataObj= %p, iid= %I, renderopt= %x, lpFormatEtcIn= %te, lpClientSite= %p, lpStg= %p, lplpObj= %p"), lpSrcDataObj, &iid, renderopt, lpFormatEtcIn, lpClientSite, lpStg, lplpObj));
VDATEHEAP();
IOleObject FAR* lpOleObj = NULL; IOleCache FAR* lpOleCache = NULL; HRESULT error; FORMATETC foretc; FORMATETC foretcCache; STGMEDIUM stgmed; CLSID clsid; BOOL fReleaseStgMed = TRUE; LPOLESTR lpszUserType = NULL;
LEDebugOut((DEB_TRACE, "%p _IN OleCreateStaticFromData ( %p , %p , %lx ," " %p , %p , %p , %p , %p )\n", NULL, lpSrcDataObj, &iid, renderopt, lpFormatEtcIn, lpClientSite, lpStg, lplpObj));
VDATEPTROUT_LABEL(lplpObj, LPVOID, safeRtn, error); *lplpObj = NULL; VDATEIFACE_LABEL( lpSrcDataObj, logRtn, error ); VDATEIID_LABEL(iid, logRtn, error);
//VDATEPTRIN rejects NULL
if ( lpFormatEtcIn ) VDATEPTRIN_LABEL( lpFormatEtcIn, FORMATETC, logRtn, error ); VDATEIFACE_LABEL(lpStg, logRtn, error); if (lpClientSite) VDATEIFACE_LABEL(lpClientSite, logRtn, error);
if (renderopt == OLERENDER_NONE || renderopt == OLERENDER_ASIS) { error = E_INVALIDARG; goto logRtn; }
if ((error = wValidateFormatEtc (renderopt, lpFormatEtcIn, &foretc)) != NOERROR) { goto logRtn; }
if (renderopt == OLERENDER_DRAW) { if (!UtQueryPictFormat(lpSrcDataObj, &foretc)) { error = DV_E_CLIPFORMAT; goto logRtn; } }
// Set the proper CLSID, or return error if that isn't possible
if (foretc.cfFormat == CF_METAFILEPICT) { clsid = CLSID_StaticMetafile; } else if (foretc.cfFormat == CF_BITMAP || foretc.cfFormat == CF_DIB) { clsid = CLSID_StaticDib; } else if (foretc.cfFormat == CF_ENHMETAFILE) { clsid = CLSID_Picture_EnhMetafile; } else { error = DV_E_CLIPFORMAT; goto logRtn; }
error = lpSrcDataObj->GetData(&foretc, &stgmed); if (NOERROR != error) { // We should support the case where the caller wants one of
// CF_BITMAP and CF_DIB, and the object supports the other
// one those 2 formats. In this case we should do the proper
// conversion. Finally the cache that is going to be created
// would be a DIB cache.
AssertOutStgmedium(error, &stgmed);
if (foretc.cfFormat == CF_DIB) { foretc.cfFormat = CF_BITMAP; foretc.tymed = TYMED_GDI; } else if (foretc.cfFormat == CF_BITMAP) { foretc.cfFormat = CF_DIB; foretc.tymed = TYMED_HGLOBAL; } else { goto logRtn; }
error = lpSrcDataObj->GetData(&foretc, &stgmed); if (NOERROR != error) { AssertOutStgmedium(error, &stgmed); goto logRtn; } }
AssertOutStgmedium(error, &stgmed);
foretcCache = foretc; foretcCache.dwAspect = foretc.dwAspect = DVASPECT_CONTENT; foretcCache.ptd = NULL;
// Even when the caller asks for bitmap cache we create the DIB cache.
BITMAP_TO_DIB(foretcCache);
error = wCreateObject (clsid, FALSE, IID_IOleObject, lpClientSite, lpStg, STG_INITNEW, (LPLPVOID) &lpOleObj);
if (NOERROR != error) { goto errRtn; }
if (lpOleObj->QueryInterface(IID_IOleCache, (LPLPVOID) &lpOleCache) != NOERROR) { goto errRtn; }
error = lpOleCache->Cache (&foretcCache, ADVF_PRIMEFIRST, NULL /*pdwConnection*/);
if (FAILED(error)) { goto errRtn; }
//REVIEW32: err, are we sure this is a good idea???
//clearing out the error, that is
error = NOERROR;
// take ownership of the data
foretc.ptd = NULL; if ((error = lpOleCache->SetData (&foretc, &stgmed, TRUE)) != NOERROR) goto errRtn;
// Write format and user type
error = lpOleObj->GetUserType(USERCLASSTYPE_FULL, &lpszUserType); AssertOutPtrParam(error, lpszUserType); WriteFmtUserTypeStg(lpStg, foretcCache.cfFormat, lpszUserType); if (lpszUserType) PubMemFree(lpszUserType);
fReleaseStgMed = FALSE;
error = lpOleObj->QueryInterface (iid, lplpObj);
errRtn: if (fReleaseStgMed) ReleaseStgMedium(&stgmed);
if (lpOleCache) lpOleCache->Release();
if (error != NOERROR && *lplpObj) { ((IUnknown FAR*) *lplpObj)->Release(); *lplpObj = NULL; }
if (lpOleObj) lpOleObj->Release();
logRtn:
LEDebugOut((DEB_TRACE, "%p OUT OleCreateStaticFromData ( %lx ) [ %p ]\n", NULL, error, *lplpObj));
safeRtn: OLETRACEOUT((API_OleCreateStaticFromData, error));
return error;}
//+-------------------------------------------------------------------------
//
// Function: OleQueryCreateFromData
//
// Synopsis: Finds out what we can create from a data object (if anything)
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object of interest
//
// Requires:
//
// Returns: NOERROR -- an OLE object can be created
// QUERY_CREATE_STATIC -- a static object can be created
// S_FALSE -- nothing can be created
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(OleQueryCreateFromData)
STDAPI OleQueryCreateFromData (LPDATAOBJECT lpSrcDataObj){ OLETRACEIN((API_OleQueryCreateFromData, PARAMFMT("lpSrcDataObj= %p"), lpSrcDataObj));
VDATEHEAP(); VDATEIFACE( lpSrcDataObj ); CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IDataObject,(IUnknown **)&lpSrcDataObj);
CLIPFORMAT cfFormat; WORD wStatus = wQueryEmbedFormats(lpSrcDataObj, &cfFormat); HRESULT hr;
if (wStatus & QUERY_CREATE_OLE) // OLE object can be created
hr = NOERROR; else if (wStatus & QUERY_CREATE_STATIC) // static object can be created
hr = ResultFromScode(OLE_S_STATIC); else // no object can be created
hr = ResultFromScode(S_FALSE);
OLETRACEOUT((API_OleQueryCreateFromData, hr));
return hr;}
//+-------------------------------------------------------------------------
//
// Function: wQueryEmbedFormats
//
// Synopsis: Enumerates the formats of the object and looks for
// ones that let us create either an embeded or static object
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
// [lpcfFormat] -- place to put the clipboard format
// of the object
// Returns: WORD -- bit flag of QUERY_CREATE_NONE, QUERY_CREATE_STATIC
// and QUERY_CREATE_OLE
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
// 08-Jun-94 davepl Optimized by unwinding while() loop
// 22-Aug-94 alexgo added MFC hack
//
//--------------------------------------------------------------------------
static const unsigned int MAX_ENUM_STEP = 20;
INTERNAL_(WORD) wQueryEmbedFormats( LPDATAOBJECT lpSrcDataObj, CLIPFORMAT FAR* lpcfFormat){ VDATEHEAP();
// This adjusts the number of formats requested per enumeration
// step. If we are running in the WOW box, we should only ask
// for one at a time since it is unknown how well old code will
// support bulk enumerations.
ULONG ulEnumSize = IsWOWThread() ? 1 : MAX_ENUM_STEP;
FORMATETC fetcarray[MAX_ENUM_STEP]; IEnumFORMATETC FAR* penm; ULONG ulNumFetched; HRESULT error; WORD wStatus = QUERY_CREATE_NONE; // no object can be created
BOOL fDone = FALSE;
*lpcfFormat = NULL;
// Grab the enumerator. If this fails, just return
// QUERY_CREATE_NONE
error = wGetEnumFormatEtc(lpSrcDataObj, DATADIR_GET, &penm); if (error != NOERROR) { return QUERY_CREATE_NONE; }
// Enumerate over the formats available in chunks for ulEnumSize. For
// each format we were able to grab, check to see if the clipformat
// indicates that we have a creation candidate (static or otherwise),
// and set bits in the bitmask as appropriate
while (!fDone && (SUCCEEDED(penm->Next(ulEnumSize, fetcarray, &ulNumFetched)))) { // We will normally get at least one, unless there are 0,
// ulEnumSize, 2*ulEnumSize, and so on...
if (ulNumFetched == 0) break;
for (ULONG c=0; c<ulNumFetched; c++) { // We care not about the target device
if (NULL != fetcarray[c].ptd) { PubMemFree(fetcarray[c].ptd); }
CLIPFORMAT cf = fetcarray[c].cfFormat;
// In these cases it is an internal
// format which is a candidate for
// OLE creation directly.
if (cf == g_cfEmbedSource || cf == g_cfEmbeddedObject || cf == g_cfFileName || cf == g_cfFileNameW) { wStatus |= QUERY_CREATE_OLE; *lpcfFormat = cf; fDone = TRUE; break; } // These formats indicate it is a
// candidate for static creation.
else if (cf == CF_METAFILEPICT || cf == CF_DIB || cf == CF_BITMAP || cf == CF_ENHMETAFILE) { wStatus = QUERY_CREATE_STATIC; *lpcfFormat = cf;
} } // end for
if (fDone) { // Starting at the _next_ formatetc, free up
// any remaining target devices among the
// fetcs we got in the enumeration step.
for (++c; c<ulNumFetched; c++) { if(fetcarray[c].ptd) { PubMemFree(fetcarray[c].ptd); } } }
} // end while
if (!(wStatus & QUERY_CREATE_OLE)) { // MFC HACK ALERT!! MFC3.0 used to re-implement
// OleQueryCreateFromData themselves because they did not
// want to make the QI RPC below. Since they do a great
// many of these calls, making the RPC can be expensive
// and destabilising for them (as this hack is being put
// in just weeks before final release of Windows NT 3.5).
//
// Note that this changes the behaviour of clipboard from
// 16bit. You will no longer know that you can paste objects
// that only support IPersistStorage but offer no data in
// in their IDataOjbect implementation.
CClipDataObject ClipDataObject; // just allocate one of these
// on the stack. We won't
// do any real work with
// this except look at the
// vtable.
IPersistStorage FAR* lpPS;
// MFC HACK (continued): If we are working with a clipboard
// data object, then we do not want to make the QI call
// below. We determine if the given data object is a
// clipboard data object by comparing vtable addresses.
// REVIEW: this will potentially break if we make all objects
// use the same IUnknown implementation
if( (*(DWORD *)lpSrcDataObj) != (*(DWORD *)((IDataObject *)&ClipDataObject)) ) {
if (lpSrcDataObj->QueryInterface(IID_IPersistStorage, (LPLPVOID)&lpPS) == NOERROR) { lpPS->Release(); wStatus |= QUERY_CREATE_OLE; // OLE object can be created
} } }
penm->Release(); return wStatus;}
//+-------------------------------------------------------------------------
//
// Function: OleQueryLinkFromData
//
// Synopsis: Calls wQueryLinkFormats to determine if a link could be
// created from this data object.
//
// Arguments: [lpSrcDataObj] -- the data object
//
// Returns: NOERROR, if a link can be created, S_FALSE otherwise
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
//--------------------------------------------------------------------------
STDAPI OleQueryLinkFromData (LPDATAOBJECT lpSrcDataObj){ OLETRACEIN((API_OleQueryLinkFromData, PARAMFMT("lpSrcDataObj= %p"), lpSrcDataObj));
VDATEHEAP(); VDATEIFACE( lpSrcDataObj ); CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IDataObject,(IUnknown **)&lpSrcDataObj);
HRESULT hr = NOERROR;
if(wQueryLinkFormats(lpSrcDataObj) == NULL) { hr = ResultFromScode(S_FALSE); }
OLETRACEOUT((API_OleQueryLinkFromData, hr));
return hr;}
//+-------------------------------------------------------------------------
//
// Function: wQueryLinkFormats
//
// Synopsis: Enumerates the formats of a data object to see if
// a link object could be created from one of them
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
//
// Returns: CLIPFORMAT of the data in the object that would enable
// link object creation.
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
// 14-Jun-94 davepl Added bulk enumeration for non-Wow runs
//
//--------------------------------------------------------------------------
INTERNAL_(CLIPFORMAT) wQueryLinkFormats(LPDATAOBJECT lpSrcDataObj){ VDATEHEAP();
// This adjusts the number of formats requested per enumeration
// step. If we are running in the WOW box, we should only ask
// for one at a time since it is unknown how well old code will
// support bulk enumerations.
ULONG ulEnumSize = IsWOWThread() ? 1 : MAX_ENUM_STEP;
FORMATETC fetcarray[MAX_ENUM_STEP]; IEnumFORMATETC FAR* penm; ULONG ulNumFetched; HRESULT error; BOOL fDone = FALSE; CLIPFORMAT cf = 0;
// Grab the enumerator. If this fails, just return
// QUERY_CREATE_NONE
error = wGetEnumFormatEtc(lpSrcDataObj, DATADIR_GET, &penm); if (error != NOERROR) { return (CLIPFORMAT) 0; }
// Enumerate over the formats available in chunks for ulEnumSize. For
// each format we were able to grab, check to see if the clipformat
// indicates that we have a creation candidate (static or otherwise),
// and set bits in the bitmask as appropriate
while (!fDone && (SUCCEEDED(penm->Next(ulEnumSize, fetcarray, &ulNumFetched)))) { // We will normally get at least one, unless there are 0,
// ulEnumSize, 2*ulEnumSize, and so on...
if (ulNumFetched == 0) break;
for (ULONG c=0; c<ulNumFetched; c++) { // We care not about the target device
if (NULL != fetcarray[c].ptd) { PubMemFree(fetcarray[c].ptd); }
CLIPFORMAT cfTemp = fetcarray[c].cfFormat;
// In these cases it is an internal
// format which is a candidate for
// OLE creation directly.
if (cfTemp == g_cfLinkSource || cfTemp == g_cfFileName || cfTemp == g_cfFileNameW) { cf = cfTemp; fDone = TRUE; break; }
} // end for
if (fDone) { // Starting at the _next_ formatetc, free up
// any remaining target devices among the
// fetcs we got in the enumeration step.
for (++c; c<ulNumFetched; c++) { if(fetcarray[c].ptd) { PubMemFree(fetcarray[c].ptd); } } } // end if
} // end while
penm->Release(); return cf;}
//+-------------------------------------------------------------------------
//
// Function: wClearRelativeMoniker
//
// Synopsis: Replaces an old relative moniker with the absolute moniker
// Internal function
//
// Effects:
//
// Arguments: [pInitObj] -- the original object
// [pNewObj] -- the object to which to set the new
// absolute moniker
//
// Requires:
//
// Returns: void
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wClearRelativeMoniker)
INTERNAL_(void) wClearRelativeMoniker (LPUNKNOWN pInitObj, LPUNKNOWN pNewObj){ VDATEHEAP();
LPOLELINK pOleLink = NULL; LPMONIKER pmkAbsolute = NULL; CLSID clsidLink = CLSID_NULL; LPOLEOBJECT pOleObj=NULL;
if (NOERROR==pInitObj->QueryInterface (IID_IOleLink, (LPLPVOID) &pOleLink)) { // Get absolute moniker ...
pOleLink->GetSourceMoniker (&pmkAbsolute); Assert(pmkAbsolute == NULL || IsValidInterface(pmkAbsolute)); if (NOERROR==pInitObj->QueryInterface (IID_IOleObject, (LPLPVOID) &pOleObj)) { // .. and its class
pOleObj->GetUserClassID (&clsidLink); pOleObj->Release(); pOleObj = NULL; } pOleLink->Release(); pOleLink = NULL; } if (pmkAbsolute && NOERROR==pNewObj->QueryInterface (IID_IOleLink, (LPLPVOID) &pOleLink)) { // Restore the absolute moniker. This will effectively
// overwrite the old relative moniker.
// This is important because when copying and pasting a link
// object between documents, the relative moniker is never
// correct. Sometimes, though, it might happen to bind
// to a different object, which is confusing to say the least.
pOleLink->SetSourceMoniker (pmkAbsolute, clsidLink); } if (pOleLink) pOleLink->Release(); if (pOleObj) pOleObj->Release(); if (pmkAbsolute) pmkAbsolute->Release();}
//+-------------------------------------------------------------------------
//
// Function: wCreateFromDataEx
//
// Synopsis: This function does the real work of creating from data.
// Basically, the data is GetData'ed from the data object,
// copied into a storage, and then loaded
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object
// [iid] -- requested interface
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site
// [lpStg] -- pointer to the storage for the object
// [lplpObj] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 28-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wCreateFromDataEx)
INTERNAL wCreateFromDataEx( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ VDATEHEAP();
#define OLE_TEMP_STG "\1OleTempStg"
HRESULT error = NOERROR; IPersistStorage FAR* lpPS = NULL; FORMATETC formatEtc; LPFORMATETC lpFormatEtc; BOOL fAlloced = FALSE; FORMATETC foretcTmp; STGMEDIUM medTmp;
if ((error = wValidateFormatEtcEx(renderopt, &cFormats, rgFormatEtc, &formatEtc, &lpFormatEtc, &fAlloced)) != NOERROR) { return error; }
*lplpObj = NULL;
INIT_FORETC(foretcTmp); medTmp.pUnkForRelease = NULL;
// try to get "EmbeddedObject" data
LPSTORAGE lpstgSrc = NULL;
foretcTmp.cfFormat = g_cfEmbeddedObject; foretcTmp.tymed = TYMED_ISTORAGE;
if (lpSrcDataObj->QueryGetData(&foretcTmp) != NOERROR) goto Next;
if ((error = StgCreateDocfile (NULL, STGM_SALL|STGM_CREATE|STGM_DELETEONRELEASE, NULL, &lpstgSrc)) != NOERROR) goto errRtn;
medTmp.tymed = TYMED_ISTORAGE; medTmp.pstg = lpstgSrc;
if ((error = lpSrcDataObj->GetDataHere(&foretcTmp, &medTmp)) == NOERROR) { // lpSrcDataObj passed to this api is a wrapper object
// (which offers g_cfEmbeddedObject) for the original
// embedded object. Now we got the original embedded object
// data into medTmp.pstg.
// copy the source data into lpStg.
if ((error = lpstgSrc->CopyTo (0, NULL, NULL, lpStg)) != NOERROR) goto errEmbeddedObject;
// By doing the following we will be getting a data object
// pointer to original embedded object, which we can use to
// initialize the cache of the object that we are going to
// create. We can not use the lpSrcDataObj passed to this api,
// 'cause the presentation data that it may give through the
// GetData call may be the one that it generated for the
// object. (ex: the container can create an object with
// olerender_none an then draw it's own representaion
// (icon, etc) for the object.
LPDATAOBJECT lpInitDataObj = NULL;
// We pass a NULL client site so we know wClearRelativeMoniker
// will be able to get the absolute moniker, not the relative.
if ((error = OleLoadWithoutBinding (lpstgSrc, FALSE, IID_IDataObject, /*lpClientSite*/NULL, (LPLPVOID) &lpInitDataObj)) != NOERROR) goto errEmbeddedObject;
if (renderopt != OLERENDER_ASIS ) UtDoStreamOperation(lpStg, /* pstgSrc */ NULL, /* pstgDst */ OPCODE_REMOVE, /* operation to performed */ STREAMTYPE_CACHE); /* stream to be operated upon */
error = wLoadAndInitObjectEx(lpInitDataObj, iid, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
if (NOERROR==error) wClearRelativeMoniker (lpInitDataObj, (LPUNKNOWN)*lplpObj);
if (lpInitDataObj) lpInitDataObj->Release();
// HACK ALERT!! If wLoadAndInitObject failed, it may have been
// because the little trick above with OleLoadWithoutBinding doesn't
// work with all objects. Some OLE1 objects (Clipart Gallery in
// particular) don't like offer presentions without being edited.
//
// So if there was an error, we'll just try again with the *real*
// data object passed into us. Needless to say, it would be much
// nicer to do this in the first place, but that breaks the old
// behavior.
if( error != NOERROR ) { error = wLoadAndInitObjectEx( lpSrcDataObj, iid, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj); }
}
errEmbeddedObject: if (lpstgSrc) lpstgSrc->Release();
goto errRtn;
Next:
// try to get "EmbedSource" data
foretcTmp.cfFormat = g_cfEmbedSource; foretcTmp.tymed = TYMED_ISTORAGE;
medTmp.tymed = TYMED_ISTORAGE; medTmp.pstg = lpStg;
if ((error = lpSrcDataObj->GetDataHere(&foretcTmp, &medTmp)) == NOERROR) { error = wLoadAndInitObjectEx(lpSrcDataObj, iid, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj); goto errRtn; }
// If we have come here, and if the object doesn't support
// IPersistStorage, then we will fail.
if ((error = wSaveObjectWithoutCommit(lpSrcDataObj, lpStg, FALSE)) != NOERROR) goto errRtn;;
if (renderopt != OLERENDER_ASIS ) UtDoStreamOperation(lpStg, /* pstgSrc */ NULL, /* pstgDst */ OPCODE_REMOVE, /* operation to performed */ STREAMTYPE_CACHE); /* stream to be operated upon */
error = wLoadAndInitObjectEx(lpSrcDataObj, iid, renderopt, cFormats, rgAdvf, lpFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
errRtn: if (fAlloced) PubMemFree(lpFormatEtc);
return error;}
//+-------------------------------------------------------------------------
//
// Function: wCreateLinkEx
//
// Synopsis: Creates a link by binding the moniker (if necessary),
// doing a GetData into a storage, and then loading the
// object from the storage.
//
// Effects:
//
// Arguments: [lpmkSrc] -- moniker to the link source
// [rclsid] -- clsid of the link source
// [lpSrcDataObj] -- pointer to the source data object
// (may be NULL)
// [iid] -- requested interface ID
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site
// [lpStg] -- storage for the link object
// [lplpObj] -- where to put the pointer to the new
// link object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 29-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wCreateLinkEx)
INTERNAL wCreateLinkEx( IMoniker FAR* lpmkSrc, REFCLSID rclsid, IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ VDATEHEAP();
IPersistStorage FAR * lpPS = NULL; IOleLink FAR* lpLink = NULL; IDataObject FAR* lpBoundDataObj = NULL; HRESULT error; CLSID clsidLast = rclsid; BOOL fNeedsUpdate = FALSE;
if (!lpSrcDataObj && ((renderopt != OLERENDER_NONE) || (IsEqualCLSID(rclsid,CLSID_NULL)) || wQueryUseCustomLink(rclsid))) {
// if renderopt is not OLERENDER_NONE, then we must have
// a data obj pointer which will be used to initialize cache.
// We also bind if we are not able to find from regdb whether
// the class has custom link implementation or not
if ((error = BindMoniker(lpmkSrc, NULL /* grfOpt */, IID_IDataObject, (LPLPVOID) &lpBoundDataObj)) != NOERROR) {
if (OLERENDER_NONE != renderopt) return ResultFromScode( OLE_E_CANT_BINDTOSOURCE);
// else we assume StdOleLink and continue with creation
} else { lpSrcDataObj = lpBoundDataObj;
if (IsEqualCLSID(clsidLast, CLSID_NULL)) UtGetClassID((LPUNKNOWN)lpSrcDataObj, &clsidLast); } }
// Deal with CustomLinkSource
// (see notes below)
if (lpSrcDataObj) { STGMEDIUM medTmp; FORMATETC foretcTmp;
INIT_FORETC(foretcTmp); foretcTmp.cfFormat = g_cfCustomLinkSource; foretcTmp.tymed = TYMED_ISTORAGE;
if (lpSrcDataObj->QueryGetData(&foretcTmp) == NOERROR) { medTmp.tymed = TYMED_ISTORAGE; medTmp.pstg = lpStg; medTmp.pUnkForRelease = NULL;
if (error = lpSrcDataObj->GetDataHere(&foretcTmp, &medTmp)) goto errRtn;
error = wLoadAndInitObjectEx(lpSrcDataObj, iid, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
// This is a really strange peice of logic,
// spaghetti code at it's finest. Basically,
// this says that if there is *NOT* a
// custom link source, then we want to do the
// logic of wCreateObject, etc. below. If we
// got to this line in the code, then we
// *did* have a custom link source, so
// don't do the stuff below (thus the goto).
// REVIEW32: If there are any bugs in here,
// then rewrite this in a more sensible fashion.
// I'm leaving as is for now due to time constraints.
goto errRtn; } }
// Otherwise
if ((error = wCreateObject (CLSID_StdOleLink, FALSE, iid, lpClientSite, lpStg, STG_INITNEW, lplpObj)) != NOERROR) goto errRtn;
if (lpSrcDataObj) { BOOL fCacheNodeCreated = FALSE;
if ((error = wInitializeCacheEx(lpSrcDataObj, clsidLast, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, *lplpObj, &fCacheNodeCreated)) != NOERROR) {
if (error != NOERROR && fCacheNodeCreated) { fNeedsUpdate = TRUE; error = NOERROR; }
} }
errRtn:
if (error == NOERROR && *lplpObj) error = ((LPUNKNOWN) *lplpObj)->QueryInterface(IID_IOleLink, (LPLPVOID) &lpLink);
if (error == NOERROR && lpLink && (dwFlags & OLECREATE_LEAVERUNNING)) { // This will connect to the object if it is already running.
lpLink->SetSourceMoniker (lpmkSrc, clsidLast); }
// We bound to the object to initialize the cache. We don't need
// it anymore
if (lpBoundDataObj) { if (error == NOERROR && (dwFlags & OLECREATE_LEAVERUNNING)) OleRun((LPUNKNOWN)*lplpObj);
// this will give a chance to the object to go away, if it can
wDoLockUnlock(lpBoundDataObj); lpBoundDataObj->Release(); }
// If the source object started running as a result of BindMoniker,
// then we would've got rid of it by now.
if (error == NOERROR && lpLink) { if ( !(dwFlags & OLECREATE_LEAVERUNNING) ) { // This will connect to the object if it is already running.
lpLink->SetSourceMoniker (lpmkSrc, clsidLast); }
if (fNeedsUpdate) { // relevant cache data is not available from the
// lpSrcDataObj. So do Update and get the right cache
// data.
error = wDoUpdate ((LPUNKNOWN) *lplpObj);
if (GetScode(error) == CACHE_E_NOCACHE_UPDATED) error = ReportResult(0, DV_E_FORMATETC, 0, 0); }
// Release on lpLink is necessary only if error == NOERROR
lpLink->Release();
}
if (error != NOERROR && *lplpObj) { ((IUnknown FAR*) *lplpObj)->Release(); *lplpObj = NULL; }
return error;}
//+-------------------------------------------------------------------------
//
// Function: wCreateFromFileEx
//
// Synopsis: Creates an ole object from a file by binding the given
// moniker and creating the object from the IDataObject pointer
//
// Effects:
//
// Arguments: [lpmkFile] -- moniker to the file
// [iid] -- requested interface ID
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site
// [lpStg] -- pointer to the storage for the new object
// [lplpObj] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 29-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wCreateFromFileEx)
INTERNAL wCreateFromFileEx( LPMONIKER lpmkFile, LPDATAOBJECT lpDataObject, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, LPOLECLIENTSITE lpClientSite, LPSTORAGE lpStg, LPLPVOID lplpObj){ VDATEHEAP();
HRESULT error; LPDATAOBJECT lpLocalDataObj;
if (!lpDataObject) { if ((error = BindMoniker(lpmkFile, NULL, IID_IDataObject, (LPLPVOID) &lpLocalDataObj)) != NOERROR) return error; } else { lpLocalDataObj = lpDataObject; }
Verify(lpLocalDataObj);
error = wCreateFromDataEx(lpLocalDataObj, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj);
if (error == NOERROR && (dwFlags & OLECREATE_LEAVERUNNING)) OleRun((LPUNKNOWN)*lplpObj);
// If we bound locally release it now, else it is up to the caller to do the right thing.
if (!lpDataObject) { wDoLockUnlock(lpLocalDataObj); lpLocalDataObj->Release(); }
return error;}
//+-------------------------------------------------------------------------
//
// Function: CoIsHashedOle1Class
//
// Synopsis: Determines whether or not a CLSID is an OLE1 class
//
// Effects:
//
// Arguments: [rclsid] -- the class ID in question
//
// Requires:
//
// Returns: TRUE if ole1.0, FALSE otherwise
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 29-Oct-93 alexgo 32bit port
//
// Notes: REVIEW32: This is a strange function..consider nuking
// it for 32bit, we may not need it (only used in 1 place)
//
//--------------------------------------------------------------------------
#pragma SEG(CoIsHashedOle1Class)
STDAPI_(BOOL) CoIsHashedOle1Class(REFCLSID rclsid){ VDATEHEAP();
CLSID clsid = rclsid; clsid.Data1 = 0L; WORD wHiWord = HIWORD(rclsid.Data1); return IsEqualGUID(clsid, IID_IUnknown) && wHiWord==4;}
//+-------------------------------------------------------------------------
//
// Function: EnsureCLSIDIsRegistered
//
// Synopsis: Checks to see if the clsid is in the registration database,
// if not, puts it there
//
// Effects:
//
// Arguments: [clsid] -- the clsid in question
// [pstg] -- storage to get more info about the
// clsid if we need to register it
//
// Requires:
//
// Returns: void
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 29-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(EnsureCLSIDIsRegistered)
void EnsureCLSIDIsRegistered (REFCLSID clsid, LPSTORAGE pstg){ VDATEHEAP();
LPOLESTR szProgId = NULL;
if (NOERROR == ProgIDFromCLSID (clsid, &szProgId)) { PubMemFree(szProgId); } else { // This is the case of getting a hashed CLSID from a file from
// another machine and the ProgId is not yet in the reg db,
// so we must get it from the storage.
// This code should rarely be executed.
CLIPFORMAT cf = 0; CLSID clsidT; OLECHAR szProgId[256];
if (ReadFmtUserTypeStg (pstg, &cf, NULL) != NOERROR) return; // Format is the ProgId
if (0==GetClipboardFormatName (cf, szProgId, 256)) return; // Will force registration of the CLSID if the ProgId (the OLE1
// classname) is registered
CLSIDFromProgID (szProgId, &clsidT); }}
//+-------------------------------------------------------------------------
//
// Function: wCreateObject
//
// Synopsis: Calls CoCreateInstance to create an object, a defhandler
// is created if necessary and CLSID info is written to
// the storage.
//
// Effects:
//
// Arguments: [clsid] -- the class id of the object to create
// [iid] -- the requested interface ID
// [lpClientSite] -- pointer to the client site
// [lpStg] -- storage for the object
// [wfStorage] -- flags for the STORAGE, one of
// STG_NONE, STD_INITNEW, STG_LOAD,
// defined at the beginning of this file
// [ppv] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Feb-94 alexgo fixed memory leak
// 29-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wCreateObject)
INTERNAL wCreateObject( CLSID clsid, BOOL fPermitCodeDownload, //parameter added in order to control whether code download occurs or not -RahulTh (11/20/97)
REFIID iid, IOleClientSite FAR* lpClientSite, IStorage FAR * lpStg, WORD wfStorage, void FAR* FAR* ppv){ VDATEHEAP();
HRESULT error; DWORD dwClsCtx; IOleObject* pOleObject = NULL; DWORD dwMiscStatus = 0; DWORD dwAddClsCtx;
dwAddClsCtx = fPermitCodeDownload?0:CLSCTX_NO_CODE_DOWNLOAD; *ppv = NULL;
CLSID clsidNew; if (wfStorage == STG_INITNEW && SUCCEEDED(OleGetAutoConvert (clsid, &clsidNew))) // Insert an object of the new class
clsid = clsidNew;
if (wfStorage == STG_LOAD && CoIsHashedOle1Class (clsid)) EnsureCLSIDIsRegistered (clsid, lpStg);
if (IsWOWThread()) { // CLSCTX needs to be turned on for possible 16 bit inproc server
// such as OLE controls
dwClsCtx = CLSCTX_INPROC | CLSCTX_INPROC_SERVER16 | dwAddClsCtx; } else { dwClsCtx = CLSCTX_INPROC | dwAddClsCtx; }
if ((error = CoCreateInstance (clsid, NULL /*pUnkOuter*/, dwClsCtx, iid, ppv)) != NOERROR) {
// if not OleLoad or error other than class not registered,
// exit
if (wfStorage != STG_LOAD || GetScode(error) != REGDB_E_CLASSNOTREG) goto errRtn;
// OleLoad and class not registered: use default handler
// directly
if ((error = OleCreateDefaultHandler(clsid, NULL, iid, ppv)) != NOERROR) goto errRtn; }
AssertSz(*ppv, "HRESULT is OK, but pointer is NULL");
// Check if we have client site
if(lpClientSite) { // QI for IOleObject on the server
error = ((IUnknown *)*ppv)->QueryInterface(IID_IOleObject, (void **)&pOleObject); if(error == NOERROR) { // Get the MiscStatus bits
error = pOleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
// Set the client site first if OLEMISC_SETCLIENTSITEFIRST bit is set
if(error == NOERROR && (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)) { error = pOleObject->SetClientSite(lpClientSite); if(error != NOERROR) { pOleObject->Release(); goto errRtn; } } else if(error != NOERROR) { error = NOERROR; dwMiscStatus = 0; } } else goto errRtn; }
if (wfStorage != STG_NONE) { IPersistStorage FAR* lpPS;
if ((error = ((LPUNKNOWN) *ppv)->QueryInterface( IID_IPersistStorage, (LPLPVOID)&lpPS)) != NOERROR) { goto errRtn; }
if (wfStorage == STG_INITNEW) { error = WriteClassStg(lpStg, clsid);
if (SUCCEEDED(error)) { error = lpPS->InitNew (lpStg); } } else { error = lpPS->Load (lpStg); }
lpPS->Release();
if (FAILED(error)) { goto errRtn; }
}
if(lpClientSite) { // Assert that pOleObject is set
Win4Assert(IsValidInterface(pOleObject));
// Set the client site if it has not been set already
if(!(dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)) error = pOleObject->SetClientSite (lpClientSite);
// Release the object
pOleObject->Release();
if (FAILED(error)) goto errRtn; }
AssertSz(error == NOERROR, "Invalid code path");
return NOERROR;
errRtn:
if (*ppv) { ((LPUNKNOWN) *ppv)->Release(); *ppv = NULL; }
return error;}
//+-------------------------------------------------------------------------
//
// Function: wLoadAndInitObjectEx
//
// Synopsis: Loads and binds an object from the given storage.
// A cacle is initialized from the data object
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to the data object to initialize
// the cache with
// [iid] -- requested interface ID
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- pointer to the client site.
// [lpStg] -- storage for the new object
// [lplpObj] -- where to put the pointer to the new object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 29-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wLoadAndInitObjectEx)
INTERNAL wLoadAndInitObjectEx( IDataObject FAR* lpSrcDataObj, REFIID iid, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg, void FAR* FAR* lplpObj){ VDATEHEAP();
HRESULT error; CLSID clsid;
if ((error = OleLoadWithoutBinding(lpStg, FALSE, iid, lpClientSite, lplpObj)) != NOERROR) return error;
UtGetClassID((LPUNKNOWN) *lplpObj, &clsid);
error = wInitializeCacheEx(lpSrcDataObj, clsid, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, *lplpObj);
if (error != NOERROR) { // relevant cache data is not available from the lpSrcDataObj.
// So do Update and get the right cache data.
error = wDoUpdate ((LPUNKNOWN) *lplpObj); }
if (GetScode(error) == CACHE_E_NOCACHE_UPDATED) { error = ReportResult(0, DV_E_FORMATETC, 0, 0); goto errRtn; }
if (error == NOERROR) wBindIfRunning((LPUNKNOWN) *lplpObj);
errRtn: if (error != NOERROR && *lplpObj) { ((IUnknown FAR*) *lplpObj)->Release(); *lplpObj = NULL; }
return error;}
//+-------------------------------------------------------------------------
//
// Function: wInitializeCacheEx
//
// Synopsis: Query's for IOleCache on the given object and calls IOC->Cache
// to initialize a cache node.
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- pointer to data to initialize the cache
// with
// [rclsid] -- CLSID to use if an icon is needed
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpNewObj] -- the object on which the cache should
// be initialized
// [pfCacheNodeCreated] -- where to return a flag indicating
// whether or not a cache node was
// created
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 31-Oct-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
// This routine modifies lpFormatEtc's fields.
#pragma SEG(wInitializeCacheEx)
INTERNAL wInitializeCacheEx( IDataObject FAR* lpSrcDataObj, REFCLSID rclsid, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, void FAR* lpNewObj, BOOL FAR* pfCacheNodeCreated){ VDATEHEAP();
IDataObject FAR* lpNewDataObj = NULL; IOleCache FAR* lpOleCache = NULL; HRESULT error; LPFORMATETC lpFormatEtc; DWORD advf; STGMEDIUM stgmed; DWORD dwConnId = 0; BOOL fIconCase;
if (pfCacheNodeCreated) *pfCacheNodeCreated = FALSE;
if (renderopt == OLERENDER_NONE || renderopt == OLERENDER_ASIS) return NOERROR;
if (lpAdviseSink) { if ((error = ((IUnknown FAR*)lpNewObj)->QueryInterface(IID_IDataObject, (LPLPVOID) &lpNewDataObj)) != NOERROR) return error; } else { if (((IUnknown FAR*)lpNewObj)->QueryInterface(IID_IOleCache, (LPLPVOID) &lpOleCache) != NOERROR) return wQueryFormatSupport(lpNewObj, renderopt, rgFormatEtc); }
for (ULONG i=0; i<cFormats; i++) { advf = (rgAdvf ? rgAdvf[i] : ADVF_PRIMEFIRST); lpFormatEtc = &rgFormatEtc[i]; fIconCase = FALSE;
if (lpFormatEtc->dwAspect == DVASPECT_ICON) { if (lpFormatEtc->cfFormat == NULL) { lpFormatEtc->cfFormat = CF_METAFILEPICT; lpFormatEtc->tymed = TYMED_MFPICT; } fIconCase = (lpFormatEtc->cfFormat == CF_METAFILEPICT); }
if (lpAdviseSink) { // if icon case, must use these advise flags or the icon
// data won't get passed back correctly
if (fIconCase) advf |= (ADVF_PRIMEFIRST | ADVF_ONLYONCE);
// should we send the data immediately?
if ((advf & ADVF_PRIMEFIRST) && lpSrcDataObj) { stgmed.tymed = TYMED_NULL; stgmed.pUnkForRelease = NULL;
if (advf & ADVF_NODATA) { // don't sent data, send only the notification
lpAdviseSink->OnDataChange(lpFormatEtc, &stgmed); } else { if (fIconCase) error = UtGetIconData(lpSrcDataObj, rclsid, lpFormatEtc, &stgmed); else error = lpSrcDataObj->GetData(lpFormatEtc, &stgmed);
if (error != NOERROR) goto errRtn;
// send data to sink and release stdmedium
lpAdviseSink->OnDataChange(lpFormatEtc, &stgmed); ReleaseStgMedium(&stgmed); }
if (advf & ADVF_ONLYONCE) continue;
// remove the ADVF_PRIMEFIRST from flags.
advf &= (~ADVF_PRIMEFIRST); }
// setup advisory connection
if ((error = lpNewDataObj->DAdvise(lpFormatEtc, advf, lpAdviseSink, &dwConnId)) != NOERROR) goto errRtn;
// optionally stuff the id in the array
if (rgdwConnection) rgdwConnection[i] = dwConnId; } else { if (fIconCase) advf = ADVF_NODATA;
// Create a cache of already specified view format.
// In case of olerender_draw, lpFormatEtc->cfFormat would have already
// been set to NULL.
error = lpOleCache->Cache(lpFormatEtc, advf, &dwConnId);
if (FAILED(GetScode(error))) { if (! ((dwConnId != 0) && fIconCase) ) goto errRtn;
// In icon case we can ignore the cache's QueryGetData failure
}
error = NOERROR; if (pfCacheNodeCreated) *pfCacheNodeCreated = TRUE;
if (fIconCase) { if ((error = UtGetIconData(lpSrcDataObj, rclsid, lpFormatEtc, &stgmed)) == NOERROR) { if ((error = lpOleCache->SetData(lpFormatEtc, &stgmed, TRUE)) != NOERROR) ReleaseStgMedium(&stgmed); } } } }
if (error == NOERROR && !lpAdviseSink && lpSrcDataObj) error = lpOleCache->InitCache(lpSrcDataObj);
errRtn: if (lpNewDataObj) lpNewDataObj->Release(); if (lpOleCache) lpOleCache->Release(); return error;}
//+-------------------------------------------------------------------------
//
// Function: wReturnCreationError
//
// Synopsis: modifies the return code, used internally in creation api's
//
// Effects:
//
// Arguments: [hresult] -- the original error code
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
INTERNAL wReturnCreationError(HRESULT hresult){ VDATEHEAP();
if (hresult != NOERROR) { SCODE sc = GetScode(hresult);
if (sc == CACHE_S_FORMATETC_NOTSUPPORTED || sc == CACHE_E_NOCACHE_UPDATED) return ReportResult(0, DV_E_FORMATETC, 0, 0); }
return hresult;}
//+-------------------------------------------------------------------------
//
// Function: wGetMonikerAndClassFromFile
//
// Synopsis: gets a moniker and class id from the given file
//
// Effects:
//
// Arguments: [lpszFileName] -- the file
// [fLink] -- passed onto CreatePackagerMoniker
// [lplpmkFile] -- where to put the pointer to the file
// moniker
// [lpfPackagerMoniker] -- where to put a flag indicating
// whether or not a packager moniker
// was created.
// [lpClsid] -- where to put the class ID
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
// 10-May-94 KevinRo Reimplemented OLE 1.0 interop
// 03-Mar-95 ScottSk Added STG_E_FILENOTFOUND
//
//
//--------------------------------------------------------------------------
INTERNAL wGetMonikerAndClassFromFile( LPCOLESTR lpszFileName, BOOL fLink, LPMONIKER FAR* lplpmkFile, BOOL FAR* lpfPackagerMoniker, CLSID FAR* lpClsid, LPDATAOBJECT * lplpDataObject){HRESULT hrFileMoniker;HRESULT hresult;BOOL fHaveBoundClsid = FALSE;LPMONIKER lpFileMoniker;
VDATEHEAP();
*lplpDataObject = NULL; *lplpmkFile = NULL;
// To ensure the same error codes are returned as before we don't return immediately if CreateFileMoniker fails.
hrFileMoniker = CreateFileMoniker((LPOLESTR)lpszFileName, &lpFileMoniker); Assert( (NOERROR == hrFileMoniker) || (NULL == lpFileMoniker) );
if (NOERROR == hrFileMoniker) { LPBINDCTX pbc;
if (SUCCEEDED(CreateBindCtx( 0, &pbc ))) { if (S_OK == lpFileMoniker->IsRunning(pbc,NULL,NULL)) {
// If the Object is Running Bind and get the CLSID
if (NOERROR == lpFileMoniker->BindToObject(pbc, NULL, IID_IDataObject, (LPLPVOID) lplpDataObject)) { fHaveBoundClsid = UtGetClassID((LPUNKNOWN)*lplpDataObject,lpClsid); Assert( (TRUE == fHaveBoundClsid) || (IsEqualCLSID(*lpClsid, CLSID_NULL)) ); }
}
pbc->Release(); } }
if (!fHaveBoundClsid) { // Call GetClassFileEx directly (rather than going through GetClassFile).
hresult = GetClassFileEx ((LPOLESTR)lpszFileName, lpClsid, CLSID_NULL); Assert( (NOERROR == hresult) || (IsEqualCLSID(*lpClsid, CLSID_NULL)) );
if (NOERROR == hresult) fHaveBoundClsid = TRUE; }
// If have a CLSID at this point see if its insertable.
if (fHaveBoundClsid) {
Assert(!IsEqualCLSID(*lpClsid, CLSID_NULL));
// Check whether we need package this file, even though it is an
// OLE class file.
if (!wNeedToPackage(*lpClsid)) { if (lpfPackagerMoniker != NULL) { *lpfPackagerMoniker = FALSE; }
*lplpmkFile = lpFileMoniker; return hrFileMoniker; } }
//
// We didnt' find an OLE insertable object or couldn't get the CLSID. Therefore, create a
// packager moniker for it.
//
// If Bound to the DataObject, release it.
if (*lplpDataObject) { (*lplpDataObject)->Release(); *lplpDataObject = NULL; }
// If GetClassFileEx() failed because the file was not found or could not be openned.
// don't try to bind with Packager.
if (hresult == MK_E_CANTOPENFILE) { if (NOERROR == hrFileMoniker) { lpFileMoniker->Release(); }
return STG_E_FILENOTFOUND; }
// If we failed to create the file moniker its finally safe to bail without changing the error code.
if (NOERROR != hrFileMoniker) { return hrFileMoniker; }
if (lpfPackagerMoniker != NULL) { *lpfPackagerMoniker = TRUE; }
hresult = CreatePackagerMonikerEx(lpszFileName,lpFileMoniker,fLink,lplpmkFile); lpFileMoniker->Release();
return hresult;}
//+-------------------------------------------------------------------------
//
// Function: wCreatePackageEx
//
// Synopsis: Internal function, does a IDO->GetData for a filename, and
// then creates either a link or normal object from that file
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- the source for the filename
// [iid] -- the requested interface ID
// [dwFlags] -- object creation flags
// [renderopt] -- render options, such as OLERENDER_DRAW
// [cFormats] -- the number of elements in rgFormatEtc
// [rgAdvf] -- array of advise flags, if OLRENDER_FORMAT
// is specified in renderopt
// [rgFormatEtc] -- array of rendering formats, if
// OLERENDER_FORMAT is specified in renderopt
// [lpAdviseSink] -- the advise sink for the object
// [rgdwConnection]-- where to put the connection IDs for the
// advisory connections
// [lpClientSite] -- client site for the object
// [lpStg] -- storage for the object
// [fLink] -- if TRUE, create a link
// [lplpObj] -- where to put the pointer to the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm: Gets a filename from the data object (converting to Unicode
// if necessary) and then creates either an embedding or link
// from that filename.
//
// History: dd-mmm-yy Author Comment
// 24-Apr-94 alexgo rewrote to handle FileNameW
// 01-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wCreatePackageEx)
INTERNAL wCreatePackageEx( LPDATAOBJECT lpSrcDataObj, REFIID iid, DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, LPOLECLIENTSITE lpClientSite, LPSTORAGE lpStg, BOOL fLink, LPLPVOID lplpObj){ VDATEHEAP();
FORMATETC formatetc; STGMEDIUM medium; HRESULT hresult; CLSID clsid = CLSID_NULL; LPOLESTR pszFileName = NULL; OLECHAR szFileName[MAX_PATH +1]; // in case we
// have to
// translate
LEDebugOut((DEB_ITRACE, "%p _IN wCreatePackageEx ( %p , %p , %lx , %lx ," " %lx , %p , %p , %p , %p , %p , %p , %lu , %p )\n", NULL, lpSrcDataObj, &iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, fLink, lplpObj));
INIT_FORETC(formatetc); formatetc.cfFormat = g_cfFileNameW; formatetc.tymed = TYMED_HGLOBAL;
// zero the medium
_xmemset(&medium, 0, sizeof(STGMEDIUM));
// we don't need to do a QueryGetData, because we will have only
// gotten here on the advice of a formatetc enumerator from the
// data object (and thus, one of the GetData calls should succeed).
hresult = lpSrcDataObj->GetData(&formatetc, &medium);
// if we couldn't get the Unicode filename for some reason, try
// for the ANSI version
if( hresult != NOERROR ) { char * pszAnsiFileName; DWORD cwchSize;
formatetc.cfFormat = g_cfFileName; // re-NULL the medium, just in case it was messed up by
// the first call above
_xmemset( &medium, 0, sizeof(STGMEDIUM));
hresult = lpSrcDataObj->GetData(&formatetc, &medium);
if( hresult == NOERROR ) { pszAnsiFileName = (char *)GlobalLock(medium.hGlobal);
cwchSize = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, pszAnsiFileName, -1, szFileName, MAX_PATH);
if( cwchSize == 0 ) { GlobalUnlock(medium.hGlobal); ReleaseStgMedium(&medium); hresult = ResultFromScode(E_FAIL); } else { pszFileName = szFileName; } // we will Unlock at the end of the routine
} } else { pszFileName = (LPOLESTR)GlobalLock(medium.hGlobal); }
if( hresult == NOERROR ) { if (fLink) { hresult = OleCreateLinkToFileEx(pszFileName, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj); } else { hresult = OleCreateFromFileEx(clsid, pszFileName, iid, dwFlags, renderopt, cFormats, rgAdvf, rgFormatEtc, lpAdviseSink, rgdwConnection, lpClientSite, lpStg, lplpObj); }
GlobalUnlock(medium.hGlobal); ReleaseStgMedium(&medium); }
LEDebugOut((DEB_ITRACE, "%p OUT wCreatePackageEx ( %lx ) [ %p ]\n", NULL, hresult, *lplpObj));
return hresult;}
//+-------------------------------------------------------------------------
//
// Function: wValidateCreateParams
//
// Synopsis: Validate the incoming create parameters
//
// Effects:
//
// Arguments: [cFormats] -- the number of elements in rgAdvf
// [rgAdvf] -- array of advise flags
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 26-Apr-96 davidwor added function
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wValidateCreateParams)
INTERNAL wValidateCreateParams( DWORD dwFlags, DWORD renderopt, ULONG cFormats, DWORD FAR* rgAdvf, LPFORMATETC rgFormatEtc, IAdviseSink FAR* lpAdviseSink, DWORD FAR* rgdwConnection, IOleClientSite FAR* lpClientSite, IStorage FAR* lpStg){ HRESULT hresult = NOERROR;
VDATEHEAP();
if (dwFlags != (dwFlags & OLECREATE_LEAVERUNNING)) { VdateAssert(dwFlags, "Invalid creation flags"); hresult = ResultFromScode(E_INVALIDARG); goto errRtn; }
if (renderopt == OLERENDER_DRAW && cFormats > 1) { VdateAssert(cFormats, "Multiple formats not allowed with OLERENDER_DRAW"); hresult = ResultFromScode(E_INVALIDARG); goto errRtn; }
if (renderopt != OLERENDER_FORMAT) VDATEPTRNULL_LABEL( lpAdviseSink, errRtn, hresult );
if (cFormats == 0) { VDATEPTRNULL_LABEL( rgAdvf, errRtn, hresult ); VDATEPTRNULL_LABEL( rgFormatEtc, errRtn, hresult ); VDATEPTRNULL_LABEL( rgdwConnection, errRtn, hresult ); } else { VDATESIZEREADPTRIN_LABEL( rgAdvf, cFormats * sizeof(DWORD), errRtn, hresult ); VDATESIZEREADPTRIN_LABEL( rgFormatEtc, cFormats * sizeof(FORMATETC), errRtn, hresult ); if ( rgdwConnection ) { VDATESIZEPTROUT_LABEL( rgdwConnection, cFormats * sizeof(DWORD), errRtn, hresult ); _xmemset(rgdwConnection, 0, cFormats * sizeof(DWORD)); } }
if ((hresult = wValidateAdvfEx(cFormats, rgAdvf)) != NOERROR) goto errRtn;
VDATEIFACE_LABEL( lpStg, errRtn, hresult ); if ( lpAdviseSink ) VDATEIFACE_LABEL( lpAdviseSink, errRtn, hresult ); if ( lpClientSite ) VDATEIFACE_LABEL( lpClientSite, errRtn, hresult );
errRtn: return hresult;}
//+-------------------------------------------------------------------------
//
// Function: wValidateAdvfEx
//
// Synopsis: Validate the incoming array of ADVF values
//
// Effects:
//
// Arguments: [cFormats] -- the number of elements in rgAdvf
// [rgAdvf] -- array of advise flags
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 19-Mar-96 davidwor added function
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wValidateAdvfEx)
INTERNAL wValidateAdvfEx( ULONG cFormats, DWORD FAR* rgAdvf){ VDATEHEAP();
if ((cFormats != 0) != (rgAdvf != NULL)) return ResultFromScode(E_INVALIDARG);
for (ULONG i=0; i<cFormats; i++) { if (rgAdvf[i] != (rgAdvf[i] & MASK_VALID_ADVF)) { VdateAssert(rgAdvf, "Invalid ADVF value specified"); return ResultFromScode(E_INVALIDARG); } }
return NOERROR;}
//+-------------------------------------------------------------------------
//
// Function: wValidateFormatEtc
//
// Synopsis: Validate the incoming formatetc and initialize the
// out formatetc with the correct info
//
// Effects:
//
// Arguments: [renderopt] -- rendering option
// [lpFormatEtc] -- the incoming formatetc
// [lpMyFormatEtc] -- the out formatetc
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
//
// Notes: The original comments,
//
// Validate the lpFormatEtc that's been passed to the creation APIs. And then
// initialize our formateEtc structure with the appropriate info.
//
// We allow NULL lpFormatEtc if the render option is olerender_draw
// We ignore lpFormatEtc if the render option is olerender_none
//
//--------------------------------------------------------------------------
#pragma SEG(wValidateFormatEtc)
INTERNAL wValidateFormatEtc( DWORD renderopt, LPFORMATETC lpFormatEtc, LPFORMATETC lpMyFormatEtc){ VDATEHEAP();
SCODE sc = S_OK;
if (renderopt == OLERENDER_NONE || renderopt == OLERENDER_ASIS) return NOERROR;
if (renderopt == OLERENDER_FORMAT) { if (!lpFormatEtc || !lpFormatEtc->cfFormat) { sc = E_INVALIDARG; goto errRtn; }
if (lpFormatEtc->tymed != UtFormatToTymed(lpFormatEtc->cfFormat)) { sc = DV_E_TYMED; goto errRtn; }
} else if (renderopt == OLERENDER_DRAW) { if (lpFormatEtc) { if (lpFormatEtc->cfFormat != NULL) { VdateAssert(lpFormatEtc->cfFormat,"NON-NULL clipformat specified with OLERENDER_DRAW"); sc = DV_E_CLIPFORMAT; goto errRtn; }
if (lpFormatEtc->tymed != TYMED_NULL) { VdateAssert(lpFormatEtc->tymed,"TYMED_NULL is not specified with OLERENDER_DRAW"); sc = DV_E_TYMED; goto errRtn; } } } else { VdateAssert(renderopt, "Unexpected value for OLERENDER_ option"); sc = E_INVALIDARG; goto errRtn; }
if (lpFormatEtc) { if (!HasValidLINDEX(lpFormatEtc)) { sc = DV_E_LINDEX; goto errRtn; }
VERIFY_ASPECT_SINGLE(lpFormatEtc->dwAspect)
*lpMyFormatEtc = *lpFormatEtc;
} else { INIT_FORETC(*lpMyFormatEtc); lpMyFormatEtc->tymed = TYMED_NULL; lpMyFormatEtc->cfFormat = NULL; }
errRtn: return ReportResult(0, sc, 0, 0);}
//+-------------------------------------------------------------------------
//
// Function: wValidateFormatEtcEx
//
// Synopsis: Validate the incoming formatetc and initialize the
// out formatetc with the correct info
//
// Effects:
//
// Arguments: [renderopt] -- rendering option
// [lpcFormats] -- the number of elements in rgFormatEtc
// [rgFormatEtc] -- array of rendering formats
// [lpFormatEtc] -- place to store valid formatetc if only one
// [lplpFormatEtc] -- the out array of formatetcs
// [lpfAlloced] -- place to store whether array was allocated
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
//
// Notes: The original comments,
//
// Validate the lpFormatEtc that's been passed to the creation APIs. And then
// initialize our formateEtc structure with the appropriate info.
//
// We allow NULL lpFormatEtc if the render option is olerender_draw
// We ignore lpFormatEtc if the render option is olerender_none
//
//--------------------------------------------------------------------------
#pragma SEG(wValidateFormatEtcEx)
INTERNAL wValidateFormatEtcEx( DWORD renderopt, ULONG FAR* lpcFormats, LPFORMATETC rgFormatEtc, LPFORMATETC lpFormatEtc, LPFORMATETC FAR* lplpFormatEtc, LPBOOL lpfAlloced){ LPFORMATETC lpfmtetc;
VDATEHEAP();
SCODE sc = S_OK;
*lplpFormatEtc = lpFormatEtc; *lpfAlloced = FALSE;
if (renderopt == OLERENDER_NONE || renderopt == OLERENDER_ASIS) return NOERROR;
if (renderopt != OLERENDER_FORMAT && renderopt != OLERENDER_DRAW) { VdateAssert(renderopt, "Unexpected value for OLERENDER_ option"); return ResultFromScode(E_INVALIDARG); }
if ((*lpcFormats != 0) != (rgFormatEtc != NULL)) return ResultFromScode(E_INVALIDARG);
if (*lpcFormats <= 1) { if (*lpcFormats == 0) *lpcFormats = 1; return wValidateFormatEtc(renderopt, rgFormatEtc, lpFormatEtc); }
*lplpFormatEtc = (LPFORMATETC)PubMemAlloc(*lpcFormats * sizeof(FORMATETC)); if (!*lplpFormatEtc) return E_OUTOFMEMORY;
*lpfAlloced = TRUE;
for (ULONG i=0; i<*lpcFormats; i++) { lpfmtetc = &rgFormatEtc[i];
if (renderopt == OLERENDER_FORMAT) { if (!lpfmtetc->cfFormat) { sc = E_INVALIDARG; goto errRtn; }
if (lpfmtetc->tymed != UtFormatToTymed(lpfmtetc->cfFormat)) { sc = DV_E_TYMED; goto errRtn; } } else if (renderopt == OLERENDER_DRAW) { if (lpfmtetc->cfFormat != NULL) { VdateAssert(lpfmtetc->cfFormat,"NON-NULL clipformat specified with OLERENDER_DRAW"); sc = DV_E_CLIPFORMAT; goto errRtn; }
if (lpfmtetc->tymed != TYMED_NULL) { VdateAssert(lpfmtetc->tymed,"TYMED_NULL is not specified with OLERENDER_DRAW"); sc = DV_E_TYMED; goto errRtn; } }
if (!HasValidLINDEX(lpfmtetc)) { sc = DV_E_LINDEX; goto errRtn; }
VERIFY_ASPECT_SINGLE(lpfmtetc->dwAspect)
(*lplpFormatEtc)[i] = *lpfmtetc; }
errRtn: if (sc != S_OK) { PubMemFree(*lplpFormatEtc); *lpfAlloced = FALSE; } return ReportResult(0, sc, 0, 0);}
//+-------------------------------------------------------------------------
//
// Function: wQueryFormatSupport
//
// Synopsis: check to see whether we will be able to Get and SetData of
// the given format
//
// Effects:
//
// Arguments: [lpObj] -- pointer to the object
// [renderopt] -- rendering options
// [lpFormatEtc] -- the formatetc in question
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm: Internal function, calls UtIsFormatSupported (which calls
// EnumFormatEtc and checks all of the formats) if renderopt
// is OLERENDER_FORMAT
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wQueryFormatSupport)
INTERNAL wQueryFormatSupport (LPVOID lpObj, DWORD renderopt, LPFORMATETC lpFormatEtc){ VDATEHEAP();
IDataObject FAR* lpDataObj; HRESULT error = NOERROR;
if (renderopt == OLERENDER_FORMAT) { if ((error = ((IUnknown FAR*) lpObj)->QueryInterface( IID_IDataObject, (LPLPVOID)&lpDataObj)) == NOERROR) { if (!UtIsFormatSupported(lpDataObj, DATADIR_GET | DATADIR_SET, lpFormatEtc->cfFormat)) error = ResultFromScode(DV_E_CLIPFORMAT);
lpDataObj->Release(); } }
return error;}
//+-------------------------------------------------------------------------
//
// Function: wGetMonikerAndClassFromObject
//
// Synopsis: Gets the moniker and class ID from the given object
//
// Effects:
//
// Arguments: [lpSrcDataObj] -- the data object
// [lplpmkSrc] -- where to put a pointer to the moniker
// [lpclsidLast] -- where to put the clsid
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 15-Mar-95 alexgo added a hack for CorelDraw5
// 01-Nov-93 alexgo 32bit port
//
// Notes: see also wGetMonikerAndClassFromFile
//
//--------------------------------------------------------------------------
#pragma SEG(wGetMonikerAndClassFromObject)
INTERNAL wGetMonikerAndClassFromObject( LPDATAOBJECT lpSrcDataObj, LPMONIKER FAR* lplpmkSrc, CLSID FAR* lpclsidLast){ VDATEHEAP();
HRESULT error; FORMATETC foretcTmp; STGMEDIUM medium; LPMONIKER lpmkSrc = NULL; LARGE_INTEGER large_integer;
INIT_FORETC(foretcTmp); foretcTmp.cfFormat = g_cfLinkSource; foretcTmp.tymed = TYMED_ISTREAM;
// 16bit OLE had a bug where the medium was uninitialized at this
// point. Corel5, when doing a paste-link to itself, actually
// checked the tymed and compared it with TYMED_NULL. So here
// we set the value to something recognizeable.
//
// NB! In the thunk layer, if we are *NOT* in Corel Draw, this
// value will be reset to TYMED_NULL.
if( IsWOWThread() ) { medium.tymed = 0x66666666; } else { medium.tymed = TYMED_NULL; } medium.pstm = NULL; medium.pUnkForRelease = NULL;
if ((error = lpSrcDataObj->GetData(&foretcTmp, &medium)) != NOERROR) return ReportResult(0, OLE_E_CANT_GETMONIKER, 0, 0);
LISet32( large_integer, 0 ); if ((error = (medium.pstm)->Seek (large_integer, STREAM_SEEK_SET, NULL)) != NOERROR) goto FreeStgMed;
// get moniker from the stream
if ((error = OleLoadFromStream (medium.pstm, IID_IMoniker, (LPLPVOID) lplpmkSrc)) != NOERROR) goto FreeStgMed;
// read class stm; if error, use CLSID_NULL (for compatibility with
// prior times when the clsid was missing).
ReadClassStm(medium.pstm, lpclsidLast);
FreeStgMed: ReleaseStgMedium (&medium); if (error != NOERROR) return ReportResult(0, OLE_E_CANT_GETMONIKER, 0, 0);
return NOERROR;}
//+-------------------------------------------------------------------------
//
// Function: wDoLockUnlock
//
// Synopsis: tickles an object by locking and unlocking, used to resolve
// ambiguities with stub manager locks
//
// Effects: the object may go away as a result of this call, if the
// object is invisible and the lock count goes to zero as
// a result of locking/unlocking.
//
// Arguments: [lpUnk] -- pointer to the object to lock/unlock
//
// Requires:
//
// Returns: void
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 01-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wDoLockUnlock)
void wDoLockUnlock(IUnknown FAR* lpUnk){ VDATEHEAP();
IRunnableObject FAR* pRO;
if (lpUnk->QueryInterface(IID_IRunnableObject, (LPLPVOID)&pRO) == NOERROR) { // increase lock count
if (pRO->LockRunning(TRUE, FALSE) == NOERROR) // decrease lock count
pRO->LockRunning(FALSE, TRUE); pRO->Release(); }}
//+-------------------------------------------------------------------------
//
// Function: wSaveObjectWithoutCommit
//
// Synopsis: Saves an object without committing (to preserve the
// container's undo state)
//
// Effects:
//
// Arguments: [lpUnk] -- pointer to the object
// [pstgSave] -- storage in which to save
// [fSameAsLoad] -- indicates SaveAs operation
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
INTERNAL wSaveObjectWithoutCommit (LPUNKNOWN lpUnk, LPSTORAGE pstgSave, BOOL fSameAsLoad){ VDATEHEAP();
LPPERSISTSTORAGE pPS; HRESULT error; CLSID clsid;
if (error = lpUnk->QueryInterface(IID_IPersistStorage, (LPLPVOID)&pPS)) return error;
if (error = pPS->GetClassID(&clsid)) goto errRtn;
if (error = WriteClassStg(pstgSave, clsid)) goto errRtn;
if (error = pPS->Save(pstgSave, fSameAsLoad)) goto errRtn;
pPS->SaveCompleted(NULL);
errRtn: pPS->Release(); return error;}
//+-------------------------------------------------------------------------
//
// Function: wStuffIconOfFileEx
//
// Synopsis: Retrieves the icon if file [lpszFile] and stuffs it into
// [lpUnk]'s cache
//
// Effects:
//
// Arguments: [lpszFile] -- the file where the icon is stored
// [fAddLabel] -- if TRUE, adds a label to the icon
// presentation
// [renderopt] -- must be OLERENDER_DRAW or
// OLERENDER_FORMAT for anything to happen
// [cFormats] -- the number of elements in rgFormatEtc
// [rgFormatEtc] -- array of rendering formats, aspect must be
// DVASPECT_ICON and the clipboard format
// must be NULL or CF_METAFILE for anything
// to happen
// [lpUnk] -- pointer to the object in which the icon
// should be stuffed
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
//
// Notes:
// REVIEW32: maybe we should support enhanced metafiles for NT
//
//--------------------------------------------------------------------------
#pragma SEG(wStuffIconOfFileEx)
INTERNAL wStuffIconOfFileEx( LPCOLESTR lpszFile, BOOL fAddLabel, DWORD renderopt, ULONG cFormats, LPFORMATETC rgFormatEtc, LPUNKNOWN lpUnk){ VDATEHEAP();
IOleCache FAR* lpOleCache; HRESULT error; BOOL fFound = FALSE; FORMATETC foretc; STGMEDIUM stgmed;
if (renderopt == OLERENDER_NONE || renderopt == OLERENDER_ASIS) return NOERROR;
if (rgFormatEtc == NULL) return NOERROR; // in this case we default to DVASPECT_CONTENT
for (ULONG i=0; i<cFormats; i++) { if ((rgFormatEtc[i].dwAspect == DVASPECT_ICON) && (rgFormatEtc[i].cfFormat == NULL || rgFormatEtc[i].cfFormat == CF_METAFILEPICT)) { foretc = rgFormatEtc[i]; fFound = TRUE; } }
if (!fFound) return NOERROR;
foretc.cfFormat = CF_METAFILEPICT; foretc.tymed = TYMED_MFPICT;
if ((error = lpUnk->QueryInterface(IID_IOleCache, (LPLPVOID) &lpOleCache)) != NOERROR) return error;
stgmed.tymed = TYMED_MFPICT; stgmed.pUnkForRelease = NULL;
// get icon data of file, from registration database
if (!(stgmed.hGlobal = OleGetIconOfFile((LPOLESTR) lpszFile, fAddLabel))) { error = ResultFromScode(E_OUTOFMEMORY); goto errRtn; }
// take ownership of the data
if ((error = lpOleCache->SetData(&foretc, &stgmed, TRUE)) != NOERROR) ReleaseStgMedium(&stgmed);
errRtn: lpOleCache->Release(); return error;
}
//+-------------------------------------------------------------------------
//
// Function: wNeedToPackage
//
// Synopsis: Determines whether or not a given CLSID should be
// packaged.
//
// Effects:
//
// Arguments: [rclsid] -- the class ID
//
// Requires:
//
// Returns: BOOL
//
// Signals:
//
// Modifies:
//
// Algorithm: Looks for the reg key PackageOnFileDrop, or if it's a
// Word document, or if it is insertable, or if it's an OLE1
// class
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
// 03-Jun-94 AlexT Just check for Insertable key (instead
// of requiring a value)
//
// Notes:
//--------------------------------------------------------------------------
INTERNAL_(BOOL) wNeedToPackage(REFCLSID rclsid){ VDATEHEAP();
HKEY hkeyClsid; HKEY hkeyTmp; HKEY hkeyTmp2; BOOL fPackage = FALSE; LPOLESTR lpszProgID; DWORD dw; LONG cbValue = sizeof(dw); LONG lRet; CLSID clsidNew;
if (NOERROR != OleGetAutoConvert (rclsid, &clsidNew)) { if (NOERROR != CoGetTreatAsClass (rclsid, &clsidNew)) { clsidNew = rclsid; } }
if (CoOpenClassKey(clsidNew, FALSE, &hkeyClsid) != NOERROR) return TRUE; // NON-OLE file, package it
if (ProgIDFromCLSID(clsidNew, &lpszProgID) == NOERROR) { // see whether we can open this key
dw = (DWORD) RegOpenKey(HKEY_CLASSES_ROOT, lpszProgID, &hkeyTmp);
PubMemFree(lpszProgID);
if (dw == ERROR_SUCCESS) { // This is definitely a OLE insertable file.
lRet = RegOpenKey(hkeyTmp, OLESTR("PackageOnFileDrop"), &hkeyTmp2); // Check whether we need to package this file
if (ERROR_SUCCESS == lRet) { RegCloseKey(hkeyTmp2); fPackage = TRUE; } else if (IsEqualCLSID(clsidNew, CLSID_WordDocument)) { // Hack to make sure Word documents are always
// Packaged on file drop. We write the key here
// so that we can say that a file is Packaged if
// and only if its ProgID has the "PackageOnFileDrop"
// key.
RegSetValue (hkeyTmp, OLESTR("PackageOnFileDrop"), REG_SZ, (LPOLESTR)NULL, 0); fPackage = TRUE; }
RegCloseKey(hkeyTmp);
if (fPackage) { RegCloseKey(hkeyClsid); return TRUE; } } }
// There is no "PackageOnFileDrop" key defined.
// See whether this is an "Insertable" class by checking for the
// existence of the Insertable key - we don't require a value
lRet = RegOpenKey(hkeyClsid, OLESTR("Insertable"), &hkeyTmp);
if (ERROR_SUCCESS == lRet) { // Insertable key exists - close it and return
RegCloseKey(hkeyTmp); goto errRtn; }
//
// See whether this is a "Ole1Class" class by opening the
// registry key Ole1Class. We don't require a value
//
cbValue = sizeof(dw); lRet = RegOpenKey(hkeyClsid,OLESTR("Ole1Class"),&hkeyTmp); if (ERROR_SUCCESS == lRet) { RegCloseKey(hkeyTmp); goto errRtn; } else { fPackage = TRUE; }
errRtn: RegCloseKey(hkeyClsid); return fPackage;}
//+-------------------------------------------------------------------------
//
// Function: wDoUpdate
//
// Synopsis: calls IOleObject->Update() on the given object, internal
// function
//
// Effects:
//
// Arguments: [lpUnkown] -- the object to update
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
#pragma SEG(wDoUpdate)
INTERNAL wDoUpdate(IUnknown FAR* lpUnknown){ VDATEHEAP();
HRESULT error = NOERROR; IOleObject FAR* lpOle;
if (lpUnknown->QueryInterface (IID_IOleObject, (LPLPVOID)&lpOle) == NOERROR) { error = lpOle->Update(); lpOle->Release(); }
return error;}
//+-------------------------------------------------------------------------
//
// Function: wBindIfRunning
//
// Synopsis: calls IOleLink->BindIfRunning() on the given object
//
// Effects:
//
// Arguments: [lpUnk] -- the object
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
INTERNAL_(void) wBindIfRunning(LPUNKNOWN lpUnk){ VDATEHEAP();
IOleLink FAR* lpLink;
if (lpUnk->QueryInterface (IID_IOleLink, (LPLPVOID)&lpLink) == NOERROR) { lpLink->BindIfRunning(); lpLink->Release(); }}
//+-------------------------------------------------------------------------
//
// Function: wQueryUseCustomLink
//
// Synopsis: look at the registry and see if the class ID has a custom
// link regisetered
//
// Effects:
//
// Arguments: [rclsid] -- the class ID in question
//
// Requires:
//
// Returns: BOOL
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 02-Nov-93 alexgo 32bit port
//
// Notes:
//
//--------------------------------------------------------------------------
INTERNAL_(BOOL) wQueryUseCustomLink(REFCLSID rclsid){ VDATEHEAP();
// see whether it has Custom Link implementation
HKEY hkeyClsid; HKEY hkeyTmp; BOOL bUseCustomLink = FALSE;
if (SUCCEEDED(CoOpenClassKey(rclsid, FALSE, &hkeyClsid))) { DWORD dw; dw = RegOpenKey(hkeyClsid,OLESTR("UseCustomLink"),&hkeyTmp);
if (ERROR_SUCCESS == dw) { RegCloseKey(hkeyTmp); bUseCustomLink = TRUE; }
RegCloseKey(hkeyClsid); }
return bUseCustomLink;}
|
