Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
NT4/private/ole32/ole232/cache/olecache.cpp
Microsoft ce47f986d8 First commit
2020-09-30 17:12:29 +02:00

6340 lines
180 KiB
C++
Raw Permalink Blame History

//+----------------------------------------------------------------------------
//
// File:
// olecache.cpp
//
// Contents:
// Ole default presentation cache implementation
//
// Classes:
// COleCache - ole multiple presentation cache
// CCacheEnum - enumerator for COleCache
//
// Functions:
// CreateDataCache
//
// History:
// 31-Jan-95 t-ScottH add Dump methods to COleCache
// CCacheEnum
// CCacheEnumFormatEtc
// add the following APIs: DumpCOleCache
// DumpCCacheEnum
// DumpCCacheEnumFormatEtc
// moved CCacheEnumFormatEtc def'n to header file
// added flag to COLECACHEFLAGS to indicate aggregation
// (_DEBUG only)
// 01/09/95 - t-ScottH - change VDATETHREAD to accept a this
// pointer, and added VDATETHREAD to IViewObject:: methods
// (COleCache::CCacheViewImpl:: )
// 03/01/94 - AlexGo - Added call tracing to AddRef/Release
// implementations
// 02/08/94 - ChrisWe - 7297: need implementation of
// FORMATETC enumerator
// 01/24/94 alexgo first pass at converting to Cairo-style
// memory allocation
// 01/11/94 - AlexGo - added VDATEHEAP macros to every function
// and method.
// 12/10/93 - AlexT - header file clean up, include ole1cls.h
// 12/09/93 - ChrisWe - incremented pointer in COleCache::GetNext()
// 11/30/93 - alexgo - fixed bugs with GETPPARENT usage
// 11/23/93 - ChrisWe - introduce use of CACHEID_NATIVE,
// CACHEID_GETNEXT_GETALL, CACHEID_GETNEXT_GETALLBUTNATIVE
// for documentary purposes
// 11/22/93 - ChrisWe - replace overloaded ==, != with
// IsEqualIID and IsEqualCLSID
// 07/04/93 - SriniK - Added the support for reading PBrush,
// MSDraw native objects, hence avoid creating
// presentation cache/stream. Also started writing static
// object data into "OLE_CONTENTS" stream in placeable
// metafile format for static metafile and DIB File
// format for static dibs. This enabled me to provide
// support for converting static objects. Also added code
// to support converting static metafile to MSDraw object
// and static DIB to PBrush object.
// 06/04/93 - SriniK - Added the support for demand loading and
// discarding the caches.
// 11/12/92 - SriniK - created
//
//-----------------------------------------------------------------------------
//
// A Brief Story about Cache IDs:
//
// Although I'm sure the true intent was to only to confuse mere mortals
// by randomly applying a modulus value to the cache id value, I think it
// works like this:
//
// When a node has never occupied this slot, its ID is simply its index
// into the array of present nodes. When a node is detached from the cache,
// the cache node pointer is cleared (signifying an emtpy slot), but its ID is
// left in the slot. When a new node is placed in this slot, it assumes
// the ID of the old node, plus MAX_CACHELIST_ITEMS. Thus if this constant
// is 100 (which it was last I looked), when node 5 is detached, and a new
// node is later added at this slot, it receives ID 105.
//
// I believe the intention was that this prevented apps from accidentally
// using ID 5 and getting the data from ID 105 by mistake (ie: referencing
// a stale connection).
#include <le2int.h>
#pragma SEG(olecache)
#include <olepres.h>
#include <olecache.h>
#include <cachenod.h>
#include <ole1cls.h>
#ifdef _DEBUG
#include <dbgdump.h>
#endif // _DEBUG
NAME_SEG(OleCache)
ASSERTDATA
#ifndef WIN32
#ifndef _MAC
const LONG lMaxSmallInt = 32767;
const LONG lMinSmallInt = -32768;
#else
#ifdef MAC_REVIEW
Review IS_SMALL_INT.
#endif
#include <limits.h>
#define lMaxSmallInt SHRT_MAX
#define lMinSmallInt SHRT_MIN
#endif
#define IS_SMALL_INT(lVal) \
((HIWORD(lVal) && ((lVal > lMaxSmallInt) || (lVal < lMinSmallInt))) \
? FALSE : TRUE)
#endif // WIN32
#define FREEZE_CONSTANT 143 // Used by Freeze() and Unfreeze()
// predefined CACHEIDs
#define CACHEID_INVALID ((DWORD)(-1))
#define CACHEID_NATIVE 0
// The CACHEID_GETNEXT_* values can be used when beginning an enumeration
// with the GetNext() functions to begin the enumeration at a particular
// place.
#define CACHEID_GETNEXT_GETALL ((DWORD)(-1))
#define CACHEID_GETNEXT_GETALLBUTNATIVE 0
// This was the original code...
/*
#define VERIFY_TYMED_SINGLE_VALID_FOR_CLIPFORMAT(pfetc) {\
if ((pfetc->cfFormat==CF_METAFILEPICT && pfetc->tymed!=TYMED_MFPICT)\
|| ( (pfetc->cfFormat==CF_BITMAP || \
pfetc->cfFormat == CF_DIB ) \
&& pfetc->tymed!=TYMED_GDI)\
|| (pfetc->cfFormat!=CF_METAFILEPICT && \
pfetc->cfFormat!=CF_BITMAP && \
pfetc->cfFormat!=CF_DIB && \
pfetc->tymed!=TYMED_HGLOBAL)) \
return ResultFromScode(DV_E_TYMED); \
}
*/
//+----------------------------------------------------------------------------
//
// Function:
// CheckTymedCFCombination (Internal)
//
// Synopsis:
// Verifies that the combination of clipformat and tymed is
// valid to the cache.
//
// Arguments:
// [pfetc] -- The candidate FORMATETC
//
// Returns:
// S_OK For a valid combination
// CACHE_S_FORMATETC_NOTSUPPORTED For a combination which can be
// cached, but not drawn by the cache
// DV_E_TYMED For all other combinations
//
// Rules:
//
// 1> (CMF && TMF) || (CEM && TEM) || (CB && TG) || (CD && TH) => S_OK
// (TH && ~CD) => CACHE_S_FORMATETC_NOTSUPPORTED
//
// 2> (~S_OK && ~CACHE_S_FORMATETC_NOTSUPPORTED) => DV_E_TYMED
//
// Where: CMF == CF_METAFILEPICT
// CEM == CF_ENHMETAFILE
// CB == CF_BITMAP
// CD == CF_FIB
// TMF == TYMED_MFPICT
// TEM == TYMED_ENHMETAFILE
// TG == TYMED_GDI
// TH == TYMED_HGLOBAL
//
// Notes:
// Since CACHE_S_FORMATETC_NOTSUPPORTED was never implemented in
// 16-bit, we return S_OK in its place if we are in the WOW.
//
// History:
// 01/07/94 DavePl Created
//
//-----------------------------------------------------------------------------
INTERNAL_(HRESULT) CheckTymedCFCombination(LPFORMATETC pfetc)
{
HRESULT hr;
// CF_METAFILEPICT on TYMED_MFPICT is a valid combination
if (pfetc->cfFormat == CF_METAFILEPICT && pfetc->tymed == TYMED_MFPICT)
{
hr = S_OK;
}
// CF_ENHMETAFILE on TYMED_ENHMF is a valid combination
else if (pfetc->cfFormat == CF_ENHMETAFILE && pfetc->tymed == TYMED_ENHMF)
{
hr = S_OK;
}
// CF_BITMAP on TYMED_GDI is a valid combination
else if (pfetc->cfFormat == CF_BITMAP && pfetc->tymed == TYMED_GDI)
{
hr = S_OK;
}
// CF_DIB on TYMED_HGLOBAL is a valid combination
else if (pfetc->cfFormat == CF_DIB && pfetc->tymed == TYMED_HGLOBAL)
{
hr = S_OK;
}
// Anything else on TYMED_HGLOBAL is valid, but we cannot draw it
else if (pfetc->tymed == TYMED_HGLOBAL)
{
hr = IsWOWThread() ? S_OK : CACHE_S_FORMATETC_NOTSUPPORTED;
}
// Any other combination is invalid
else
{
hr = DV_E_TYMED;
}
return hr;
}
//+----------------------------------------------------------------------------
//
// Function:
// IsSameAsObjectFormatEtc, internal
//
// Synopsis:
// REVIEW, checks to see if [lpforetc] is compatible with
// [cfFormat]. If [lpforetc] doesn't have a format set,
// sets it to cfFormat, which is then assumed to be
// one of CF_METAFILEPICT, or CF_DIB.
//
// Arguments:
// [lpforetc] -- a pointer to a FORMATETC
// [cfFormat] -- a clipboard format
//
// Returns:
// DV_E_ASPECT, if the aspect isn't DVASPECT_CONTENT
// DV_E_LINDEX, DV_E_CLIPFORMAT if the lindex or clipboard
// formats don't match
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
INTERNAL IsSameAsObjectFormatEtc(LPFORMATETC lpforetc, CLIPFORMAT cfFormat);
//+----------------------------------------------------------------------------
//
// Function:
// CreateDataCache, public
//
// Synopsis:
// Creates an instance of COleCache, the default presentation
// cache used by Ole.
//
// Arguments:
// [pUnkOuter] -- pointer to outer unknown, if this is being
// aggregated
// [rclsid] -- the class that the cache should assume for itself
// [iid] -- the interface the user would like returned
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_OUTOFMEMORY, S_OK
//
// Notes:
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CreateDataCache)
STDAPI CreateDataCache(IUnknown FAR* pUnkOuter, REFCLSID rclsid, REFIID iid,
LPVOID FAR* ppv)
{
OLETRACEIN((API_CreateDataCache, PARAMFMT("pUnkOuter= %p, rclsid= %I, iid= %I, ppv= %p"),
pUnkOuter, &rclsid, &iid, ppv));
VDATEHEAP();
HRESULT error;
COleCache FAR* lpCOleCache; // the newly allocated cache
CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IUnknown,(IUnknown **)&pUnkOuter);
// NULL for pUnkOuter is OK
if (pUnkOuter)
{
VDATEIFACE_LABEL(pUnkOuter, errRtn, error);
if (!IsEqualIID(iid, IID_IUnknown))
{
// being aggregated but they did not request IUnknown
error = E_INVALIDARG;
goto errRtn;
}
}
// allocate new cache
lpCOleCache = (COleCache FAR*) new FAR COleCache(pUnkOuter, rclsid);
// if insufficient memory, return
if (!lpCOleCache)
{
*ppv = NULL;
error = ResultFromScode(E_OUTOFMEMORY);
goto errRtn;
}
// if we're being aggregated, return private IUnknown
if (pUnkOuter)
{
*ppv = (void FAR *)(IUnknown FAR *)&lpCOleCache->m_UnkPrivate;
error = NOERROR;
}
else
{
// get requested interface on cache
error = lpCOleCache->QueryInterface(iid, ppv);
// release local pointer to cache and return
lpCOleCache->Release();
}
CALLHOOKOBJECTCREATE(error, rclsid, iid, (IUnknown **)ppv);
errRtn:
OLETRACEOUT((API_CreateDataCache, error));
return error;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::COleCache, public
//
// Synopsis:
// constructor
//
// Arguments:
// [pUnkOuter] -- outer unknown, if being aggregated
// [rclsid] -- the class id the cache should assume for itself
//
// Notes:
// The IUnknown returned is not the private unknown. The private
// unknown is pOleCache->m_UnkPrivate
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_ctor)
COleCache::COleCache(IUnknown FAR* pUnkOuter, REFCLSID rclsid)
{
VDATEHEAP();
GET_A5();
// set reference count for return from constructor
m_refs = 1;
// initialize flags
m_uFlag = 0;
// aggregate, or use our own IUnknown for outer IUnknown
if (NULL == pUnkOuter)
{
m_pUnkOuter = &m_UnkPrivate;
}
else
{
m_pUnkOuter = pUnkOuter;
// this is for the debugger extensions
// (since we can not compare m_pUnkOuter to m_pUnkPrivate with copied mem)
// it is only used in the ::Dump method
#ifdef _DEBUG
m_uFlag |= COLECACHEF_AGGREGATED;
#endif // _DEBUG
}
// no storage yet
m_pStg = NULL;
// initialize cache list
m_uCacheNodeCnt = 0;
m_uCacheNodeMax = 0;
m_pCacheList = NULL;
LEVERIFY( GrowCacheList() ); // REVIEW(davepl) Need error case here?
m_pCacheEnum = NULL; // pointer to cache enumerator list
// no advise sink connected for the view object
m_pViewAdvSink = NULL;
m_advfView = 0;
m_aspectsView = 0;
// id of cache node which was used in the previous Draw call
m_dwDrawCacheId = CACHEID_INVALID;
// no frozen aspects
m_dwFrozenAspects = NULL;
// no data object yet
m_pDataObject = NULL; // non-NULL if running; no ref count
m_clsid = rclsid;
// set flags for the format, based on the clsid
if (IsEqualCLSID(m_clsid, CLSID_StaticMetafile))
{
m_cfFormat = CF_METAFILEPICT;
m_uFlag |= COLECACHEF_STATIC | COLECACHEF_FORMATKNOWN;
}
else if (IsEqualCLSID(m_clsid, CLSID_StaticDib))
{
m_cfFormat = CF_DIB;
m_uFlag |= COLECACHEF_STATIC | COLECACHEF_FORMATKNOWN;
}
else if (IsEqualCLSID(m_clsid, CLSID_PBrush))
{
m_cfFormat = CF_DIB;
m_uFlag |= COLECACHEF_PBRUSHORMSDRAW | COLECACHEF_FORMATKNOWN;
}
else if (IsEqualCLSID(m_clsid, CLSID_MSDraw))
{
m_cfFormat = CF_METAFILEPICT;
m_uFlag |= COLECACHEF_PBRUSHORMSDRAW | COLECACHEF_FORMATKNOWN;
}
else if (IsEqualCLSID(m_clsid, CLSID_Picture_EnhMetafile))
{
m_cfFormat = CF_ENHMETAFILE;
m_uFlag |= COLECACHEF_STATIC | COLECACHEF_FORMATKNOWN;
}
else
{
m_cfFormat = NULL;
}
// If we know the object format then add a cachenode for it. This node
// will be put in the 0th entry of the cachelist. This node never gets
// saved. It's get used in drawing, for finding out the extents, and by
// the enumerator, etc...
if (m_cfFormat)
{
LEVERIFY( AddCacheNodeForNative() );
}
m_fUsedToBePBrush = FALSE;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::~COleCache, public //REVIEW
//
// Synopsis:
// destructor
//
// Notes:
// Enumerators for the cache no not reference count it, with the
// view that the cache can go away at any time, invalidating
// the enumerators. This walks the list of enumerators, alerting
// them to the fact that the cache is being destroyed.
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_dtor)
COleCache::~COleCache(void)
{
VDATEHEAP();
M_PROLOG(this);
// Notify all cache enumerators that we are getting deleted
while(m_pCacheEnum)
{
m_pCacheEnum->OnOleCacheDelete();
m_pCacheEnum = m_pCacheEnum->m_pNextCacheEnum;
}
// Clear the cache list - delete all the cache nodes
DeleteAll();
// delete the list of cache node pointers
PubMemFree(m_pCacheList);
// if we're holding storage, release it
if (m_pStg)
{
m_pStg->Release();
m_pStg = NULL;
}
// if we're holding an advise sink, release it
if (m_pViewAdvSink)
{
m_pViewAdvSink->Release();
m_pViewAdvSink = NULL;
}
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_QueryInterface)
STDMETHODIMP COleCache::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
VDATEHEAP();
return(m_pUnkOuter->QueryInterface(iid, ppv));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_AddRef)
STDMETHODIMP_(ULONG) COleCache::AddRef(void)
{
VDATEHEAP();
return(m_pUnkOuter->AddRef());
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/15/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_Release)
STDMETHODIMP_(ULONG) COleCache::Release(void)
{
VDATEHEAP();
return(m_pUnkOuter->Release());
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetExtent, public
//
// Synopsis:
// Gets the size of the cached presentation for [dwAspect]. If
// there are several, because of varied advise control flags,
// such as ADVF_NODATA, ADVF_ONSTOP, ADVF_ONSAVE, etc, gets the
// most up to date one, up to frozen cached values
//
// Arguments:
// [dwAspect] -- the aspect for which we'd like the extent
// [lpsizel] -- pointer to where to return the width and height
//
// Returns:
// OLE_E_BLANK
// S_OK
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetExtent)
INTERNAL COleCache::GetExtent(DWORD dwAspect, LPSIZEL lpsizel)
{
VDATEHEAP();
DWORD dwCacheId; // cache id of node currently being examined
LPCACHENODE lpCacheNode; // pointer to node being examined
int iCacheType; // cache type [from below] of node being examined
int iCacheTypeSoFar; // best cache type so far
// these values are defined in order of least to best preferred, so that
// numeric comparisons are valid; DO NOT REORDER
#define CACHETYPE_NODATA 1
#define CACHETYPE_ONSTOP 2
#define CACHETYPE_ONSAVE 3
#define CACHETYPE_NORMAL 4
const FORMATETC FAR *lpforetc; // format information for current node
DWORD grfAdvf; // advise flags for current node
// if there are no cache nodes, there's nothing we can return
if (!m_uCacheNodeCnt)
{
lpsizel->cx = 0;
lpsizel->cy = 0;
return ResultFromScode(OLE_E_BLANK);
}
// Here we want to return the extents of the cache node that has NORMAL
// advise flags. If we don't find such a node then we will take the next
// best available.
// REVIEW(davepl) Clean up this loop, I get ill just looking at it
for(iCacheTypeSoFar = 0, dwCacheId = CACHEID_GETNEXT_GETALL;
lpCacheNode = GetNext(dwAspect, DEF_LINDEX,
&dwCacheId);)
{
// get a pointer to the FORMATETC for this node
lpforetc = lpCacheNode->GetFormatEtc();
// make sure the cfFormat is either CF_METAFILEPICT or CF_DIB
if ((lpforetc->cfFormat == CF_METAFILEPICT) ||
(lpforetc->cfFormat == CF_DIB) ||
(lpforetc->cfFormat == CF_ENHMETAFILE))
{
grfAdvf = lpCacheNode->GetAdvf();
if (!(grfAdvf & (ADVFCACHE_ONSAVE |
ADVF_DATAONSTOP | ADVF_NODATA)))
iCacheType = CACHETYPE_NORMAL;
else
{
if (grfAdvf & ADVFCACHE_ONSAVE)
iCacheType = CACHETYPE_ONSAVE;
else if (grfAdvf & ADVF_NODATA)
iCacheType = CACHETYPE_NODATA;
else
iCacheType = CACHETYPE_ONSTOP;
}
if (iCacheType > iCacheTypeSoFar)
{
SIZEL sizelTmp;
// Get the extents from the presentation object
if ((lpCacheNode->GetPresObj())->GetExtent(
dwAspect, &sizelTmp) != NOERROR)
continue;
if (sizelTmp.cx == 0 || sizelTmp.cy == 0)
continue;
// We got proper extent, update state.
// If the cache is a
// NORMAL cache then we are done.
*lpsizel = sizelTmp;
if ((iCacheTypeSoFar = iCacheType) ==
CACHETYPE_NORMAL)
return NOERROR;
}
}
}
if (lpsizel->cx == 0 || lpsizel->cy == 0)
return ResultFromScode(OLE_E_BLANK);
return NOERROR;
// don't need these anymore
#undef CACHETYPE_NODATA
#undef CACHETYPE_ONSTOP
#undef CACHETYPE_ONSAVE
#undef CACHETYPE_NORMAL
}
// Private methods of COleCache - called by its friends CCacheNode, CCacheEnum
// and all nested classes of COleCache
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::OnChange, private
//
// Synopsis:
// Used by cache nodes to alert the cache that their content has
// changed. The advise sink held by the cache is alerted to
// the change if it affects an aspect that the advise sink is
// interested in.
//
// Arguments:
// [dwAspect] -- the aspect that changed
// [lindex] -- the lindex for the aspect that changed
// [fDirty] -- indicates that the change has made the cache dirty
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
// Each one of the cache nodes call this method when their data changes. We
// in turn send the view notification only if the aspect and lindex of the
// cache node (that called us) matches with the aspect and lindex for which
// view advise is set up.
#pragma SEG(COleCache_OnChange)
INTERNAL_(void) COleCache::OnChange(DWORD dwAspect, LONG lindex, BOOL fDirty)
{
VDATEHEAP();
M_PROLOG(this);
// mark the cache as dirty
if (fDirty)
m_uFlag |= COLECACHEF_DIRTY;
// if there's no view advise sink, there's nothing to do
if (m_pViewAdvSink == NULL)
return;
// if the aspect that changed is not one that the view advise sink
// client is interested in, there's nothing more to do
if (!(m_aspectsView & dwAspect))
return;
// advise the view advise sink client of the change
m_pViewAdvSink->OnViewChange(dwAspect, lindex);
// if client only wanted notification once, free the advise sink
if (m_advfView & ADVF_ONLYONCE)
{
m_pViewAdvSink->Release();
m_pViewAdvSink = NULL;
}
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetStg, private
//
// Synopsis:
// returns the storage the cache has been given to use
//
// Arguments:
// none
//
// Returns:
// pointer to the IStorage instance
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
INTERNAL_(LPSTORAGE) COleCache::GetStg(void)
{
VDATEHEAP();
return m_pStg;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::DetachCacheEnum, private
//
// Synopsis:
// This removes an instance of CCacheEnum from the list of
// enumerators maintained by COleCache.
//
// Arguments:
// [pCacheEnum] -- the cache enumerator to remove
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
// CCacheEnum calls this routine to remove its pointer to the enumerators list
#pragma SEG(COleCache_DetachCacheEnum)
INTERNAL_(void) COleCache::DetachCacheEnum(CCacheEnum FAR* pCacheEnum)
{
VDATEHEAP();
CCacheEnum FAR *FAR *ppCE; // pointer to the pointer to the list item
CCacheEnum FAR *pCE; // pointer to the item
// NOTE: no ref count
// search the list for [pCacheEnum]
for(ppCE = &m_pCacheEnum; pCE = *ppCE; ppCE = &pCE->m_pNextCacheEnum)
{
// if we find [pCacheEnum], splice it out of the list
if (pCE == pCacheEnum)
{
*ppCE = pCE->m_pNextCacheEnum;
pCE->m_pNextCacheEnum = NULL;
break;
}
}
}
// Following are the COleCache cache list manipulation methods
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GrowCacheList, private
//
// Synopsis:
// Grows the size of the cachenode list. Use this when all
// available nodes are used up. Grows the list by
// NUM_CACHELIST_ITEMS
//
// Arguments:
// none
//
// Returns:
// TRUE if the list is successfully grown, FALSE otherwise
//
// Modifies:
// m_pCacheList
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GrowCacheList)
INTERNAL_(BOOL) COleCache::GrowCacheList(void)
{
VDATEHEAP();
ULONG ulNewMax; // the number of cache nodes we'll have after growing
ULONG ulSize; // the amount of memory required
LPCACHELIST pCacheList; // pointer to the (re)allocated memory
ULONG ulCnt; // used to count off the new items for initialization
ulNewMax = NUM_CACHELIST_ITEMS + m_uCacheNodeMax;
// The current architecture of the cache prevents the cachenode
// array from having more entries that MAX_CACHELIST_ITEMS, so
// we must fail any attempt to grow the cache beyond this point.
if (ulNewMax > MAX_CACHELIST_ITEMS)
{
return NULL;
}
ulSize = ulNewMax * sizeof(CACHELIST_ITEM);
// (re)allocate the memory for the cachelist array
if (m_pCacheList == NULL)
pCacheList = (LPCACHELIST)PubMemAlloc(ulSize);
else
pCacheList = (LPCACHELIST)PubMemRealloc(m_pCacheList,
ulSize);
// if allocation failed, nothing more we can do
if (pCacheList == NULL)
return FALSE;
// REVIEW, if a reallocation, if m_pCacheList still valid on failure
// assign the new memory
m_pCacheList = pCacheList;
// initialize the newly allocated items with 0
for (pCacheList += m_uCacheNodeMax, ulCnt = NUM_CACHELIST_ITEMS;
ulCnt; ++pCacheList, --ulCnt)
{
pCacheList->dwCacheId = 0;
pCacheList->lpCacheNode = 0;
}
// record new array length
m_uCacheNodeMax = ulNewMax;
return TRUE;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::DeleteAll, private
//
// Synopsis:
// Delete all cache nodes in the cache list array
//
// Arguments:
// none
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
// clear the cache list
#pragma SEG(COleCache_DeleteAll)
INTERNAL_(void) COleCache::DeleteAll(void)
{
VDATEHEAP();
DWORD dwCacheId = CACHEID_GETNEXT_GETALL;
LPCACHENODE lpCacheNode;
// if no nodes are in use, nothing to do
if (!m_uCacheNodeCnt)
return;
// get each node that is in use, and free it
while(m_uCacheNodeCnt && GetNext(&dwCacheId))
{
// Remove the CacheNode from the list and then delete it.
if (lpCacheNode = Detach(dwCacheId))
lpCacheNode->Delete();
}
Assert(!m_uCacheNodeCnt);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Attach, private
//
// Synopsis:
// adds a new cache node to the cache node list
//
// Arguments:
// [lpCacheNode] -- pointer to new cache node to add to the list
//
// Returns:
// The cache id of the newly added node, or CACHEID_INVALID,
// if it cannot be attached.
//
// Modifies:
// m_pCacheList
//
// Notes:
//
// History:
// 11/16/93 - ChrisWe - file inspection and cleanup; return
// CACHEID_INVALID on failure, instead of zero, which
// is a legitimate (internal) cache node id
//
//-----------------------------------------------------------------------------
// Find an empty entry and add the CacheNode to the list. Note that
// lpCacheNode is not ref counted.
#pragma SEG(COleCache_Attach)
INTERNAL_(DWORD) COleCache::Attach(LPCACHENODE lpCacheNode)
{
VDATEHEAP();
CACHELIST_ITEM FAR *pCI; // pointer to current cachelist item
ULONG c; // counter
// The dwCacheID is nothing but the index into the array plus
// N*MAX_CACHELIST_ITEMS. Since 0 cannot be a valid connection ID, we
// should not use the 0th entry of the array.
// REVIEW, and yet we do, for the CACHEID_NATIVE!!!
// look for an empty slot
for(pCI = m_pCacheList + (c = CACHEID_NATIVE+1); c < m_uCacheNodeMax;
++pCI, ++c)
{
if (pCI->lpCacheNode == NULL)
goto foundEmpty;
}
// if we get here, all slots are in use, so grow the array of slots
// if we can't grow it, get out
if (!GrowCacheList())
return(CACHEID_INVALID);
// the first free slot is at the end of the (newly allocated) array
pCI = m_pCacheList+c;
foundEmpty:
// We found an empty slot. Now assign the cache ID such that we
// will be able to catch error cases.
if (pCI->dwCacheId == 0)
pCI->dwCacheId = c;
else
pCI->dwCacheId += MAX_CACHELIST_ITEMS;
pCI->lpCacheNode = lpCacheNode;
// Keep track of the number of caches
m_uCacheNodeCnt++;
return pCI->dwCacheId;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Detach, private
//
// Synopsis:
// Remove the indicated cache node from the list of cache nodes
// maintained. The cache node is not deleted, but is returned.
//
// Arguments:
// [dwCacheId] -- the id of the cache node
//
// Returns:
// pointer to the detached cache node, if it is found, or NULL.
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_Detach)
INTERNAL_(LPCACHENODE) COleCache::Detach(DWORD dwCacheId)
{
VDATEHEAP();
ULONG index = dwCacheId % MAX_CACHELIST_ITEMS;
LPCACHENODE lpCacheNode = NULL; // return value; the node being detached
CACHELIST_ITEM FAR *pCI; // the cachelist item affected
if (index >= m_uCacheNodeMax)
return NULL;
pCI = m_pCacheList+index;
if ((pCI->dwCacheId == dwCacheId) && (pCI->lpCacheNode != NULL))
{
// record the cache node pointer for return
lpCacheNode = pCI->lpCacheNode;
// mark this cache node item as unused
pCI->lpCacheNode = NULL;
Assert(m_uCacheNodeCnt != 0);
// Keep trck of the number of caches
m_uCacheNodeCnt--;
}
return lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetNext, private
//
// Synopsis:
// Fetch the next cache node after the one identified by
// *[lpdwCacheId]. Update *[lpdwCacheID] to that node.
//
// Arguments:
// [lpdwCacheId] -- pointer to a cache id.
//
// Returns:
// pointer to the cache node, if there is one, or NULL
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
// Upon entry *lpdwCacheId will be set to the cur cache id. On exit it will be
// set to the next valid cache id.
#pragma SEG(COleCache_GetNext)
INTERNAL_(LPCACHENODE) COleCache::GetNext(LPDWORD lpdwCacheId)
{
VDATEHEAP();
CACHELIST_ITEM FAR *pCI; // used to walk the array of cachelist items
ULONG index; // the index of the current cachelist item
// Start from the entry next to the current one. If starting at the
// "next" element pushes us past the last possible cache node index,
// there's no way we can actually find anything, so return NULL.
if (*lpdwCacheId % MAX_CACHELIST_ITEMS == MAX_CACHELIST_ITEMS - 1)
{
return NULL;
}
index = (*lpdwCacheId+1) % MAX_CACHELIST_ITEMS;
for(pCI = m_pCacheList + index; index < m_uCacheNodeMax; ++pCI, ++index)
{
if (pCI->lpCacheNode)
{
*lpdwCacheId = pCI->dwCacheId;
return pCI->lpCacheNode;
}
}
// if we got here, we went off the end of the array
// REVIEW, should we set *lpdwCacheId so we don't iterate again
// if the last N entries were all empty?
return NULL;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetAt, private
//
// Synopsis:
// Fetch the cache node identified by [dwCacheId]
//
// Arguments:
// [dwCacheId] -- the id of the cache node to fetch
//
// Returns:
// the pointer to the cache node, if it is valid, or NULL
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetAt)
INTERNAL_(LPCACHENODE) COleCache::GetAt(DWORD dwCacheId)
{
VDATEHEAP();
ULONG index = dwCacheId % MAX_CACHELIST_ITEMS;
CACHELIST_ITEM FAR *pCI;
if (index >= m_uCacheNodeMax)
return NULL;
pCI = m_pCacheList+index;
if (pCI->dwCacheId == dwCacheId)
return(pCI->lpCacheNode); // could be NULL
return NULL;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetAt, private
//
// Synopsis:
// Fetch the cache node with the given [dwAspect], [lindex],
// [cfFormat], and for device described by [ptd]
//
// Arguments:
// [dwAspect] -- the aspect to look for
// [lindex] -- the lindex to look for
// [cfFormat] -- the clipboard format to look for
// [ptd] -- the target device for the cache node
// [lpdwCacheId] -- a pointer to where to return the cache node
// id, if a match is found
//
// Returns:
// pointer to a cache node that matches the requested attributes,
// if there is one, or NULL
//
// Notes:
// the m_dwDrawCacheId node is checked first, if there is one
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetAt)
INTERNAL_(LPCACHENODE) COleCache::GetAt(DWORD dwAspect, LONG lindex,
CLIPFORMAT cfFormat, DVTARGETDEVICE FAR* ptd, DWORD FAR* lpdwCacheId)
{
VDATEHEAP();
DWORD dwCacheId = CACHEID_GETNEXT_GETALL;
LPCACHENODE lpCacheNode = NULL;
const FORMATETC FAR *lpforetc;
// Check to see whether the cache currently being used for drawing is
// the one that we are looking for.
if (m_dwDrawCacheId != CACHEID_INVALID)
{
if (!(lpCacheNode = GetAt(m_dwDrawCacheId)))
{
// the draw cache id has become invalid, so clear it.
m_dwDrawCacheId = CACHEID_INVALID;
}
else
{
// The draw cache id is valid, get the formatetc of
// the cache
lpforetc = lpCacheNode->GetFormatEtc();
// look for a match
if ((lpforetc->cfFormat == cfFormat) &&
(lpforetc->dwAspect == dwAspect) &&
(lpforetc->lindex == lindex) &&
UtCompareTargetDevice(ptd,
lpforetc->ptd))
{
dwCacheId = m_dwDrawCacheId;
goto errRtn;
}
}
}
// What we are looking for does not match with the current draw cache.
// So, scan the list for a match.
while(lpCacheNode = GetNext(&dwCacheId))
{
if (dwCacheId == m_dwDrawCacheId)
continue; // we have checked the draw cache, so skip it
lpforetc = lpCacheNode->GetFormatEtc();
if ((lpforetc->cfFormat == cfFormat) &&
(lpforetc->dwAspect == dwAspect) &&
(lpforetc->lindex == lindex) &&
UtCompareTargetDevice(ptd, lpforetc->ptd))
break; // we found a match, so break out of the loop
}
// if we don't find a match, then lpCacheNode will be NULL.
errRtn:
if (lpdwCacheId)
*lpdwCacheId = dwCacheId;
return lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetNext, public
//
// Synopsis:
// Fetch the next cache node after the one identified by
// *[lpdwCacheId] that matches the given [dwAspect] and [lindex]
//
// Arguments:
// [dwAspect] -- the aspect to look for
// [lindex] -- the lindex to look for
// [lpdwCacheId] -- pointer to a cache id of the node after which
// to start the search. The cache id of the node that
// is found to match [dwAspect] and [lindex] will be
// returned in the same place.
//
// Returns:
// pointer to the cache node that matches the requested
// attributes, if one is found, or NULL
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetNext)
INTERNAL_(LPCACHENODE) COleCache::GetNext(DWORD dwAspect, LONG lindex,
DWORD FAR* lpdwCacheId)
{
VDATEHEAP();
DWORD dwCacheId = *lpdwCacheId;
LPCACHENODE lpCacheNode = NULL;
const FORMATETC FAR *lpforetc;
while(lpCacheNode = GetNext(&dwCacheId))
{
lpforetc = lpCacheNode->GetFormatEtc();
if ((lpforetc->dwAspect == dwAspect) &&
(lpforetc->lindex == lindex))
break; // we found a match, so break out of the loop
}
// if we don't find a match, then lpCacheNode will be NULL.
// REVIEW, so why don't we advance *lpdwCacheId in that case?
if (lpCacheNode)
*lpdwCacheId = dwCacheId;
return lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetAt, private
//
// Synopsis:
// Fetch a pointer to the cache node with the given FORMATETC,
// if there is one. if [lpforetc]->cfFormat is NULL, we check
// for CF_ENHMETAFILE, CF_METAFILE, and CF_DIB, in that order.
//
// Arguments:
// [lpforetc] -- pointer to the FORMATETC to check for
//
// Returns:
// Pointer to the cache node with a matching FORMATETC, if there
// is one, or NULL.
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetAt)
INTERNAL_(LPCACHENODE) COleCache::GetAt(LPFORMATETC lpforetc,
DWORD FAR* lpdwCacheId)
{
VDATEHEAP();
LPCACHENODE lpCacheNode;
if (lpforetc->cfFormat == 0)
{
// See whether we already cached an EMF, metafile or a DIB
if (lpCacheNode = GetAt(lpforetc->dwAspect, lpforetc->lindex,
CF_METAFILEPICT, lpforetc->ptd, lpdwCacheId))
goto Exit;
if (lpCacheNode = GetAt(lpforetc->dwAspect, lpforetc->lindex,
CF_DIB, lpforetc->ptd, lpdwCacheId))
goto Exit;
if (lpCacheNode = GetAt(lpforetc->dwAspect, lpforetc->lindex,
CF_ENHMETAFILE, lpforetc->ptd, lpdwCacheId))
goto Exit;
// If we have a NULL node, and we are _looking_ for a NULL
// node, we must satisfy the request so that the advise flags
// can be updated for multiple caches of NULL nodes.
if (lpCacheNode = GetAt(lpforetc->dwAspect, lpforetc->lindex,
0, lpforetc->ptd, lpdwCacheId))
goto Exit;
}
else
{
// NON-NULL cfFormat
// see whether this format is already cached.
if (lpCacheNode = GetAt(lpforetc->dwAspect, lpforetc->lindex,
lpforetc->cfFormat, lpforetc->ptd, lpdwCacheId))
goto Exit;
}
Exit:
return lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetPresObjForDrawing, private
//
// Synopsis:
// Fetch a presentation object matching the given parameters,
// if there is one. We try to get CF_ENHMETAFILE,
// CF_METAFILEPICT, and CF_DIB formats, in that order.
//
// Arguments:
// [dwAspect] -- the aspect we'd like
// [lindex] -- the lindex we'd like
// [ptd] -- description of the target device the presentation
// should be suitable for
//
// Returns:
// pointer to the presentation object, if a suitable one is
// found, or NULL
//
// Modifies:
// m_dwDrawCacheId is set to the newly found cache id, if one
// is found
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetPresObjForDrawing)
INTERNAL_(LPOLEPRESOBJECT) COleCache::GetPresObjForDrawing(DWORD dwAspect,
LONG lindex, DVTARGETDEVICE FAR* ptd)
{
VDATEHEAP();
LPOLEPRESOBJECT lpPresObj; // the found presentation object
DWORD dwCacheId; // the cache id of the presentation object
// Try for Enhanced Metafile
if ((lpPresObj = GetPresObj(dwAspect, lindex, CF_ENHMETAFILE, ptd,
&dwCacheId)) && !lpPresObj->IsBlank())
goto success;
// Try for Metafile
if ((lpPresObj = GetPresObj(dwAspect, lindex, CF_METAFILEPICT, ptd,
&dwCacheId)) && !lpPresObj->IsBlank())
goto success;
// Try for Dib
if ((lpPresObj = GetPresObj(dwAspect, lindex, CF_DIB, ptd,
&dwCacheId)) && !lpPresObj->IsBlank())
goto success;
return NULL;
success:
// COleCache try to get the CacheNode for a given dwAspect, lindex, ptd,
// etc.., they will first try the cachenode with this cache id, and if
// they don't find the match they will start scanning the list.
//
// This caching is necessary 'cause even when the containers create
// mutiple caches most of the time they deal with only one (view)
// aspect.
m_dwDrawCacheId = dwCacheId;
return lpPresObj;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetPresObj, private
//
// Synopsis:
// Get the presentation object of the cache node which matches
// the requested attributes.
//
// Arguments:
// [dwAspect] -- the aspect
// [lindex] -- the lindex
// [cfFormat] -- the clipboard format
// [ptd] -- points to the description of the target device
// [pdwCacheId] -- pointer to a location where the cache id
// can be returned for the presentation object
//
// Returns:
// pointer to the presentation object, is one is found that
// matches the requested parameters, or NULL
//
// Notes:
// If a request is made for CF_BITMAP ([cfFormat]), then
// GetPresObj() checks for CF_DIB.
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetPresObj)
INTERNAL_(LPOLEPRESOBJECT) COleCache::GetPresObj(DWORD dwAspect, LONG lindex,
CLIPFORMAT cfFormatIn, DVTARGETDEVICE FAR* ptd,
DWORD FAR* pdwCacheId)
{
VDATEHEAP();
LPCACHENODE lpCacheNode;
#ifndef _MAC
CLIPFORMAT cfFormat = ((cfFormatIn == CF_BITMAP) ? CF_DIB :
cfFormatIn);
#endif
if (lpCacheNode = GetAt(dwAspect, lindex, cfFormat, ptd, pdwCacheId))
return lpCacheNode->GetPresObj();
return NULL;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::AddCacheNodeForNative, private
//
// Synopsis:
// Create the Native format cache node, and add it to the list
// of cache nodes, if it doesn't already exist.
//
// Arguments:
// none
//
// Returns:
// pointer to the found, or newly created cache node. Can
// return NULL if out of memory
//
// Notes:
// This assumes that m_cfFormat is set.
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
INTERNAL_(LPCACHENODE)COleCache::AddCacheNodeForNative(void)
{
VDATEHEAP();
CACHELIST_ITEM FAR *pCI; // points to CACHEID_NATIVE cache node
LPCACHENODE lpCacheNode; // points to the cache node in the cache list
FORMATETC foretc; // the format we'll initialize the new node with
// point at the CACHEID_NATIVE node
pCI = &m_pCacheList[CACHEID_NATIVE];
// if we already have a native format, return it
if (pCI->lpCacheNode)
return(pCI->lpCacheNode);
Assert(m_cfFormat);
INIT_FORETC(foretc);
foretc.cfFormat = m_cfFormat;
if (foretc.cfFormat == CF_METAFILEPICT)
{
foretc.tymed = TYMED_MFPICT;
}
else if (foretc.cfFormat == CF_ENHMETAFILE)
{
foretc.tymed = TYMED_ENHMF;
}
else
{
foretc.tymed = TYMED_HGLOBAL; // REVIEW, need to use union
}
// create cache node
if (lpCacheNode = new FAR CCacheNode(&foretc,
(((m_uFlag & COLECACHEF_PBRUSHORMSDRAW) && !m_fUsedToBePBrush) ?
ADVF_NODATA : 0), this))
{
if (lpCacheNode->CreatePresObject(NULL /*lpDataObj*/,
FALSE /*fConvert*/) != NOERROR)
{
// if we can't create presentation object,
// delete the cache node, and drop out
lpCacheNode->Delete();
}
else
{
// there's one more cache node in use
++m_uCacheNodeCnt;
// set this as the CACHEID_NATIVE cache node
pCI->lpCacheNode = lpCacheNode;
}
}
// if creation failed, this will return NULL
return pCI->lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::DeleteCacheNodeForNative, private
//
// Synopsis:
// Delete the native format cache node
//
// Arguments:
// none
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
inline INTERNAL_(void) COleCache::DeleteCacheNodeForNative(void)
{
VDATEHEAP();
CACHELIST_ITEM FAR *pCI = &m_pCacheList[CACHEID_NATIVE];
// if there is no native cache node, there's nothing to do
if (!pCI->lpCacheNode)
return;
// delete the native cache node
pCI->lpCacheNode->Delete();
pCI->lpCacheNode = NULL;
--m_uCacheNodeCnt;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::MoveCacheNodeForNative, private
//
// Synopsis:
// Moves whatever cache node is under CACHEID_NATIVE to
// another position and another cache id, leaving the
// native cachenode unused.
//
// Arguments:
// none
//
// Notes:
//
// History:
// 11/17/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
inline INTERNAL_(void) COleCache::MoveCacheNodeForNative(void)
{
VDATEHEAP();
if (m_pCacheList[CACHEID_NATIVE].lpCacheNode)
Attach(Detach(CACHEID_NATIVE));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::UpdateCacheNodeForNative, private
//
// Synopsis:
// Update the native data cache node from the storage currently
// associated with the cache
//
// Arguments:
// none
//
// Returns:
// a pointer to the native cache node
//
// Notes:
//
// History:
// 11/23/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
INTERNAL_(LPCACHENODE) COleCache::UpdateCacheNodeForNative()
{
VDATEHEAP();
CACHELIST_ITEM FAR *pCI = &m_pCacheList[CACHEID_NATIVE];
FORMATETC foretc;
STGMEDIUM stgmed;
// if there is no native cache node, add one
if (!pCI->lpCacheNode)
{
AddCacheNodeForNative();
// if there still isn't a native cache node, get out
if (!pCI->lpCacheNode)
return NULL;
}
Assert(m_pStg);
if (!m_pStg)
goto errRtn;
// initialize a FORMATETC for native data
INIT_FORETC(foretc);
foretc.cfFormat = m_cfFormat;
if (foretc.cfFormat == CF_METAFILEPICT)
{
foretc.tymed = TYMED_MFPICT;
}
else if (foretc.cfFormat == CF_ENHMETAFILE)
{
foretc.tymed = TYMED_ENHMF;
}
else
{
foretc.tymed = TYMED_HGLOBAL; // REVIEW, need to use union
}
// retrieve a global with the native data
stgmed.pUnkForRelease = NULL;
stgmed.tymed = foretc.tymed;
stgmed.hGlobal = UtGetHPRESFromNative(m_pStg, foretc.cfFormat,
(m_uFlag & COLECACHEF_PBRUSHORMSDRAW) ? TRUE : FALSE);
// set the data
if (stgmed.hGlobal)
pCI->lpCacheNode->SetData(&foretc, &stgmed, TRUE);
errRtn:
return pCI->lpCacheNode;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleObject::FindObjectFormat, private
//
// Synopsis:
// Determines what the object's clipboard format is. If
// it is CF_ENHMETAFILE, CF_METAFILEPICT, or CF_DIB, the format
// is marked as COLECACHE_FORMATKNOWN, and installed in
// CACHEID_NATIVE. If anything else, the format is unknown, and
// the native cache node is made empty. There is no effect, if the
// presentation is COLECACHE_STATIC.
//
// Arguments:
// [pstg] -- pointer to storage where the object can be found
//
// Notes:
//
// History:
//
//-----------------------------------------------------------------------------
INTERNAL_(void) COleCache::FindObjectFormat(LPSTORAGE pstg)
{
VDATEHEAP();
CLIPFORMAT cf;
CALLHOOKOBJECT(S_OK,CLSID_NULL,IID_IStorage,(IUnknown **)&pstg);
if (m_uFlag & COLECACHEF_STATIC)
return;
if (IsEqualCLSID(m_clsid, CLSID_PBrush) || m_fUsedToBePBrush)
cf = CF_DIB;
else if (IsEqualCLSID(m_clsid, CLSID_MSDraw))
cf = CF_METAFILEPICT;
else
{
if (!pstg)
return;
if (FAILED(ReadFmtUserTypeStg(pstg, &cf, NULL)))
cf = 0;
}
if (m_cfFormat == cf)
return;
if (cf == CF_METAFILEPICT || cf == CF_DIB || cf == CF_ENHMETAFILE)
{
DeleteCacheNodeForNative();
m_cfFormat = cf;
AddCacheNodeForNative();
m_uFlag |= COLECACHEF_FORMATKNOWN;
}
else
{
MoveCacheNodeForNative();
m_uFlag &= ~COLECACHEF_FORMATKNOWN;
}
}
// IOleCacheControl implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::OnRun, public
//
// Synopsis:
// implements IOleCacheControl::OnRun
//
// Notify the cache that the object is running; the cache will
// set up advisory connections with interested presentation nodes.
// No effect if the cache has already been notified that the object
// is running.
//
// Arguments:
// [pDataObj] -- an IDataObject interface on the running object
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 11/23/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_OnRun)
STDMETHODIMP COleCache::OnRun(IDataObject FAR* pDataObj)
{
VDATEHEAP();
VDATETHREAD(this);
DWORD dwCacheId; // used to loop through the cache nodes
LPCACHENODE lpCacheNode; // points to the current cache node
M_PROLOG(this);
VDATEIFACE(pDataObj);
// if we already have the data object, nothing more to do
if (m_pDataObject)
return NOERROR;
m_pDataObject = pDataObj; // NOTE: no ref count
// Notify all the cache nodes that the object is RUN, so that they can
// set up the advise connections with it.
for(dwCacheId = CACHEID_GETNEXT_GETALL;
lpCacheNode = GetNext(&dwCacheId);)
lpCacheNode->OnRun(pDataObj);
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::OnStop, public
//
// Synopsis:
// implements IOleCacheControl::OnStop
//
// Informs the cache that the object (whose IDataObject is
// in m_pDataObject) has stopped. Advisory connections to the
// object are torn down. No effect if the cache has already
// been notified that the object has stopped.
//
// Arguments:
// none
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 11/23/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_OnStop)
STDMETHODIMP COleCache::OnStop(void)
{
VDATEHEAP();
VDATETHREAD(this);
DWORD dwCacheId; // used to loop through the cache nodes
LPCACHENODE lpCacheNode; // points to the current cache node
M_PROLOG(this);
// if there's no data object, there's nothing to do
if (!m_pDataObject)
return(NOERROR);
for(dwCacheId = CACHEID_GETNEXT_GETALL;
lpCacheNode = GetNext(&dwCacheId);)
lpCacheNode->OnStop();
m_pDataObject = NULL; // NOTE: no ref count
return NOERROR;
}
// IOleCache implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Cache, public
//
// Synopsis:
// implementation of IOleCache::Cache
//
// Instructs that cache to cache a rendering of this object.
//
// Arguments:
// [lpforetcIn] -- the presentation format to cache
// [advf] -- the advise control flags, from ADVF_*
// [lpdwCacheId] -- pointer to where to return the id of the
// cache node for this format
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/24/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_Cache)
STDMETHODIMP COleCache::Cache(LPFORMATETC lpforetcIn, DWORD advf,
LPDWORD lpdwCacheId)
{
VDATEHEAP();
VDATETHREAD(this);
HRESULT error;
FORMATETC foretc;
LPCACHENODE lpCacheNode = NULL;
DWORD dwDummyCacheId; // point lpdwCacheId at this to avoid testing
M_PROLOG(this);
// initialize *lpdwCacheId in case of error return, OR,
// initialize lpdwCacheId so that we needn't test it before assigning
// *lpdwCacheId in future
if (lpdwCacheId)
*lpdwCacheId = CACHEID_NATIVE; // REVIEW, not CACHEID_INVALID?
else
lpdwCacheId = &dwDummyCacheId;
// validate parameters
if (!HasValidLINDEX(lpforetcIn))
{
return(DV_E_LINDEX);
}
if (FAILED(error = VerifyAspectSingle(lpforetcIn->dwAspect)))
{
return error;
}
if (lpforetcIn->cfFormat)
{
if (FAILED(error = CheckTymedCFCombination(lpforetcIn)))
{
return error;
}
}
if (lpforetcIn->ptd)
{
VDATEPTRIN(lpforetcIn->ptd, sizeof(DVTARGETDEVICE));
}
AssertSz(m_pStg,
"Cache IStorage ptr has not been initialized by handler\n");
// copy the FORMATETC, so that we can alter it if we wish
foretc = *lpforetcIn;
if (foretc.dwAspect != DVASPECT_ICON)
{
BITMAP_TO_DIB(foretc);
if (m_uFlag & COLECACHEF_FORMATKNOWN)
{
// check to see if the new format is the same as the
// current native format
if ((error = IsSameAsObjectFormatEtc(&foretc,
m_cfFormat)) == NOERROR)
{
// if ptd is NULL then we know how to draw
// this format. Return success code, but return
// CACHEID_NATIVE for dwCacheId.
if (foretc.ptd == NULL)
{
// Locate the cache node and update the
// advise flags, if they are different
if (lpCacheNode = GetAt(&foretc, lpdwCacheId))
{
if (lpCacheNode->GetAdvf() != advf)
{
// If we are setting new advise flags,
// mark the cache as dirty
lpCacheNode->SetAdvf(advf);
m_uFlag |= COLECACHEF_DIRTY;
}
}
// We assume that we _must_ already have
// cached this format, so we must have
// found it
Assert(lpCacheNode);
return ResultFromScode(CACHE_S_SAMECACHE);
}
else if (m_uFlag & COLECACHEF_STATIC)
{
// NON-NULL ptd doesn't make any sense
// for static objects
return ResultFromScode(
DV_E_DVTARGETDEVICE);
}
}
else if (m_uFlag & COLECACHEF_STATIC)
return error;
// otherwise, if formatetc is a non-standard formatetc
// (OR) ptd is NON NULL, then we don't have choice but
// to cache it.
}
}
// check to see if we've already got this format cached
if (lpCacheNode = GetAt(&foretc, lpdwCacheId))
{
// are the advise control flags different?
if (lpCacheNode->GetAdvf() != advf)
{
// change the advise control flags; mark cache dirty
lpCacheNode->SetAdvf(advf);
m_uFlag |= COLECACHEF_DIRTY;
}
// get out, indicating this is already cached
return ResultFromScode(CACHE_S_SAMECACHE);
}
// if aspect is DVASPECT_ICON, then format has to be CF_METAFILEPICT
if (foretc.dwAspect == DVASPECT_ICON)
{
// if the format is not set, set it
if (foretc.cfFormat == NULL)
{
foretc.cfFormat = CF_METAFILEPICT;
foretc.tymed = TYMED_MFPICT;
}
else if (foretc.cfFormat != CF_METAFILEPICT)
return ResultFromScode(DV_E_FORMATETC);
}
// if this aspect is frozen, don't allow creation of the cache
if (m_dwFrozenAspects & lpforetcIn->dwAspect)
return ResultFromScode(E_FAIL);
// Create cache node for this formatetc
if (!(lpCacheNode = new FAR CCacheNode(&foretc, advf, this)))
return ReportResult(0, E_OUTOFMEMORY, 0, 0);
// Add it to the cache list
if (!(*lpdwCacheId = Attach(lpCacheNode)))
{
// if we fail to attach it, delete it and return error
lpCacheNode->Delete();
return ReportResult(0, E_OUTOFMEMORY, 0, 0);
}
// the new cache node has successfully been added, mark cache dirty
m_uFlag |= COLECACHEF_DIRTY;
// try to create the presentation object
if ((error = lpCacheNode->CreatePresObject(m_pDataObject,
FALSE /*fConvert*/)) == NOERROR)
{
// presentation object is created, let the cachenode setup
// advise connections with the server object.
lpCacheNode->OnRun(m_pDataObject);
}
// CreatePresObject can fail to create the presentation object because
// of one of the following reasons.
// 1. The server object doesn't support the format
// 2. The object is not running and the lpformatetc->cfFormat == NULL.
//
// If the object is running and cfFormat is NULL, then the method
// CreatePresObject queries the object to check whether it supports
// one of CF_ENHMETAFILE, CF_METAFILEPICT, CF_DIB and CF_BITMAP in that
// order. And only if the obejct supports one of those formats does it
// create the presentation object, othewise it will be case 1.
//
// Whether the presentation object is created or not, the cachenode will
// not be removed. It is the responsibility of the caller to do Uncache
// if the presentation object is not created (which would be conveyed
// through a special error code.)
// Do the special handling for icon here. If the object is not able to
// render ICON with CF_METAFILEPICT format, then we will go ahead and
// render it ourselves, by getting the ICON from registration data base.
if (foretc.dwAspect == DVASPECT_ICON &&
!IsEqualCLSID(m_clsid, CLSID_NULL))
{
LPOLEPRESOBJECT lpPresObj; // presentation obj, if there is one
STGMEDIUM stgmed;
// if we failed to create the presentation object, as above,
// error code is already set
if (!(lpPresObj = lpCacheNode->GetPresObj()))
goto errRtn;
// Don't bother if it has already been rendered
if (!lpPresObj->IsBlank())
return NOERROR;
// lookup the icon
if (UtGetIconData(NULL/*lpSrcDataObj*/, m_clsid,
&foretc, &stgmed) == NOERROR)
{
if (lpCacheNode->SetData(&foretc, &stgmed, TRUE) !=
NOERROR)
ReleaseStgMedium(&stgmed);
}
}
// If we don't already have an error condition, check to see if this
// a format we cannot draw.
if (S_OK == error && lpforetcIn->cfFormat)
{
error = CheckTymedCFCombination(&foretc);
}
errRtn:
return(error);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Uncache, public
//
// Synopsis:
// implements IOleCache::Uncache
//
// instructs the cache that the indicated cache node is no longer
// needed and should be deleted
//
// Arguments:
// [dwCacheId] -- the id of the cache node to delete
//
// Returns:
// OLE_E_NOCONNECTION, if [dwCacheId] is invalid
// S_OK
//
// Notes:
// Internally, CACHEID_NATIVE is valid for COLECACHEF_FORMATKNOWN,
// but this cache id is never passed outside. This cache node
// is maintained automatically without any user knowledge of it.
// Outside the cache, CACHEID_NATIVE is invalid. If this value
// is passed in, we have to check to see if we have such a node,
// and if we do, ignore it.
// REVIEW, why don't we return OLE_E_NOCONNECTION here?
//
// History:
// 11/24/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_Uncache)
STDMETHODIMP COleCache::Uncache(DWORD dwCacheId)
{
VDATEHEAP();
VDATETHREAD(this);
LPCACHENODE lpCacheNode; // the cache node dwCacheId identifies
M_PROLOG(this);
// if the cache id is for the native format node, then this node is
// not known about externally, and this is merely an invalid cache node
// id that was handed back from Cache().
if (dwCacheId == CACHEID_NATIVE)
{
if (m_uFlag & COLECACHEF_FORMATKNOWN)
return NOERROR;
}
else
{
// remove cachenode from the cache list and then call its
// delete method
if (lpCacheNode = Detach(dwCacheId))
{
lpCacheNode->Delete();
m_uFlag |= COLECACHEF_DIRTY;
return NOERROR;
}
}
// if we got here, [dwCachdId] was invalid
return ResultFromScode(OLE_E_NOCONNECTION);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::EnumCache, public
//
// Synopsis:
// implements IOleCache::EnumCache
//
// returns an enumerator that can be used to tell what is in the
// cache
//
// Arguments:
// [ppenum] -- a pointer to where to return the pointer to the
// enumerator
//
// Returns:
// E_OUTOFMEMORY, S_OK
//
// Notes:
//
// History:
// 11/24/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_EnumCache)
STDMETHODIMP COleCache::EnumCache(LPENUMSTATDATA FAR* ppenum)
{
VDATEHEAP();
VDATETHREAD(this);
M_PROLOG(this);
if (!(*ppenum = (LPENUMSTATDATA) new CCacheEnum(this, (DWORD) DEF_LINDEX,
FALSE)))
return ReportResult(0, E_OUTOFMEMORY, 0, 0);
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::InitCache, public
//
// Synopsis:
// implements IOleCache::InitCache
//
// initializes all cache nodes with the given data object
//
// Arguments:
// [lpSrcDataObj] -- pointer to the source data object
//
// Returns:
// E_INVALIDARG, if [lpSrcDataObj] is NULL
// same as IOleCache2::UpdateCache
//
// Notes:
//
// History:
// 11/24/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_InitCache)
STDMETHODIMP COleCache::InitCache(LPDATAOBJECT lpSrcDataObj)
{
VDATEHEAP();
VDATETHREAD(this);
M_PROLOG(this);
// make sure there's a data object
if (!lpSrcDataObj)
return ResultFromScode(E_INVALIDARG);
// scan the cache list and update all the cache nodes. It is possible
// that for some cache nodes the presentation objects get created as
// part of the update process. As explained in IOleCache
return UpdateCache(lpSrcDataObj, UPDFCACHE_ALLBUTNODATACACHE,
NULL /* reserved */);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::SetData, public
//
// Synopsis:
// implements IOleCache::SetData
//
// puts data into the cache node which matches the given
// FORMATETC
//
// Arguments:
// [pformatetc] -- the format the data is in
// [pmedium] -- the storage medium for the new data
// [fRelease] -- indicates whether to release the storage
// after the data is examined
//
// Returns:
// HRESULT
//
// Notes:
// If the data is for a static object, it is written out to
// disk to the contents stream.
//
// History:
// 11/24/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_SetData)
STDMETHODIMP COleCache::SetData(LPFORMATETC pformatetc, LPSTGMEDIUM pmedium,
BOOL fRelease)
{
VDATEHEAP();
VDATETHREAD(this);
LPCACHENODE lpCacheNode; // pointer to the matching cache node
CLIPFORMAT cfFormat; // local copy of (transmuted) format
M_PROLOG(this);
VERIFY_TYMED_SINGLE_VALID_FOR_CLIPFORMAT(pformatetc)
// if the object, is static, and we don't already have it,
// write it out to the contents stream
if (m_uFlag & COLECACHEF_STATIC)
{
HRESULT error;
FORMATETC foretc;
STGMEDIUM stgmed;
if (pformatetc->dwAspect == DVASPECT_ICON)
goto LOther;
foretc = *pformatetc;
if (error = IsSameAsObjectFormatEtc(&foretc, m_cfFormat))
return error;
if (foretc.ptd)
return ResultFromScode(DV_E_DVTARGETDEVICE);
if (!(lpCacheNode = AddCacheNodeForNative()))
return ResultFromScode(E_OUTOFMEMORY);
if (error = lpCacheNode->SetData(pformatetc, pmedium, fRelease))
return error;
// write data into "CONTENTS" stream
if (error = OpenOrCreateStream(m_pStg,
OLE_CONTENTS_STREAM, &stgmed.pstm))
return error;
stgmed.pUnkForRelease = NULL;
stgmed.tymed = TYMED_ISTREAM;
foretc.tymed = TYMED_ISTREAM;
error = (lpCacheNode->GetPresObj())->GetDataHere(&foretc,
&stgmed);
stgmed.pstm->Release();
return error;
}
LOther:
// if its CF_BITMAP, keep CF_DIB instead
cfFormat = ((pformatetc->cfFormat == CF_BITMAP) ?
CF_DIB : pformatetc->cfFormat);
// find the cache node for the requested data, if there is one
if (!(lpCacheNode = GetAt(pformatetc->dwAspect,
pformatetc->lindex, cfFormat, pformatetc->ptd,
NULL /*lpdwCacheId*/)))
return ResultFromScode(OLE_E_BLANK);
// set the data in that cache node
return lpCacheNode->SetData(pformatetc, pmedium, fRelease);
}
// IOleCache2 implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::UpdateCache, public
//
// Synopsis:
// implements IOleCache2::UpdateCache
//
// Updates all cache entries with the data object passed in, if
// it is not NULL. If NULL, uses the already-known about data
// object that is kept inside if the object is running.
//
// Arguments:
// [pDataObjIn] -- The data object to get data from, or NULL
// [grfUpdf] -- update control flags
// [pReserved] -- must be NULL
//
// Returns:
// HRESULT
//
// Notes:
// The native cache node is updated on disk, only if its
// COLECACHEF_PBRUSHORMSDRAW
// REVIEW, what about other native format objects?
//
// History:
// 11/24/93 - ChrisWe - file cleanup and inspection
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_UpdateCache)
STDMETHODIMP COleCache::UpdateCache(LPDATAOBJECT pDataObjIn, DWORD grfUpdf,
LPVOID pReserved)
{
VDATEHEAP();
VDATETHREAD(this);
LPDATAOBJECT pDataObject; // the data object to use for the update
DWORD dwCacheId; // cache id of current node being examined
ULONG cntUpdatedNodes; // count of nodes that were updated without error
ULONG cntTotalNodes;
LPCACHENODE lpCacheNode; // the cache node currently being updated
M_PROLOG(this);
if (pReserved != NULL)
AssertSz(FALSE, "Non-NULL reserved parameter passed to OleCache::UpdateCache");
// validate the data object, if one is passed in; if there isn't one,
// use the current one for the cache, if there is one
if (pDataObjIn)
{
VDATEIFACE(pDataObjIn);
pDataObject = pDataObjIn;
}
else if (!(pDataObject = m_pDataObject))
{
return ResultFromScode(OLE_E_NOTRUNNING);
}
// if no caches, then there is nothing to update.
if (m_uCacheNodeCnt == 0)
return NOERROR;
// Do special handling for PaintBrush or MSDraw objects.
if (m_uFlag & COLECACHEF_PBRUSHORMSDRAW)
UpdateCacheNodeForNative();
// Ask the cache nodes to update themselves from this data object
// pointer.
for(cntUpdatedNodes = 0, dwCacheId = CACHEID_GETNEXT_GETALLBUTNATIVE,
cntTotalNodes = 0;
lpCacheNode = GetNext(&dwCacheId);)
{
cntTotalNodes++;
if (lpCacheNode->Update(pDataObject, grfUpdf) == NOERROR)
{
cntUpdatedNodes++;
}
}
// it's OK to have zero nodes and zero updates (PBrush will
// have this in particular
if( cntUpdatedNodes == cntTotalNodes )
{
return NOERROR;
}
if (cntUpdatedNodes == 0)
return ReportResult(0, CACHE_E_NOCACHE_UPDATED, 0, 0);
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::DiscardCache, public
//
// Synopsis:
// implements IOleCache2::DiscardCache
//
// Instructs the cache that its contents should be discarded;
// the contents are optionally saved to disk before discarding.
//
// Arguments:
// [dwDiscardOpt] -- discard option from DISCARDCACHE_*
//
// Returns:
// HRESULT
//
// Notes:
// This maintains the dirty state of the cache, even if it is
// saved.
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
STDMETHODIMP COleCache::DiscardCache(DWORD dwDiscardOpt)
{
VDATEHEAP();
VDATETHREAD(this);
HRESULT error; // error state so far
COLECACHEFLAG uDirty = m_uFlag & COLECACHEF_DIRTY;
// remember state of the dirty flag
if (dwDiscardOpt == DISCARDCACHE_SAVEIFDIRTY)
{
// if the contents are dirty, try to save to disk
if (uDirty)
{
if (m_pStg == NULL)
return ResultFromScode(OLE_E_NOSTORAGE);
if (FAILED(error = Save(m_pStg,
TRUE /* fSameAsLoad */)))
return error;
}
// continue and do SaveCompleted which will discard the cached
// presentations from memory
goto LNoSave;
}
// if any option other than NOSAVE was specified, we shouldn't have
// gotten here
AssertSz(dwDiscardOpt == DISCARDCACHE_NOSAVE,
"Invalid DiscardCache option");
if (dwDiscardOpt != DISCARDCACHE_NOSAVE)
return ResultFromScode(E_INVALIDARG);
LNoSave:
m_uFlag |= COLECACHEF_NOSCRIBBLEMODE | COLECACHEF_SAMEASLOAD;
wSaveCompleted(NULL, TRUE /*fDiscardDrawCacheAlso*/);
// restore the dirty state, since Save() will have cleared it
// REVIEW, why, since it's not dirty anymore?
m_uFlag |= uDirty;
return NOERROR;
}
// private IUnknown implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheUnkImpl::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// This provides the private IUnknown implementation when
// COleCache is aggregated
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheUnkImpl_QueryInterface)
STDMETHODIMP NC(COleCache, CCacheUnkImpl)::QueryInterface(REFIID iid,
LPVOID FAR* ppv)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_UnkPrivate);
M_PROLOG(pOleCache);
VDATEPTROUT(ppv, LPVOID);
if (IsEqualIID(iid, IID_IUnknown) ||
IsEqualIID(iid, IID_IOleCache) ||
IsEqualIID(iid, IID_IOleCache2))
*ppv = (void FAR *)(IOleCache2 FAR *)pOleCache;
else if (IsEqualIID(iid, IID_IDataObject))
*ppv = (void FAR *)(IDataObject FAR *)&pOleCache->m_Data;
else if (IsEqualIID(iid, IID_IViewObject) ||
IsEqualIID(iid, IID_IViewObject2))
*ppv = (void FAR *)(IViewObject2 FAR *)&pOleCache->m_View;
else if (IsEqualIID(iid, IID_IPersist) ||
IsEqualIID(iid, IID_IPersistStorage))
*ppv = (void FAR *)(IPersistStorage FAR *)pOleCache;
else if (IsEqualIID(iid, IID_IOleCacheControl))
*ppv = (void FAR *)(IOleCacheControl FAR *)pOleCache;
else
{
*ppv = NULL;
return ReportResult(0, E_NOINTERFACE, 0, 0);
}
pOleCache->m_pUnkOuter->AddRef();
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheUnkImpl::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// This is part of the private IUnknown implementation of
// COleCache used when COleCache is aggregated
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheUnkImpl_AddRef)
STDMETHODIMP_(ULONG) NC(COleCache, CCacheUnkImpl)::AddRef(void)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_UnkPrivate);
LEDebugOut((DEB_TRACE, "%p _IN COleCache::CCacheUnkImpl::AddRef "
"( )\n", this ));
M_PROLOG(pOleCache);
++pOleCache->m_refs;
LEDebugOut((DEB_TRACE, "%p OUT COleCache::CCacheUnkImpl::AddRef "
"( %lu )\n", this, pOleCache->m_refs));
return pOleCache->m_refs;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheUnkImpl::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// This is part of the private IUnknown implementation of
// COleCache used when COleCache is aggregated
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheUnkImpl_Release)
STDMETHODIMP_(ULONG) NC(COleCache, CCacheUnkImpl)::Release(void)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_UnkPrivate);
ULONG uRefs; // the reference count after decrementing
M_PROLOG(pOleCache);
LEDebugOut((DEB_TRACE, "%p _IN COleCache::CCacheUnkImpl::Release "
"( )\n", this ));
if ((uRefs = --pOleCache->m_refs) == 0)
{
delete pOleCache;
}
LEDebugOut((DEB_TRACE, "%p OUT COleCache::CCacheUnkImpl::Release "
"( %lu )\n", this, uRefs));
return uRefs; // m_refs reference is no longer valid if it was zero
}
// IDataObject implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_QueryInterface)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::QueryInterface(REFIID riid,
LPVOID FAR* ppvObj)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
return pOleCache->m_pUnkOuter->QueryInterface(riid, ppvObj);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_AddRef)
STDMETHODIMP_(ULONG) NC(COleCache,CCacheDataImpl)::AddRef (void)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
return pOleCache->m_pUnkOuter->AddRef();
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_Release)
STDMETHODIMP_(ULONG) NC(COleCache,CCacheDataImpl)::Release (void)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
return pOleCache->m_pUnkOuter->Release();
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::GetData, public
//
// Synopsis:
// implements IDataObject::GetData
//
// Arguments:
// [pforetcIn] -- the format the requestor would like the data in
// [pmedium] -- where to return the storage medium to the caller
//
// Returns:
// OLE_E_BLANK, if the cache is empty
// REVIEW, anything COleCache::GetPresObj returns
// REVIEW, anything returned by presObj->GetData
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_GetData)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::GetData(LPFORMATETC pforetcIn,
LPSTGMEDIUM pmedium)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
LPOLEPRESOBJECT lpPresObj; // the presentation object with
// the requested data in it
M_PROLOG(pOleCache);
// if the cache is empty, return with nothing
if (!pOleCache->m_uCacheNodeCnt)
return ResultFromScode(OLE_E_BLANK);
Verify(pmedium);
Verify(pforetcIn);
// null out in case of error
pmedium->tymed = TYMED_NULL;
pmedium->pUnkForRelease = NULL;
VERIFY_ASPECT_SINGLE(pforetcIn->dwAspect);
// if no presentation object in the cache that matches the requested
// format, return blank
if (!(lpPresObj = pOleCache->GetPresObj(pforetcIn->dwAspect,
pforetcIn->lindex, pforetcIn->cfFormat,
pforetcIn->ptd, NULL)))
return(ResultFromScode(OLE_E_BLANK));
// if we got here, we have a presentation object that matches the
// requested format; return data from it
return(lpPresObj->GetData(pforetcIn, pmedium));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::GetDataHere, public
//
// Synopsis:
// implements IDataObject::GetDataHere
//
// Arguments:
// [pforetcIn] -- the format the requestor would like the data in
// [pmedium] -- where to return the storage medium to the caller
//
// Returns:
// OLE_E_BLANK, if the cache is empty
// REVIEW, anything COleCache::GetPresObj returns
// REVIEW, anything returned by presObj->GetData
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_GetDataHere)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::GetDataHere(LPFORMATETC pforetcIn,
LPSTGMEDIUM pmedium)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
LPOLEPRESOBJECT lpPresObj; // the presentation object with the
// requested data in it
M_PROLOG(pOleCache);
// if the cache is empty, return with nothing
if (!pOleCache->m_uCacheNodeCnt);
return ResultFromScode(OLE_E_BLANK);
VERIFY_TYMED_SINGLE(pforetcIn->tymed);
VERIFY_ASPECT_SINGLE(pforetcIn->dwAspect);
// TYMED_MFPICT, TYMED_GDI will not be allowed
if ((pforetcIn->tymed == TYMED_MFPICT)
|| (pforetcIn->tymed == TYMED_GDI)
|| (pmedium->tymed != pforetcIn->tymed))
return ReportResult(0, DV_E_TYMED, 0, 0);
// Get data from cache node, if one exists
if (!(lpPresObj = pOleCache->GetPresObj(pforetcIn->dwAspect,
pforetcIn->lindex, pforetcIn->cfFormat,
pforetcIn->ptd, NULL)))
return ResultFromScode(OLE_E_BLANK);
// ask the presentation object for the data
return lpPresObj->GetDataHere(pforetcIn, pmedium);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::QueryGetData, public
//
// Synopsis:
// implements IDataObject::QueryGetData
//
// Arguments:
// [pforetcIn] -- the format to check for
//
// Returns:
// S_FALSE, if data is not available in the requested format
// S_OK otherwise
//
// Notes:
// We will say that the formatetc is supported only if there is
// a cache and a presentation data in that cache for that
// formatetc.
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_QueryGetData)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::QueryGetData(LPFORMATETC pforetcIn)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
LPOLEPRESOBJECT lpPresObj; // the presentation object with the
// requested data in it
M_PROLOG(pOleCache);
// if the cache is empty, return with nothing
if (!pOleCache->m_uCacheNodeCnt)
{
return ResultFromScode(S_FALSE);
}
VERIFY_TYMED_VALID_FOR_CLIPFORMAT(pforetcIn);
// if the cachenode for this formatetc and the presentation object for
// the cachenode exists then query will succeed
if (lpPresObj = pOleCache->GetPresObj(pforetcIn->dwAspect,
pforetcIn->lindex, pforetcIn->cfFormat,
pforetcIn->ptd, NULL))
{
return NOERROR;
}
return ResultFromScode(S_FALSE);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::GetCanonicalFormatEtc, public
//
// Synopsis:
// implements IDataObject::GetCanonicalFormatEtc
//
// Arguments:
// [pformatetc] --
// [pformatetcOut] --
//
// Returns:
//
// Notes:
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_GetCanonicalFormatEtc)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::GetCanonicalFormatEtc(
LPFORMATETC pformatetc, LPFORMATETC pformatetcOut)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
M_PROLOG(pOleCache);
// REVIEW: code need to be added
return ReportResult(0, E_NOTIMPL, 0, 0); // just not implemented
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::SetData, public
//
// Synopsis:
// implements IDataObject::SetData
//
// Arguments:
// [pformatetc] -- the format the data is in
// [pmedium] -- the storage medium the data is on
// [fRelease] -- release storage medium after data is copied
//
// Returns:
// REVIEW, anything IOleCache::SetData can return
//
// Notes:
// Does the same thing as IOleCache::SetData
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_SetData)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::SetData(LPFORMATETC pformatetc,
LPSTGMEDIUM pmedium, BOOL fRelease)
{
VDATEHEAP();
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
VERIFY_TYMED_SINGLE_VALID_FOR_CLIPFORMAT(pformatetc);
return pOleCache->SetData(pformatetc, pmedium, fRelease);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::EnumFormatEtc, public
//
// Synopsis:
// implements IDataObject::EnumFormatEtc
//
// Arguments:
// [dwDirection] -- which way to run the enumerator
// [ppenumFormatEtc] -- pointer to where to put the enumerator
//
// Returns:
// E_OUTOFMEMORY, S_OK
//
// Notes:
//
// History:
// 02/10/94 - ChrisWe - added implementation
// 11/10/93 - ChrisWe - set returned pointer to NULL
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_EnumFormatEtc)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::EnumFormatEtc(DWORD dwDirection,
LPENUMFORMATETC FAR* ppenumFormatEtc)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_Data);
IEnumSTATDATA FAR *pIES;
HRESULT hr;
VDATEHEAP();
VDATEPTROUT(ppenumFormatEtc, LPENUMFORMATETC);
// initialize for error return
*ppenumFormatEtc = NULL;
// check that only an enumeration for retrieval is required
if ((dwDirection | DATADIR_GET) != DATADIR_GET)
return(ReportResult(0, E_NOTIMPL, 0, 0));
hr = pOleCache->EnumCache(&pIES);
if (!SUCCEEDED(hr))
return(hr);
*ppenumFormatEtc = (IEnumFORMATETC FAR *)new CCacheEnumFormatEtc(pIES);
pIES->Release();
if (!*ppenumFormatEtc)
return(ReportResult(0, E_OUTOFMEMORY, 0, 0));
return(S_OK);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::DAdvise, public
//
// Synopsis:
// implements IDataObject::DAdvise
//
// Arguments:
// [pforetc] -- the data format the advise sink is interested in
// [advf] -- advise control flags from ADVF_*
// [pAdvSink] -- the advise sink
// [pdwConnection] -- pointer to where to return the connection id
//
// Returns:
// OLE_E_ADVISENOTSUPPORTED
//
// Notes:
// Defhndlr and deflink never call the following three methods. Even for App
// handlers which make use our cache implementation this is not necessary. So,
// I am making it return error.
//
// History:
// 11/10/93 - ChrisWe - set returned connection id to 0
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_DAdvise)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::DAdvise(LPFORMATETC pforetc,
DWORD advf, IAdviseSink FAR* pAdvSink, DWORD FAR* pdwConnection)
{
VDATEHEAP();
*pdwConnection = 0;
return(ReportResult(0, OLE_E_ADVISENOTSUPPORTED, 0, 0));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::DUnadvise, public
//
// Synopsis:
// implements IDataObject::DUnadvise
//
// Arguments:
// [dwConnection] -- the connection id
//
// Returns:
// OLE_E_NOCONNECTION
//
// Notes:
// See COleCache::CCacheDataImpl::DAdvise
//
// History:
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_DUnadvise)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::DUnadvise(DWORD dwConnection)
{
VDATEHEAP();
return(ReportResult(0, OLE_E_NOCONNECTION, 0, 0));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheDataImpl::EnumDAdvise, public
//
// Synopsis:
// implements IDataObject::EnumDAdvise
//
// Arguments:
// [ppenumDAdvise] -- pointer to where to return the enumerator
//
// Returns:
// OLE_E_ADVISENOTSUPPORTED
//
// Notes:
// See COleCache::CCacheDataImpl::DAdvise
//
// History:
// 11/10/93 - ChrisWe - set returned enumerator pointer to 0
// 11/10/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheDataImpl_EnumDAdvise)
STDMETHODIMP NC(COleCache,CCacheDataImpl)::EnumDAdvise(
LPENUMSTATDATA FAR* ppenumDAdvise)
{
VDATEHEAP();
*ppenumDAdvise = NULL;
return(ReportResult(0, OLE_E_ADVISENOTSUPPORTED, 0, 0));
}
// IViewObject implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/10/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_QueryInterface)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::QueryInterface(REFIID riid,
LPVOID FAR* ppvObj)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
return pOleCache->m_pUnkOuter->QueryInterface(riid, ppvObj);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/10/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_AddRef)
STDMETHODIMP_(ULONG) NC(COleCache,CCacheViewImpl)::AddRef(void)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
//
// VDATETHREAD contains a 'return HRESULT' but this procedure expects to
// return a ULONG. Avoid the warning.
#if ( _MSC_VER >= 800 )
#pragma warning( disable : 4245 )
#endif
VDATETHREAD(pOleCache);
#if ( _MSC_VER >= 800 )
#pragma warning( default: 4245 )
#endif
return pOleCache->m_pUnkOuter->AddRef();
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/10/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_Release)
STDMETHODIMP_(ULONG) NC(COleCache,CCacheViewImpl)::Release(void)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
//
// VDATETHREAD contains a 'return HRESULT' but this procedure expects to
// return a ULONG. Avoid the warning.
#if ( _MSC_VER >= 800 )
#pragma warning( disable : 4245 )
#endif
VDATETHREAD(pOleCache);
#if ( _MSC_VER >= 800 )
#pragma warning( default : 4245 )
#endif
return pOleCache->m_pUnkOuter->Release();
}
#ifdef _CHICAGO_
//+---------------------------------------------------------------------------
//
// Method: static COleCache::DrawStackSwitch
//
// Synopsis: needed for stack switching
//
// Arguments: [pCV] --
// [dwDrawAspect] --
// [lindex] --
// [pvAspect] --
// [ptd] --
// [hicTargetDev] --
// [hdcDraw] --
// [lprcBounds] --
// [lprcWBounds] --
// [pfnContinue] --
// [DWORD] --
// [DWORD] --
// [dwContinue] --
//
// Returns:
//
// History: 5-25-95 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
INTERNAL COleCache::DrawStackSwitch(
LPVOID *pCV,
DWORD dwDrawAspect,
LONG lindex, void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
HDC hicTargetDev, HDC hdcDraw,
LPCRECTL lprcBounds,
LPCRECTL lprcWBounds,
BOOL (CALLBACK * pfnContinue)(DWORD),
DWORD dwContinue)
{
HRESULT hres = NOERROR;
StackDebugOut((DEB_STCKSWTCH, "COleCache::DrawStackSwitch 32->16 : pCV(%x)n", pCV));
hres = ((CCacheViewImpl *)pCV)->SSDraw(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, hdcDraw,
lprcBounds, lprcWBounds, pfnContinue, dwContinue);
StackDebugOut((DEB_STCKSWTCH, "COleCache::DrawStackSwitch 32<-16 back; hres:%ld\n", hres));
return hres;
}
#endif // _CHICAGO_
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::Draw, public
//
// Synopsis:
// implements IViewObject::Draw
//
// Arguments:
// [dwDrawAspect] -- a value from the DVASPECT_* enumeration
// [lindex] -- indicates what piece of the object is of
// interest; legal values vary with dwDrawAspect
// [pvAspect] -- currently NULL
// [ptd] -- the target device
// [hicTargetDev] -- in information context for [ptd]
// [hdcDraw] -- device context on which drawing is to be done
// [lprcBounds] -- boundaries of drawing on [hdcDraw]
// [lprcWBounds] -- if hdcDraw is a meta-file, it's boundaries
// [pfnContinue] --a callback function that the drawer should call
// periodically to see if rendering should be aborted.
// [dwContinue] -- passed on into [pfnContinue]
//
// Returns:
// OLE_E_BLANK, if no presentation object can be found
// REVIEW, anything from IOlePresObj::Draw
//
// Notes:
// This finds the presentation object in the cache for
// the requested format, if there is one, and then passes
// on the call to its Draw method.
//
// The use of a callback function as a parameter means that
// this interface cannot be remoted, unless some custom
// proxy is built, allowing the function to be called back in its
// original context; the interface is defined as
// [local] in common\types
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_Draw)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::Draw(
DWORD dwDrawAspect,
LONG lindex, void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
HDC hicTargetDev, HDC hdcDraw,
LPCRECTL lprcBounds,
LPCRECTL lprcWBounds,
BOOL (CALLBACK * pfnContinue)(DWORD),
DWORD dwContinue)
#ifdef _CHICAGO_
{
HRESULT hres;
// Note: Switch to the 16 bit stack under WIN95.
if (SSONBIGSTACK())
{
LEDebugOut((DEB_TRACE, "COleCache::DrawStackSwitch 32->16; this(%x)n", this));
hres = SSCall(44, SSF_SmallStack, (LPVOID)DrawStackSwitch, (DWORD) this,
(DWORD)dwDrawAspect, (DWORD)lindex,(DWORD) pvAspect, (DWORD)ptd, (DWORD)hicTargetDev,
(DWORD)hdcDraw, (DWORD)lprcBounds, (DWORD)lprcWBounds, (DWORD)pfnContinue, (DWORD)dwContinue);
}
else
hres = SSDraw(dwDrawAspect, lindex, pvAspect, ptd, hicTargetDev, hdcDraw,
lprcBounds, lprcWBounds, pfnContinue, dwContinue);
return hres;
}
//+---------------------------------------------------------------------------
//
// Method: SSDraw
//
// Synopsis: Called by Draw after switching to 16 bit stack
//
// Arguments: [dwDrawAspect] --
// [lindex] --
// [pvAspect] --
// [ptd] --
// [hicTargetDev] --
// [hdcDraw] --
// [lprcBounds] --
// [lprcWBounds] --
// [pfnContinue] --
// [DWORD] --
// [DWORD] --
// [dwContinue] --
//
// Returns:
//
// History: 5-25-95 JohannP (Johann Posch) Created
//
// Notes:
//
//----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_SSDraw)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::SSDraw(
DWORD dwDrawAspect,
LONG lindex, void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
HDC hicTargetDev, HDC hdcDraw,
LPCRECTL lprcBounds,
LPCRECTL lprcWBounds,
BOOL (CALLBACK * pfnContinue)(DWORD),
DWORD dwContinue)
#endif // _CHICAGO_
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
BOOL bMetaDC; // is [hdcDraw] for a metafile?
LPOLEPRESOBJECT lpPresObj; // the presentation object for the
// requested format, if there is one
M_PROLOG(pOleCache);
// validate parameters
// if (pvAspect)
// VDATEPTRIN(pvAspect, ?????);
if (ptd)
VDATEPTRIN(ptd, DVTARGETDEVICE);
if (lprcWBounds)
VDATEPTRIN(lprcWBounds, RECTL);
if( !lprcBounds )
{
return E_INVALIDARG;
}
else
{
VDATEPTRIN(lprcBounds, RECTL);
}
// we can't draw into a NULL-DC.
if( hdcDraw == NULL )
{
return E_INVALIDARG;
}
if (!IsValidLINDEX(dwDrawAspect, lindex))
{
return(DV_E_LINDEX);
}
// Get presentation object for this aspect, lindex, ptd, if there is one
if (!(lpPresObj = pOleCache->GetPresObjForDrawing(dwDrawAspect,
lindex, ptd)))
return ReportResult(0, OLE_E_BLANK, 0, 0);
// if the DC is a metafile DC then valid window bounds must be passed in
if ((bMetaDC = OleIsDcMeta(hdcDraw)) && (lprcWBounds == NULL))
return ReportResult(0, E_INVALIDARG, 0, 0);
#ifdef MAC_REVIEW
A RECT value on the MAC contains members which are 'short's'. A RECTL
uses longs, and in the code below an assumption is explicitely made
that long member values is directly comp[atible on the MAC. Naturally, this is not
the case, and the compiler will barf on this.
#endif
#ifndef WIN32 // no need to do this on WIN 32 also
// On Win 16 make sure that the coordinates are valid 16bit quantities.
RECT rcBounds;
RECT rcWBounds;
if (!(IS_SMALL_INT(lprcBounds->left) &&
IS_SMALL_INT(lprcBounds->right) &&
IS_SMALL_INT(lprcBounds->top) &&
IS_SMALL_INT(lprcBounds->bottom)))
{
AssertSz(FALSE, "Rect coordinate is not a small int");
return ReportResult(0, OLE_E_INVALIDRECT, 0, 0);
}
else
{
rcBounds.left = (int) lprcBounds->left;
rcBounds.right = (int) lprcBounds->right;
rcBounds.top = (int) lprcBounds->top;
rcBounds.bottom = (int) lprcBounds->bottom;
}
if (bMetaDC)
{
if (!(IS_SMALL_INT(lprcWBounds->left) &&
IS_SMALL_INT(lprcWBounds->right) &&
IS_SMALL_INT(lprcWBounds->top) &&
IS_SMALL_INT(lprcWBounds->bottom)))
{
AssertSz(FALSE, "Rect coordinate is not a small int");
return ReportResult(0, OLE_E_INVALIDRECT, 0, 0);
}
else
{
rcWBounds.left = (int) lprcWBounds->left;
rcWBounds.right = (int) lprcWBounds->right;
rcWBounds.top = (int) lprcWBounds->top;
rcWBounds.bottom = (int) lprcWBounds->bottom;
}
}
return(lpPresObj->Draw(pvAspect, hicTargetDev, hdcDraw,
&rcBounds, &rcWBounds, pfnContinue, dwContinue));
#else
// on MAC as well as win 32 we can use the same pointer as it is,
// 'cause rect fields are 32 bit quantities
return(lpPresObj->Draw(pvAspect, hicTargetDev, hdcDraw,
lprcBounds, lprcWBounds, pfnContinue, dwContinue));
#endif
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::GetColorSet, public
//
// Synopsis:
// implements IViewObject::GetColorSet
//
// Arguments:
// [dwDrawAspect] -- a value from the DVASPECT_* enumeration
// [lindex] -- indicates what piece of the object is of
// interest; legal values vary with dwDrawAspect
// [pvAspect] -- currently NULL
// [ptd] -- the target device
// [hicTargetDev] -- in information context for [ptd]
// [ppColorSet] -- the color set required for the requested
// rendering
//
// Returns:
// OLE_E_BLANK, if no presentation object can be found
// REVIEW, anything from IOlePresObj::Draw
//
// Notes:
// Finds a presentation object in the cache that matches the
// requested rendering, if there is one, and asks the
// presentation object for the color set.
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_GetColorSet)
STDMETHODIMP NC(COleCache, CCacheViewImpl)::GetColorSet(DWORD dwDrawAspect,
LONG lindex, void FAR* pvAspect, DVTARGETDEVICE FAR * ptd,
HDC hicTargetDev, LPLOGPALETTE FAR* ppColorSet)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
LPOLEPRESOBJECT lpPresObj;
M_PROLOG(pOleCache);
*ppColorSet = NULL;
if (!IsValidLINDEX(dwDrawAspect, lindex))
{
return(DV_E_LINDEX);
}
// Get presentation object for this aspect, lindex, ptd
if (!(lpPresObj = pOleCache->GetPresObjForDrawing(dwDrawAspect,
lindex, ptd)))
return ResultFromScode(OLE_E_BLANK);
return(lpPresObj->GetColorSet(pvAspect, hicTargetDev, ppColorSet));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl, public
//
// Synopsis:
// implements IViewObject::Freeze
//
// Arguments:
// [dwDrawAspect] -- a value from the DVASPECT_* enumeration
// [lindex] -- indicates what piece of the object is of
// interest; legal values vary with dwDrawAspect
// [pvAspect] -- currently NULL
// [pdwFreeze] -- a token that can later be used to unfreeze
// this aspects cached presentations
//
// Returns:
// OLE_E_BLANK, if no presentation is found that matches the
// requested characteristics
//
// Notes:
// The current implementation returns the ASPECT+FREEZE_CONSTANT
// as the FreezeID. At Unfreeze time we get the ASPECT by doing
// FreezeID-FREEZE_CONSTANT.
//
// REVIEW: In future where we allow lindexes other than DEF_LINDEX,
// we will have to use some other scheme for generating the
// FreezeID.
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_Freeze)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::Freeze(DWORD dwAspect,
LONG lindex, LPVOID pvAspect, DWORD FAR* pdwFreeze)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
DWORD dwDummyFreeze; // point at this if !pdwFreeze to avoid retesting
LPCACHENODE lpCacheNode; // pointer to cache node being examined
DWORD dwCacheId; // id of cache node being examined
int iCnt; // counts number of cache nodes frozen
M_PROLOG(pOleCache);
// We need to initialize this first for error returns
if (!pdwFreeze)
{
// point at a dummy, so we don't always have to pre-test
// assignments of *pdwFreeze with "if (pdwFreeze) ..."
pdwFreeze = &dwDummyFreeze;
}
else
{
// initialize for error returns
VDATEPTROUT(pdwFreeze, DWORD);
*pdwFreeze = 0;
}
// validate parameters
VERIFY_ASPECT_SINGLE(dwAspect);
if (!IsValidLINDEX(dwAspect, lindex))
{
return(DV_E_LINDEX);
}
// if (pvAspect)
// VDATEPTRIN(pvAspect , ??????)
// nothing to do if the aspect we're interested in is already frozen
if (pOleCache->m_dwFrozenAspects & dwAspect)
{
*pdwFreeze = dwAspect + FREEZE_CONSTANT;
return(ResultFromScode(VIEW_S_ALREADY_FROZEN));
}
// start searching cache at beginning
dwCacheId = CACHEID_GETNEXT_GETALL;
// no cache nodes have been frozen yet
iCnt = 0;
// freeze each cache node that matches the aspect and lindex
while(lpCacheNode = pOleCache->GetNext(dwAspect, lindex, &dwCacheId))
{
lpCacheNode->Freeze(); // REVIEW, do we have to check for error
iCnt++;
}
// if we froze any cache nodes
if (iCnt)
{
// Add this aspect to the frozen aspects list.
pOleCache->m_dwFrozenAspects |= dwAspect;
// return the freeze id
*pdwFreeze = dwAspect + FREEZE_CONSTANT;
return(NOERROR);
}
// if we got here, nothing matched the requested characteristics
return(ResultFromScode(OLE_E_BLANK));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::Unfreeze, public
//
// Synopsis:
// implements IViewObject::Unfreeze
//
// Arguments:
// [dwFreezeId] -- the id returned by Freeze() when some aspect
// was frozen earlier
//
// Returns:
// OLE_E_NOCONNECTION, if dwFreezeId is invalid
// S_OK
//
// Notes:
// See notes for Freeze().
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_Unfreeze)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::Unfreeze(DWORD dwFreezeId)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
DWORD dwAspect; // the aspect, after recovered from the dwFreezeId
LPCACHENODE lpCacheNode; // pointer to cache node being examined
DWORD dwCacheId; // id of cache node being examined
LONG lindex; // the lindex for the frozen item
HRESULT error = ResultFromScode(OLE_E_NOCONNECTION);
M_PROLOG(pOleCache);
// Get Aspect and lindex from dwFreezeId
dwAspect = dwFreezeId - FREEZE_CONSTANT;
lindex = DEF_LINDEX;
// Make sure that only one bit is set and it is <= DVASPECT_DOCPRINT
// REVIEW, we didn't check for DVASPECT_DOCPRINT when we froze!
// REVIEW, does this really check for one bit?
// REVIEW, why not use VERIFY_ASPECT_SINGLE?
// REVIEW, shouldn't error be E_INVALIDARG?
if (!(!(dwAspect & (dwAspect-1)) && (dwAspect <= DVASPECT_DOCPRINT)))
return error;
// Make sure that this aspect is frozen
// REVIEW, shouldn't we have a better error code?
if (!(pOleCache->m_dwFrozenAspects & dwAspect))
return error;
// Need to start search from the beginning
dwCacheId = CACHEID_GETNEXT_GETALL;
// unfreeze all the cache nodes that match (aspect, lindex)
while (lpCacheNode = pOleCache->GetNext(dwAspect, lindex, &dwCacheId))
if (lpCacheNode->Unfreeze() == NOERROR) // REVIEW, have to check for error?
pOleCache->m_dwFrozenAspects &= ~dwAspect; // Remove this aspect from the
// frozen aspects list only if
// the object is unfrozen
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::SetAdvise, public
//
// Synopsis:
// implements IViewObject::SetAdvise
//
// Arguments:
// [aspects] -- the aspects the sink would like to be advised of
// changes to
// [advf] -- advise control flags from ADVF_*
// [pAdvSink] -- the advise sink
//
// Returns:
// E_INVALIDARG
// S_OK
//
// Notes:
// Only one advise sink is allowed at a time. If a second one
// is registered, the first one is released.
//
// When cache nodes notify the cache that they have changed,
// if their (aspect, lindex) match those specified here,
// OnViewChange notification is sent to the sink.
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_SetAdvise)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::SetAdvise(DWORD aspects,
DWORD advf, IAdviseSink FAR* pAdvSink)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
M_PROLOG(pOleCache);
// if an advise sink is given, check it
if (pAdvSink != NULL)
VDATEIFACE(pAdvSink);
if (advf & ADVF_NODATA) // ?????
return ReportResult(0, E_INVALIDARG, 0, 0);
// REVIEW: should probably check agains ADVCACHE*
// We allow only one view advise at any given time, so Release the
// old sink.
if (pOleCache->m_pViewAdvSink != NULL)
pOleCache->m_pViewAdvSink->Release();
// Remember the new sink.
if ((pOleCache->m_pViewAdvSink = pAdvSink) != NULL) {
pAdvSink->AddRef();
// remember the control flags and requested aspect
pOleCache->m_advfView = advf;
pOleCache->m_aspectsView = aspects;
// send OnViewChange immediately if ADVF_PRIMEFIRST is done.
if (advf & ADVF_PRIMEFIRST)
pOleCache->OnChange(aspects, DEF_LINDEX,
FALSE /*fDirty*/);
}
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::GetAdvise, public
//
// Synopsis:
// implement IViewObject::GetAdvise
//
// Arguments:
// [pAspects] -- a pointer to where to return the aspects the
// current advise sink is interested in
// [pAdvf] -- a pointer to where to return the advise control
// flags for the current advise sink
// [ppAdvSink] -- a pointer to where to return a reference to
// the current advise sink
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_GetAdvise)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::GetAdvise(DWORD FAR* pAspects,
DWORD FAR* pAdvf, IAdviseSink FAR* FAR* ppAdvSink)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
VDATEHEAP();
VDATETHREAD(pOleCache);
M_PROLOG(pOleCache);
// validate the parameters
if (ppAdvSink)
{
VDATEPTROUT(ppAdvSink, IAdviseSink FAR *);
// initialize this for error returns
*ppAdvSink = NULL;
}
if (pAspects)
VDATEPTROUT(pAspects, DWORD);
if (pAdvf)
VDATEPTROUT(pAdvf, DWORD);
if (pOleCache->m_pViewAdvSink == NULL)
{
// no view advise sink registered
if (pAspects)
*pAspects = 0;
if (pAdvf)
*pAdvf = 0;
// *ppAdvSink has already been initialized above
}
else
{
if (pAspects)
*pAspects = pOleCache->m_aspectsView;
if (pAdvf)
*pAdvf = pOleCache->m_advfView;
if (ppAdvSink)
(*ppAdvSink = pOleCache->m_pViewAdvSink)->AddRef();
}
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::CCacheViewImpl::GetExtent, public
//
// Synopsis:
// implements IViewObject::GetExtent
//
// Arguments:
// [dwDrawAspect] -- the aspect for which we'd like the extent
// [lindex] -- the lindex for which we'd like the extent
// [ptd] -- pointer to the target device descriptor
// [lpsizel] -- pointer to where to return the extent
//
// Returns:
// OLE_E_BLANK, if no presentation can be found that matches
// (dwDrawAspect, lindex)
// REVIEW, anything from IOlePresObj::GetExtent
//
// Notes:
//
// History:
// 01/12/95 - t-ScottH- added VDATETHREAD( GETPPARENT...)
// 11/11/93 - ChrisWe - file inspection and cleanup
// 11/30/93 - alexgo - fixed bug with GETPPARENT usage
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_CCacheViewImpl_GetExtent)
STDMETHODIMP NC(COleCache,CCacheViewImpl)::GetExtent(DWORD dwDrawAspect,
LONG lindex, DVTARGETDEVICE FAR* ptd, LPSIZEL lpsizel)
{
COleCache FAR *pOleCache = GETPPARENT(this, COleCache, m_View);
HRESULT hr;
VDATEHEAP();
VDATETHREAD(pOleCache);
VDATEPTROUT(lpsizel, SIZEL);
LPOLEPRESOBJECT lpPresObj;
M_PROLOG(pOleCache);
// validate parameters
if (!IsValidLINDEX(dwDrawAspect, lindex))
{
return(DV_E_LINDEX);
}
if (ptd)
VDATEPTRIN(ptd, DVTARGETDEVICE);
// Get presentation object for this aspect, lindex, ptd, if there is one
if (!(lpPresObj = pOleCache->GetPresObjForDrawing(dwDrawAspect,
lindex, ptd)))
return ResultFromScode(OLE_E_BLANK);
hr = lpPresObj->GetExtent(dwDrawAspect, lpsizel);
// make sure Extents are positive
lpsizel->cx = LONG_ABS(lpsizel->cx);
lpsizel->cy = LONG_ABS(lpsizel->cy);
return hr;
}
// IPersistStorage implementation
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::GetClassID, public
//
// Synopsis:
// implements IPersist::GetClassID
//
// Arguments:
// [pClassID] -- pointer to where to return class id
//
// Returns:
// E_NOTIMPL
//
// Notes:
//
// History:
// 11/11/93 - ChrisWe - file inspection and cleanup;
// set result to CLSID_NULL
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_GetClassID)
STDMETHODIMP COleCache::GetClassID(LPCLSID pClassID)
{
VDATEHEAP();
VDATEPTROUT(pClassID, LPCLSID);
*pClassID = m_clsid;
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::IsDirty, public
//
// Synopsis:
// implements IPersistStorage::IsDirty
//
// Arguments:
// none
//
// Returns:
// S_FALSE, if the object does not need saving
// S_OK otherwise
//
// Notes:
//
// History:
// 11/11/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_IsDirty)
STDMETHODIMP COleCache::IsDirty(void)
{
VDATEHEAP();
M_PROLOG(this);
return((m_uFlag & COLECACHEF_DIRTY) ?
NOERROR : ResultFromScode(S_FALSE));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::InitNew, public
//
// Synopsis:
// implements IPersistStorage::InitNew
//
// Arguments:
// [pstg] -- the temp storage the object can use until saved
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 11/11/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_InitNew)
STDMETHODIMP COleCache::InitNew(LPSTORAGE pstg)
{
VDATEHEAP();
M_PROLOG(this);
VDATEIFACE(pstg);
if (m_pStg)
return ResultFromScode(CO_E_ALREADYINITIALIZED);
m_uFlag |= COLECACHEF_DIRTY;
(m_pStg = pstg)->AddRef();
// initialize native cachenode, if that's meaningful
FindObjectFormat(pstg);
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Load, public
//
// Synopsis:
// implements IPersistStorage::Load
//
// Arguments:
// [pstg] -- the storage to load from
//
// Returns:
// REVIEW, various Storage errors
// S_OK
//
// Notes:
// Presentations are loaded from sequentially numbered
// streams, stopping at the first one that cannot be found.
//
// History:
// 11/11/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_Load)
STDMETHODIMP COleCache::Load(LPSTORAGE pstg)
{
VDATEHEAP();
VDATETHREAD(this);
A5_PROLOG(this);
HRESULT error; // error status so far
LPSTREAM lpstream; // stream we're loading a presentation from
LPCACHENODE lpCacheNode; // cache node we're loading
int iPresStreamNum; // counts through the presentation streams
OLECHAR szName[
sizeof(OLE_PRESENTATION_STREAM)/sizeof(OLECHAR)];
// used to construct the names of presentation streams
VDATEIFACE(pstg);
// REVIEW(davepl) Does this error code really make any sense here?
if (m_pStg)
return ResultFromScode(CO_E_ALREADYINITIALIZED);
// remember the storage; we'll AddRef this later, if load is successful
m_pStg = pstg;
CLSID clsid;
error = ReadClassStg(pstg, &clsid);
if ( SUCCEEDED(error) &&
IsEqualCLSID(clsid, CLSID_PBrush))
{
m_uFlag |= COLECACHEF_PBRUSHORMSDRAW | COLECACHEF_FORMATKNOWN;
m_fUsedToBePBrush = TRUE;
}
// initialize native cachenode, if that's meaningful
FindObjectFormat(pstg);
if (m_uFlag & COLECACHEF_STATIC)
{
UINT uiStatus;
// if static object is in old format (i.e. data was written
// into the OLE_PRESENTATION_STREAM rather than the CONTENTS
// stream), then convert it to new format.
error = UtOlePresStmToContentsStm(pstg,
OLE_PRESENTATION_STREAM, TRUE, &uiStatus);
if (error != NOERROR)
{
// if CONTENTS stream doesn't exist or we are not able
// to create it, then we have a problem.
if (uiStatus & CONVERT_NODESTINATION)
goto errRtn;
// By now we know that CONTENTS stream exists.
// REVIEW, seems to me there could be other errors!
error = NOERROR;
}
// We know that the data is in the CONTENTS stream. Now let's
// make sure that it is in the proper format.
lpCacheNode = UpdateCacheNodeForNative();
if (lpCacheNode == NULL)
{
error = ResultFromScode(E_OUTOFMEMORY);
goto errRtn;
}
else if ((lpCacheNode->GetPresObj())->IsBlank())
{
// Even though CONTENTS stream existed, we are not
// able to read data from it. The stream format is
// invalid.
AssertSz(FALSE, "Format of CONTENTS stream is invalid");
error = ResultFromScode(DV_E_CLIPFORMAT);
goto errRtn;
}
}
else if (m_uFlag & COLECACHEF_FORMATKNOWN)
{
UpdateCacheNodeForNative();
}
// prepare to construct presentation stream names in szName
_xstrcpy(szName, OLE_PRESENTATION_STREAM);
// Enumerate the presentation streams and load them one after another.
// The enumeration stops the first time the attempt to open
// stream fails.
for(iPresStreamNum = 0; iPresStreamNum < OLE_MAX_PRES_STREAMS;)
{
if (error = pstg->OpenStream(szName, NULL,
(STGM_READ | STGM_SHARE_EXCLUSIVE), 0,
&lpstream))
{
// Translate stream does not exist into ok. This
// means that we don't have any more streams to read.
if (GetScode(error) == STG_E_FILENOTFOUND)
error = NOERROR;
goto errRtn;
}
// We've opened the stream. Now create a cachenode, so that
// we can ask it to load itself from the stream.
if (!(lpCacheNode = new FAR CCacheNode(this)))
{
error = ReportResult (0, E_OUTOFMEMORY, 0, 0);
goto errLoad;
}
// ask the cachenode to load itself from the stream
if (error = lpCacheNode->Load(lpstream, iPresStreamNum))
goto errLoad;
// add the cache node to the cache list
if (!Attach(lpCacheNode))
{
error = ReportResult(0, E_OUTOFMEMORY, 0, 0);
goto errLoad;
}
// release the stream
lpstream->Release();
lpstream = NULL;
// if the server object is runinng, ask the loaded cached
// node to connect to the server object
if (m_pDataObject)
lpCacheNode->OnRun(m_pDataObject);
// Get the next presentation stream name.
UtGetPresStreamName(szName, ++iPresStreamNum);
continue;
errLoad:
// something went wrong while loading the current stream
if (lpstream)
lpstream->Release();
if (lpCacheNode)
lpCacheNode->Delete();
break;
}
errRtn:
if (error != NOERROR)
{
// delete all the cache nodes that we loaded so far.
DeleteAll();
m_pStg = NULL;
}
else
{
// cache is not dirty
m_uFlag &= ~COLECACHEF_DIRTY;
// remember storage we loaded from
m_pStg->AddRef();
// if static object remove all the caches (if there
// are any) except the ICON cache.
if (m_uFlag & COLECACHEF_STATIC)
{
DWORD dwCacheId = CACHEID_GETNEXT_GETALLBUTNATIVE;
// REVIEW -- GETNEXT_GETALL
// REVIEW, if COLECACHEF_STATIC, there doesn't
// appear to be a native cache node, but I
// don't understand why
const FORMATETC FAR *lpforetc;
while (lpCacheNode = GetNext(&dwCacheId))
{
lpforetc = lpCacheNode->GetFormatEtc();
if (lpforetc->dwAspect != DVASPECT_ICON)
Uncache(dwCacheId);
}
}
}
RESTORE_A5();
return error;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Save, public
//
// Synopsis:
// implements IPersistStorage::Save
//
// Arguments:
// [pstgSave] -- the storage to use to save this
// [fSameAsLoad] -- is this the same storage we loaded from?
//
// Returns:
//
// Notes:
// All the caches are saved to streams with sequential numeric
// names. Load takes advantage of this to load until it
// can't find the next file.
//
// History:
// 11/11/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
// $$$
// Save all the caches to presentation streams numbered sequentially
#pragma SEG(COleCache_Save)
STDMETHODIMP COleCache::Save(LPSTORAGE pstgSave, BOOL fSameAsLoad)
{
VDATEHEAP();
VDATETHREAD(this);
A5_PROLOG(this);
HRESULT error = NOERROR; // error status so far
int iPresStreamNum; // the stream number to use to save
LPCACHENODE lpCacheNode; // the cache node being saved
DWORD dwCacheId; // cache id of the cache being saved
int cntCachesNotSaved;
// validate parameters
VDATEIFACE(pstgSave);
// if we're saving to the same place this was loaded from, and
// the cache isn't dirty, there's no need to rewrite everything out
if (fSameAsLoad && !(m_uFlag & COLECACHEF_DIRTY))
{
error = NOERROR;
goto errRtn;
}
// Enumerate the cache nodes and ask them to save themselves into
// presentation streams.
// REVIEW, what is this extra pass before hand about? It just
// seems to count the items to save, and do nothing more. I asked
// SriniK, and he couldn't give me an answer after looking at it.
// He's promised to add some more comments to the code after he's
// looked at it some more.
dwCacheId = CACHEID_GETNEXT_GETALLBUTNATIVE; // REVIEW GETNEXT_GETALL???
iPresStreamNum = 0;
cntCachesNotSaved = 0;
while (lpCacheNode = GetNext(&dwCacheId))
{
// Ask the cache node to save itself into this stream
error = lpCacheNode->Save(pstgSave, fSameAsLoad,
iPresStreamNum, (dwCacheId == m_dwDrawCacheId),
TRUE /* save if you have saved before */,
&cntCachesNotSaved);
if ((error != NOERROR) ||
(++iPresStreamNum >= OLE_MAX_PRES_STREAMS))
break;
}
if (fSameAsLoad && (cntCachesNotSaved != 0) && (error == NOERROR))
{
dwCacheId = CACHEID_GETNEXT_GETALLBUTNATIVE;
iPresStreamNum = 0;
while (lpCacheNode = GetNext(&dwCacheId))
{
// Ask the cache node to save itself into this stream
error = lpCacheNode->Save(pstgSave, fSameAsLoad,
iPresStreamNum,
(dwCacheId == m_dwDrawCacheId),
FALSE /* save if haven't before */,
NULL);
if ((error != NOERROR) ||
(++iPresStreamNum >=
OLE_MAX_PRES_STREAMS))
break;
}
}
// remove additional presentation streams if any exist
UtRemoveExtraOlePresStreams(pstgSave, iPresStreamNum);
errRtn:
if (error == NOERROR)
{
m_uFlag |= COLECACHEF_NOSCRIBBLEMODE;
if (fSameAsLoad)
m_uFlag |= COLECACHEF_SAMEASLOAD;
else
m_uFlag &= ~COLECACHEF_SAMEASLOAD;
}
RESTORE_A5();
return error;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::SaveCompleted, public
//
// Synopsis:
// implements IPersistStorage::SaveCompleted
//
// Arguments:
// [pstgNew] -- NULL, or a pointer to the storage that the current
// storage operations are being done to, when this is
// not the same as the storage this object was loaded
// from (pointer to a "Save as..." destination.)
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_SaveCompleted)
STDMETHODIMP COleCache::SaveCompleted(LPSTORAGE pstgNew)
{
VDATEHEAP();
VDATETHREAD(this);
M_PROLOG(this);
return wSaveCompleted(pstgNew, FALSE /*fDiscardDrawCacheAlso*/);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::wSaveCompleted, private
//
// Synopsis:
// Does work of IPersistStorage::wSaveCompleted, making a new
// storage the current one, and clearing the dirty flags on
// the cache nodes and cache if a save was done to the original
// storage the cache was loaded from.
//
// Arguments:
// [pstgNew] -- pointer to storage saving was done to, if it
// wasn't done to the original source location.
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
INTERNAL COleCache::wSaveCompleted(LPSTORAGE pstgNew,
BOOL fDiscardDrawCacheAlso)
{
VDATEHEAP();
if ((m_uFlag & COLECACHEF_SAMEASLOAD) || pstgNew)
{
m_uFlag &= ~COLECACHEF_SAMEASLOAD;
// if new storage, make this the current storage
// REVIEW, this means that DiscardCache() would save to this
// storage, rather than the original
if (pstgNew)
{
if (m_pStg)
m_pStg->Release();
(m_pStg = pstgNew)->AddRef();
}
if (m_uFlag & COLECACHEF_NOSCRIBBLEMODE)
{
DWORD dwCacheId;
LPCACHENODE lpCacheNode;
int iStreamNum;
// Do special handling for PaintBrush or MSDraw objects.
if (m_uFlag & COLECACHEF_PBRUSHORMSDRAW)
UpdateCacheNodeForNative();
// clear the dirty flags of all the cache nodes
for(iStreamNum = 0, dwCacheId =
CACHEID_GETNEXT_GETALLBUTNATIVE;
lpCacheNode = GetNext(&dwCacheId);
++iStreamNum)
{
lpCacheNode->SaveCompleted(iStreamNum,
(!fDiscardDrawCacheAlso &&
(dwCacheId ==
m_dwDrawCacheId)));
}
m_uFlag &= ~COLECACHEF_DIRTY;
}
}
m_uFlag &= ~COLECACHEF_NOSCRIBBLEMODE;
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::HandsOffStorage, public
//
// Synopsis:
// implements IPersistStorage::HandsOffStorage
//
// Arguments:
// none
//
// Returns:
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(COleCache_HandsOffStorage)
STDMETHODIMP COleCache::HandsOffStorage(void)
{
VDATEHEAP();
VDATETHREAD(this);
M_PROLOG(this);
// if we're holding onto storage, release it
if (m_pStg)
{
m_pStg->Release();
m_pStg = NULL;
}
return NOERROR;
}
//+-------------------------------------------------------------------------
//
// Member: COleCache::Dump, public (_DEBUG only)
//
// Synopsis: return a string containing the contents of the data members
//
// Effects:
//
// Arguments: [ppszDump] - an out pointer to a null terminated character array
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies: [ppsz] - argument
//
// Derivation:
//
// Algorithm: use dbgstream to create a string containing information on the
// content of data structures
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
HRESULT COleCache::Dump(char **ppszDump, ULONG ulFlag, int nIndentLevel)
{
int i;
unsigned int ui;
char *pszPrefix;
char *pszCThreadCheck;
char *pszCacheListItem;
char *pszCCacheEnum;
char *pszADVF;
char *pszDVASPECT;
char *pszCLSID;
char *pszClipFormat;
dbgstream dstrPrefix;
dbgstream dstrDump(3900);
// determine prefix of newlines
if ( ulFlag & DEB_VERBOSE )
{
dstrPrefix << this << " _VB ";
}
// determine indentation prefix for all newlines
for (i = 0; i < nIndentLevel; i++)
{
dstrPrefix << DUMPTAB;
}
pszPrefix = dstrPrefix.str();
// put data members in stream
pszCThreadCheck = DumpCThreadCheck((CThreadCheck *)this, ulFlag, nIndentLevel + 1);
dstrDump << pszPrefix << "CThreadCheck:" << endl;
dstrDump << pszCThreadCheck;
CoTaskMemFree(pszCThreadCheck);
// these are not included since they are just vtables (also, we would
// not get the correct values in the debugger extension for the addresses)
// dstrDump << pszPrefix << "&IUnknown = " << &m_UnkPrivate << endl;
// dstrDump << pszPrefix << "&IDataObject = " << &m_Data << endl;
// dstrDump << pszPrefix << "&IViewObject2 = " << &m_View << endl;
dstrDump << pszPrefix << "No. of References = " << m_refs << endl;
dstrDump << pszPrefix << "pIUnknown, pUnkOuter = ";
if (m_uFlag & COLECACHEF_AGGREGATED)
{
dstrDump << "AGGREGATED (" << m_pUnkOuter << ")" << endl;
}
else
{
dstrDump << "NO AGGREGATION (" << m_pUnkOuter << ")" << endl;
}
dstrDump << pszPrefix << "pIStorage = " << m_pStg << endl;
dstrDump << pszPrefix << "COleCache Flags = ";
if (m_uFlag & COLECACHEF_DIRTY)
{
dstrDump << "COLECACHEF_DIRTY ";
}
if (m_uFlag & COLECACHEF_NOSCRIBBLEMODE)
{
dstrDump << "COLECACHEF_NOSCRIBBLEMODE ";
}
if (m_uFlag & COLECACHEF_SAMEASLOAD)
{
dstrDump << "COLECACHEF_SAMEASLOAD ";
}
if (m_uFlag & COLECACHEF_PBRUSHORMSDRAW)
{
dstrDump << "COLECACHEF_PBRUSHORMSDRAW ";
}
if (m_uFlag & COLECACHEF_STATIC)
{
dstrDump << "COLECACHEF_STATIC ";
}
if (m_uFlag & COLECACHEF_FORMATKNOWN)
{
dstrDump << "COLECACHEF_FORMATKNOWN ";
}
if (m_uFlag & COLECACHEF_AGGREGATED)
{
dstrDump << "COLECACHEF_AGGREGATED ";
}
// if none of the flags are set!
if ( !( (m_uFlag & COLECACHEF_DIRTY) |
(m_uFlag & COLECACHEF_NOSCRIBBLEMODE) |
(m_uFlag & COLECACHEF_SAMEASLOAD) |
(m_uFlag & COLECACHEF_PBRUSHORMSDRAW) |
(m_uFlag & COLECACHEF_STATIC) |
(m_uFlag & COLECACHEF_FORMATKNOWN) |
(m_uFlag & COLECACHEF_AGGREGATED)))
{
dstrDump << "No FLAGS SET! ";
}
dstrDump << "(" << (void *)m_uFlag << ")" << endl;
dstrDump << pszPrefix << "Size of CacheList(max) = " << m_uCacheNodeMax << endl;
dstrDump << pszPrefix << "No. of elements in CacheList = " << m_uCacheNodeCnt << endl;
// the array could be sparse
if (m_uCacheNodeCnt != 0)
{
for (ui = 0; ui < m_uCacheNodeMax; ui++)
{
pszCacheListItem = DumpCACHELIST_ITEM(&m_pCacheList[ui], ulFlag, nIndentLevel + 1);
dstrDump << pszPrefix << "CacheList Item [" << ui << "]:" << endl;
dstrDump << pszCacheListItem;
CoTaskMemFree(pszCacheListItem);
}
}
if (m_pCacheEnum != NULL)
{
dstrDump << pszPrefix << "CCacheEnum:" << endl;
pszCCacheEnum = DumpCCacheEnum(m_pCacheEnum, ulFlag, nIndentLevel + 1);
dstrDump << pszCCacheEnum;
CoTaskMemFree(pszCCacheEnum);
}
else
{
dstrDump << pszPrefix << "CCacheEnum: = " << m_pCacheEnum << endl;
}
dstrDump << pszPrefix << "pIAdviseSink (View advise) = " << m_pViewAdvSink << endl;
pszADVF = DumpADVFFlags(m_advfView);
dstrDump << pszPrefix << "View Advise Flags = " << pszADVF << endl;
CoTaskMemFree(pszADVF);
pszDVASPECT = DumpDVASPECTFlags(m_aspectsView);
dstrDump << pszPrefix << "Aspect Flags = " << pszDVASPECT << endl;
CoTaskMemFree(pszDVASPECT);
dstrDump << pszPrefix << "Drawing Cache ID = " << m_dwDrawCacheId << endl;
dstrDump << pszPrefix << "Count of Frozen Aspects = " << m_dwFrozenAspects<< endl;
dstrDump << pszPrefix << "pIDataObject = " << m_pDataObject << endl;
pszCLSID = DumpCLSID(m_clsid);
dstrDump << pszPrefix << "CLSID = " << pszCLSID << endl;
CoTaskMemFree(pszCLSID);
pszClipFormat = DumpCLIPFORMAT(m_cfFormat);
dstrDump << pszPrefix << "Clipboard Format = " << pszClipFormat << endl;
CoTaskMemFree(pszClipFormat);
// cleanup and provide pointer to character array
*ppszDump = dstrDump.str();
if (*ppszDump == NULL)
{
*ppszDump = UtDupStringA(szDumpErrorMessage);
}
CoTaskMemFree(pszPrefix);
return NOERROR;
}
#endif // _DEBUG
//+-------------------------------------------------------------------------
//
// Function: DumpCOleCache, public (_DEBUG only)
//
// Synopsis: calls the COleCache::Dump method, takes care of errors and
// returns the zero terminated string
//
// Effects:
//
// Arguments: [pOC] - pointer to COleCache
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: character array of structure dump or error (null terminated)
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
char *DumpCOleCache(COleCache *pOC, ULONG ulFlag, int nIndentLevel)
{
HRESULT hresult;
char *pszDump;
if (pOC == NULL)
{
return UtDupStringA(szDumpBadPtr);
}
hresult = pOC->Dump(&pszDump, ulFlag, nIndentLevel);
if (hresult != NOERROR)
{
CoTaskMemFree(pszDump);
return DumpHRESULT(hresult);
}
return pszDump;
}
#endif // _DEBUG
// CCacheEnumFormatEtc implementation
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::CCacheEnumFormatEtc, public
//
// Synopsis:
// constructor
//
// sets reference count to 1
//
// Arguments:
// [pIES] -- IEnumSTATDATA enumerator that this IEnumFORMATETC
// enumerator will be based on; may be NULL
//
// Notes:
// We allow the underlying IEnumSTATDATA enumerator to be null
// for the case where an IEnumSTATDATA enumerator refuses to
// be cloned, and yet we want to clone this IEnumFORMATETC.
// When the underlying enumerator is NULL, we always return
// OLE_E_BLANK, and treat this enumerator as empty; taking the
// cache's IEnumSTATDATA as an example worthy of copying.
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_ctor)
CCacheEnumFormatEtc::CCacheEnumFormatEtc(IEnumSTATDATA FAR *pIES)
{
VDATEHEAP();
m_refs = 1;
if (m_pIES = pIES)
pIES->AddRef();
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::~CCacheEnumFormatEtc, private
//
// Synopsis:
// destructor
//
// dissociates this enumerator from the cache, if it still exists
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
CCacheEnumFormatEtc::~CCacheEnumFormatEtc()
{
VDATEHEAP();
if (m_pIES)
m_pIES->Release();
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_QueryInterface)
STDMETHODIMP CCacheEnumFormatEtc::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
VDATEHEAP();
VDATETHREAD(this);
if (IsEqualIID(riid, IID_IUnknown) ||
IsEqualIID(riid, IID_IEnumFORMATETC))
*ppv = (void FAR *)(IEnumFORMATETC FAR *)this;
else
{
*ppv = NULL;
return ReportResult(0, E_NOINTERFACE, 0, 0);
}
AddRef();
return(NOERROR);
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_AddRef)
STDMETHODIMP_(ULONG) CCacheEnumFormatEtc::AddRef(void)
{
VDATEHEAP();
return m_refs++;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_Release)
STDMETHODIMP_(ULONG) CCacheEnumFormatEtc::Release(void)
{
VDATEHEAP();
if (--m_refs == 0)
{
delete this;
return(0);
}
return m_refs;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::Next, public
//
// Synopsis:
// implements IEnumFORMATETC::Next
//
// Arguments:
// [celt] -- the number of items the caller would like returned
// [rgelt] -- a pointer to where the items may be returned as
// an array
// [pceltFetched] -- a pointer to where to place the count of
// the actual number of items returned. May be NULL
// if the caller is not interested in this number
//
// Returns:
// S_OK, if exactly the number of items requested is being
// returned
// S_FALSE, if fewer items than the number requested are being
// returned
// OLE_E_BLANK, if the ole cache associated with this
// enumerator has been destroyed
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
// 08/23/94 - Davepl - enforced enumerator count OUT param
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_Next)
STDMETHODIMP CCacheEnumFormatEtc::Next(ULONG celt, FORMATETC FAR* rgelt,
ULONG FAR* pceltFetched)
{
STATDATA sd; // used as intermediary for other enumerator
ULONG cnt; // count of number of elements fetched so far
ULONG fc; // FetchCount
HRESULT hr;
VDATEHEAP();
VDATETHREAD(this);
VDATEPTROUT(rgelt, FORMATETC);
// Enumerators require that when more than one element is being fetched,
// a valid OUT ulong is provided to indicate the count of elts returned
// 16-bit didn't enforce this, so we InWow-special-case it.
if (!IsWOWThread())
{
if ( celt > 1 && NULL == pceltFetched)
{
return E_INVALIDARG;
}
}
// if no other enumerator, can't comply
if (!m_pIES)
return(ReportResult(0, OLE_E_BLANK, 0, 0)); // REVIEW, scode
// iterate until we've fetched as many items as requested
for(cnt = 0; cnt < celt; ++rgelt, ++cnt)
{
hr = m_pIES->Next(1, &sd, &fc);
if (fc != 1)
break;
// copy the relevant information
*rgelt = sd.formatetc;
Assert(rgelt->ptd == NULL);
// release the advise sink in the STATDATA
if (sd.pAdvSink)
sd.pAdvSink->Release();
// REVIEW, as this is done here, we are using the IEnumSTATDATA
// enumerator to implement this one. The IES enumerator does
// more work than this one, namely this AddRef'ing of the
// advise sink, which might actually be remoted. We're doing
// this this way because that one already exists, and we're
// trying to disturb the code as little as possible. A
// performance optimization that can be done later on is to
// switch the code between the two enumerators, (or to factor
// out the guts of the IES one,) so that we don't do the
// extra work for this one, but only for the IES one when it
// is necessary.
}
// if a count of returned elements was requested, copy it
if (pceltFetched)
*pceltFetched = cnt;
// if we fetched as many items as requested, return
if (cnt == celt)
return NOERROR;
// zero out the unused array elements
for(; cnt < celt; ++rgelt, ++cnt)
{
rgelt->cfFormat = 0;
}
return(ReportResult(0, S_FALSE, 0, 0));
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Skip, public
//
// Synopsis:
// implements IEnumFORMATETC::Skip
//
// Arguments:
// [celt] -- count of the number of items in the enumeration to
// skip over
//
// Returns:
// OLE_E_BLANK, if the associated ole cache has been destroyed
// S_FALSE, if there were fewer items left in the enumeration
// than we were to skip
// S_OK
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_Skip)
STDMETHODIMP CCacheEnumFormatEtc::Skip(ULONG celt)
{
VDATEHEAP();
VDATETHREAD(this);
// if no other enumerator, can't comply
if (!m_pIES)
return(ReportResult(0, OLE_E_BLANK, 0, 0)); // REVIEW, scode
return(m_pIES->Skip(celt));
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::Reset, public
//
// Synopsis:
// implements IEnumFORMATETC::Reset
//
// Arguments:
// none
//
// Returns:
// OLE_E_BLANK, if the associated ole cache has been destroyed
// S_OK
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_Reset)
STDMETHODIMP CCacheEnumFormatEtc::Reset(void)
{
VDATEHEAP();
VDATETHREAD(this);
// if no other enumerator, can't comply
if (!m_pIES)
return(ReportResult(0, OLE_E_BLANK, 0, 0)); // REVIEW, scode
return(m_pIES->Reset());
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnumFormatEtc::Clone, public
//
// Synopsis:
// implements IEnumFORMATETC::Clone
//
// Arguments:
// [ppenum] -- pointer to where to return the created enumerator
//
// Returns:
// OLE_E_BLANK, if the associated cache has been destroyed;
// no enumerator is created in this case
// E_OUTOFMEMORY, S_OK
//
// Notes:
//
// History:
// 02/08/94 - ChrisWe - created
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnumFormatEtc_Clone)
STDMETHODIMP CCacheEnumFormatEtc::Clone(LPENUMFORMATETC FAR* ppenum)
{
IEnumSTATDATA FAR *pIES; // the IEnumSTATDATA to base the clone on
HRESULT hr;
VDATEHEAP();
VDATETHREAD(this);
// obtain an IEnumSTATDATA to base the cloned IEnumFORMATETC on
if (!m_pIES)
pIES = NULL;
else
hr = m_pIES->Clone(&pIES);
// create the new IEnumFORMATETC
*ppenum = new CCacheEnumFormatEtc(pIES);
// release the IEnumSTATDATA, if we've got one
if (pIES)
pIES->Release();
// if no new enumerator, we ran out of memory
if (!*ppenum)
return(ReportResult(0, E_OUTOFMEMORY, 0, 0));
return NOERROR;
}
//+-------------------------------------------------------------------------
//
// Member: CCacheEnumFormatEtc::Dump, public (_DEBUG only)
//
// Synopsis: return a string containing the contents of the data members
//
// Effects:
//
// Arguments: [ppszDump] - an out pointer to a null terminated character array
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies: [ppsz] - argument
//
// Derivation:
//
// Algorithm: use dbgstream to create a string containing information on the
// content of data structures
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
HRESULT CCacheEnumFormatEtc::Dump(char **ppszDump, ULONG ulFlag, int nIndentLevel)
{
int i;
char *pszPrefix;
char *pszCThreadCheck;
dbgstream dstrPrefix;
dbgstream dstrDump;
// determine prefix of newlines
if ( ulFlag & DEB_VERBOSE )
{
dstrPrefix << this << " _VB ";
}
// determine indentation prefix for all newlines
for (i = 0; i < nIndentLevel; i++)
{
dstrPrefix << DUMPTAB;
}
pszPrefix = dstrPrefix.str();
// put data members in stream
pszCThreadCheck = DumpCThreadCheck((CThreadCheck *)this, ulFlag, nIndentLevel + 1);
dstrDump << pszPrefix << "CThreadCheck:" << endl;
dstrDump << pszCThreadCheck;
CoTaskMemFree(pszCThreadCheck);
dstrDump << pszPrefix << "No. of References = " << m_refs << endl;
dstrDump << pszPrefix << "pIEnumSTATDATA = " << m_pIES << endl;
// cleanup and provide pointer to character array
*ppszDump = dstrDump.str();
if (*ppszDump == NULL)
{
*ppszDump = UtDupStringA(szDumpErrorMessage);
}
CoTaskMemFree(pszPrefix);
return NOERROR;
}
#endif // _DEBUG
//+-------------------------------------------------------------------------
//
// Function: DumpCCacheEnumFormatEtc, public (_DEBUG only)
//
// Synopsis: calls the CCacheEnumFormatEtc::Dump method, takes care of errors and
// returns the zero terminated string
//
// Effects:
//
// Arguments: [pCEFE] - pointer to CCacheEnumFormatEtc
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: character array of structure dump or error (null terminated)
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
char *DumpCCacheEnumFormatEtc(CCacheEnumFormatEtc *pCEFE, ULONG ulFlag, int nIndentLevel)
{
HRESULT hresult;
char *pszDump;
if (pCEFE == NULL)
{
return UtDupStringA(szDumpBadPtr);
}
hresult = pCEFE->Dump(&pszDump, ulFlag, nIndentLevel);
if (hresult != NOERROR)
{
CoTaskMemFree(pszDump);
return DumpHRESULT(hresult);
}
return pszDump;
}
#endif // _DEBUG
// CCacheEnum implementation
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::CCacheEnum, public
//
// Synopsis:
// constructor
//
// sets reference count to 1
//
// Arguments:
// [pOleCache] -- the instance of COleCache this is an
// enumerator for; may be NULL
// [dwCurrent] -- id of the item in the cache that the enumerator
// is on
// [fDib] -- act as if the last item seen is a CF_DIB cache item
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_ctor)
CCacheEnum::CCacheEnum(COleCache FAR* pOleCache, ULONG ulCurrent, BOOL fDib)
{
VDATEHEAP();
m_ulCurCacheId = ulCurrent;
m_refs = 1;
m_pOleCache = pOleCache; // remember the COleCache object pointer
// NOTE: no ref count
m_pNextCacheEnum = NULL;
m_fDib = fDib;
// if there's a cache, add this enumerator to the head of the
// enumerator list
if (pOleCache)
{
m_pNextCacheEnum = pOleCache->m_pCacheEnum;
pOleCache->m_pCacheEnum = this;
}
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::~CCacheEnum, private
//
// Synopsis:
// destructor
//
// dissociates this enumerator from the cache, if it still exists
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
CCacheEnum::~CCacheEnum()
{
VDATEHEAP();
// If there's a cache, ask it to remove us from its enumerator list
if (m_pOleCache)
m_pOleCache->DetachCacheEnum(this);
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::OnOleCacheDelete, private
//
// Synopsis:
// Indicates that the cache the enumerator was associated
// with has been destroyed. The enumerator no longer returns
// anything but error values.
//
// Arguments:
// none
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_OnOleCacheDelete)
// COleCache calls this when it is getting deleted
INTERNAL_(void) CCacheEnum::OnOleCacheDelete(void)
{
VDATEHEAP();
m_pOleCache = NULL; // NOTE: no ref count
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::QueryInterface, public
//
// Synopsis:
// implements IUnknown::QueryInterface
//
// Arguments:
// [iid] -- IID of the desired interface
// [ppv] -- pointer to where to return the requested interface
//
// Returns:
// E_NOINTERFACE, if the requested interface is not available
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_QueryInterface)
STDMETHODIMP CCacheEnum::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
VDATEHEAP();
VDATETHREAD(this);
if (IsEqualIID(riid, IID_IUnknown) ||
IsEqualIID(riid, IID_IEnumSTATDATA))
*ppv = (void FAR *)(IEnumSTATDATA FAR *)this;
else
{
*ppv = NULL;
return ReportResult(0, E_NOINTERFACE, 0, 0);
}
AddRef();
return(NOERROR);
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::AddRef, public
//
// Synopsis:
// implements IUnknown::AddRef
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_AddRef)
STDMETHODIMP_(ULONG) CCacheEnum::AddRef()
{
VDATEHEAP();
return m_refs++;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::Release, public
//
// Synopsis:
// implements IUnknown::Release
//
// Arguments:
// none
//
// Returns:
// the object's reference count
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_Release)
STDMETHODIMP_(ULONG) CCacheEnum::Release()
{
VDATEHEAP();
if (--m_refs == 0)
{
delete this;
return(0);
}
return m_refs;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::Next, public
//
// Synopsis:
// implements IEnumSTATDATA::Next
//
// Arguments:
// [celt] -- the number of items the caller would like returned
// [rgelt] -- a pointer to where the items may be returned as
// an array
// [pceltFetched] -- a pointer to where to place the count of
// the actual number of items returned. May be NULL
// if the caller is not interested in this number
//
// Returns:
// S_OK, if exactly the number of items requested is being
// returned
// S_FALSE, if fewer items than the number requested are being
// returned
// OLE_E_BLANK, if the ole cache associated with this
// enumerator has been destroyed
//
// Notes:
// Immediately after any CF_DIB item is returned, a CF_BITMAP
// item is synthesized for the same cache item, and returned next.
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup; use pointer
// aritmetic to speed array accesses
// 08/08/94 AlexT Handle case where cache node is uncached
// during enumeration
// 08/23/94 - Davepl - enforced enumerator count OUT param
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_Next)
STDMETHODIMP CCacheEnum::Next(ULONG celt, STATDATA FAR* rgelt,
ULONG FAR* pceltFetched)
{
VDATEHEAP();
VDATETHREAD(this);
// Enumerators require that when more than one element is being fetched,
// a valid OUT ulong is provided to indicate the count of elts returned
// 16-bit didn't enforce this, so we InWow-special-case it.
if (celt > 1 && NULL == pceltFetched && !IsWOWThread())
{
return E_INVALIDARG;
}
ULONG cnt; // count of number of elements fetched so far
LPCACHENODE lpCacheNode; // pointer to the current cache node
// if no cache, can't run enumerator
if (!m_pOleCache)
return ReportResult (0, OLE_E_BLANK, 0, 0); // REVIEW, scode
// iterate until we've fetched as many items as requested
cnt = 0;
while (cnt < celt)
{
if (!m_fDib)
{
// If we're here, the last returned item was NOT
// CF_DIB
// Get next valid cache node from cache node list
lpCacheNode = m_pOleCache->GetNext(&m_ulCurCacheId);
if (NULL == lpCacheNode)
{
// No more nodes to process
break;
}
// Ask the CacheNode itself for the statdata.
lpCacheNode->CopyStatData(rgelt);
// if this item is of format CF_DIB, then on the
// next iteration, return a synthesized CF_BITMAP for
// the same item
if (CF_DIB == rgelt->formatetc.cfFormat)
{
m_fDib = TRUE;
}
}
else
{
// The last item returned was a CF_DIB
// now we synthesize a CF_BITMAP item for the same
// cache item
m_fDib = FALSE;
// get the *current* cache node
lpCacheNode = m_pOleCache->GetAt(m_ulCurCacheId);
if (NULL == lpCacheNode ||
CF_DIB != lpCacheNode->GetFormatEtc()->cfFormat)
{
// The node no longer exists (or is the wrong
// type) - caller probably called Uncache, so
// we'll just get the next node
continue;
}
// Ask the CacheNode for the statdata.
lpCacheNode->CopyStatData(rgelt);
rgelt->formatetc.cfFormat = CF_BITMAP;
rgelt->formatetc.tymed = TYMED_GDI;
}
// return the connection id
rgelt->dwConnection = m_ulCurCacheId;
cnt++;
rgelt++;
}
// if a count of returned elements was requested, copy it
if (pceltFetched)
*pceltFetched = cnt;
// if we fetched as many items as requested, return
if (cnt == celt)
return NOERROR;
// zero out the unused array elements
for(; cnt < celt; ++rgelt, ++cnt)
{
rgelt->dwConnection = 0;
rgelt->pAdvSink = NULL;
}
return ReportResult(0, S_FALSE, 0, 0);
}
//+----------------------------------------------------------------------------
//
// Member:
// COleCache::Skip, public
//
// Synopsis:
// implements IEnumSTATDATA::Skip
//
// Arguments:
// [celt] -- count of the number of items in the enumeration to
// skip over
//
// Returns:
// OLE_E_BLANK, if the associated ole cache has been destroyed
// S_FALSE, if there were fewer items left in the enumeration
// than we were to skip
// S_OK
//
// Notes:
// REVIEW, Skipped would-have-been-synthesized CF_BITMAP items
// are not counted towards the skip count
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup;
// fixed error return for case where there are fewer items
// in the enumeration than we are to skip
// 08/08/94 AlexT Synchronize with ::Next implementation
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_Skip)
STDMETHODIMP CCacheEnum::Skip(ULONG celt)
{
VDATEHEAP();
VDATETHREAD(this);
LPCACHENODE lpCacheNode; // pointer to the current cache node
// if there's no cache, there's nothing we can do
if (!m_pOleCache)
return ReportResult (0, OLE_E_BLANK, 0, 0);
for (NULL; celt > 0; celt--)
{
if (m_fDib)
{
// The last node enumerated (or skipped) was CF_DIB;
// if that node still exists, we'll "skip" the fake
// CF_BITMAP node we would have generated.
m_fDib = FALSE;
// get the *current* cache node
lpCacheNode = m_pOleCache->GetAt(m_ulCurCacheId);
if (NULL != lpCacheNode &&
CF_DIB == lpCacheNode->GetFormatEtc()->cfFormat)
{
// The current cache node exists and it is of type
// CF_DIB, which means we've "found" a node to
// skip (in this case it's our fake CF_BITMAP that
// we would have generated from CF_DIB). The
// continue statement will execute the celt--
// in the for loop above
continue;
}
// if there was no cache node at m_ulCurCacheId, or
// the format was not CF_DIB that means the original
// node disappeared while we were enumerating
// (the caller may have called Uncache); we just
// fall through and pick up the next node
}
// If we're here, the last returned item was NOT
// CF_DIB
// Get next valid cache node from cache node list
lpCacheNode = m_pOleCache->GetNext(&m_ulCurCacheId);
if (NULL == lpCacheNode)
{
return ReportResult (0, S_FALSE, 0, 0);
}
// if this item is of format CF_DIB, then on the
// next iteration, return a synthesized CF_BITMAP for
// the same item
if (CF_DIB == lpCacheNode->GetFormatEtc()->cfFormat)
{
m_fDib = TRUE;
}
}
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::Reset, public
//
// Synopsis:
// implements IEnumSTATDATA::Reset
//
// Arguments:
// none
//
// Returns:
// OLE_E_BLANK, if the associated ole cache has been destroyed
// S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_Reset)
STDMETHODIMP CCacheEnum::Reset(void)
{
VDATEHEAP();
VDATETHREAD(this);
// if there's no cache, there's nothing to do
if (!m_pOleCache)
return ReportResult (0, OLE_E_BLANK, 0, 0);
// REVIEW, shouldn't there be a better error code for this?
// don't need to return a synthesized CF_BITMAP next
if (m_fDib)
m_fDib = FALSE;
// begin scanning the cache from the beginning again
m_ulCurCacheId = CACHEID_GETNEXT_GETALL;
return NOERROR;
}
//+----------------------------------------------------------------------------
//
// Member:
// CCacheEnum::Clone, public
//
// Synopsis:
// implements IEnumSTATDATA::Clone
//
// Arguments:
// [ppenum] -- pointer to where to return the created enumerator
//
// Returns:
// OLE_E_BLANK, if the associated cache has been destroyed;
// no enumerator is created in this case
// E_OUTOFMEMORY, S_OK
//
// Notes:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
#pragma SEG(CCacheEnum_Clone)
STDMETHODIMP CCacheEnum::Clone(LPENUMSTATDATA FAR* ppenum)
{
VDATEHEAP();
VDATETHREAD(this);
// if there's no cache, don't create enumerator
if (!m_pOleCache)
{
*ppenum = NULL;
return ReportResult (0, OLE_E_BLANK, 0, 0);
}
// pass our state (pointer to COleCache and current item id) to the
// constuctor to get a clone.
if (!(*ppenum = (LPENUMSTATDATA) new CCacheEnum(m_pOleCache,
m_ulCurCacheId, m_fDib)))
return ReportResult(0, E_OUTOFMEMORY, 0, 0);
return NOERROR;
}
INTERNAL IsSameAsObjectFormatEtc(LPFORMATETC lpforetc, CLIPFORMAT cfFormat)
{
VDATEHEAP();
// this function only checks for DVASPECT_CONTENT
if (lpforetc->dwAspect != DVASPECT_CONTENT)
return ResultFromScode(DV_E_DVASPECT);
// is the lindex right?
if (lpforetc->lindex != DEF_LINDEX)
return ResultFromScode(DV_E_LINDEX);
// if there's no format, set it to CF_METAFILEPICT or CF_DIB
if (lpforetc->cfFormat == NULL)
{
lpforetc->cfFormat = cfFormat;
if (lpforetc->cfFormat == CF_METAFILEPICT)
{
lpforetc->tymed = TYMED_MFPICT;
}
#ifdef FULL_EMF_SUPPORT
else if (lpforetc->cfFormat == CF_ENHMETAFILE)
{
lpforetc->tymed = TYMED_ENHMF;
}
#endif
else
{
lpforetc->tymed = TYMED_HGLOBAL;
}
}
else
{
// if it's CF_BITMAP, change it to CF_DIB
BITMAP_TO_DIB((*lpforetc));
// compare the two formats
if (lpforetc->cfFormat != cfFormat)
return ResultFromScode(DV_E_CLIPFORMAT);
}
// if we got here, the two formats are [interchangeable?]
return NOERROR;
}
//+-------------------------------------------------------------------------
//
// Member: CCacheEnum::Dump, public (_DEBUG only)
//
// Synopsis: return a string containing the contents of the data members
//
// Effects:
//
// Arguments: [ppszDump] - an out pointer to a null terminated character array
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies: [ppsz] - argument
//
// Derivation:
//
// Algorithm: use dbgstream to create a string containing information on the
// content of data structures
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
HRESULT CCacheEnum::Dump(char **ppszDump, ULONG ulFlag, int nIndentLevel)
{
int i;
char *pszPrefix;
char *pszCThreadCheck;
dbgstream dstrPrefix;
dbgstream dstrDump;
// determine prefix of newlines
if ( ulFlag & DEB_VERBOSE )
{
dstrPrefix << this << " _VB ";
}
// determine indentation prefix for all newlines
for (i = 0; i < nIndentLevel; i++)
{
dstrPrefix << DUMPTAB;
}
pszPrefix = dstrPrefix.str();
// put data members in stream
pszCThreadCheck = DumpCThreadCheck((CThreadCheck *)this, ulFlag, nIndentLevel + 1);
dstrDump << pszPrefix << "CThreadCheck:" << endl;
dstrDump << pszCThreadCheck;
CoTaskMemFree(pszCThreadCheck);
dstrDump << pszPrefix << "No. of References = " << m_refs << endl;
dstrDump << pszPrefix << "Last returned item CF_DIB?= ";
if (m_fDib == TRUE)
{
dstrDump << "TRUE" << endl;
}
else
{
dstrDump << "FALSE" << endl;
}
dstrDump << pszPrefix << "Current cache ID enum = " << m_ulCurCacheId << endl;
// we don't want to dump the COleCache due to recursion
dstrDump << pszPrefix << "pCOleCache = " << m_pOleCache << endl;
dstrDump << pszPrefix << "pNext CCacheEnum = " << m_pNextCacheEnum << endl;
// cleanup and provide pointer to character array
*ppszDump = dstrDump.str();
if (*ppszDump == NULL)
{
*ppszDump = UtDupStringA(szDumpErrorMessage);
}
CoTaskMemFree(pszPrefix);
return NOERROR;
}
#endif // _DEBUG
//+-------------------------------------------------------------------------
//
// Function: DumpCCacheEnum, public (_DEBUG only)
//
// Synopsis: calls the CCacheEnum::Dump method, takes care of errors and
// returns the zero terminated string
//
// Effects:
//
// Arguments: [pCE] - pointer to CCacheEnum
// [ulFlag] - flag determining prefix of all newlines of the
// out character array (default is 0 - no prefix)
// [nIndentLevel] - will add a indent prefix after the other prefix
// for ALL newlines (including those with no prefix)
//
// Requires:
//
// Returns: character array of structure dump or error (null terminated)
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 31-Jan-95 t-ScottH author
//
// Notes:
//
//--------------------------------------------------------------------------
#ifdef _DEBUG
char *DumpCCacheEnum(CCacheEnum *pCE, ULONG ulFlag, int nIndentLevel)
{
HRESULT hresult;
char *pszDump;
if (pCE == NULL)
{
return UtDupStringA(szDumpBadPtr);
}
hresult = pCE->Dump(&pszDump, ulFlag, nIndentLevel);
if (hresult != NOERROR)
{
CoTaskMemFree(pszDump);
return DumpHRESULT(hresult);
}
return pszDump;
}
#endif // _DEBUG
Reference in New Issue View Git Blame Copy Permalink