datacache.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "ole2.h"
#include "compobj_private.h"
#include "wine/list.h"
#include "wine/debug.h"
#include <pshpack2.h>
#include <poppack.h>

Include dependency graph for datacache.c:

Go to the source code of this file.

Classes
struct	PresentationDataHeader
struct	DataCacheEntry
struct	DataCache
struct	meta_placeable

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	STREAM_NUMBER_NOT_SET   -2
#define	STREAM_NUMBER_CONTENTS   -1 /* CONTENTS stream */

Typedefs
typedef struct PresentationDataHeader	PresentationDataHeader
typedef struct DataCacheEntry	DataCacheEntry
typedef struct DataCache	DataCache

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static DataCache *	impl_from_IDataObject (IDataObject *iface)
static DataCache *	impl_from_IUnknown (IUnknown *iface)
static DataCache *	impl_from_IPersistStorage (IPersistStorage *iface)
static DataCache *	impl_from_IViewObject2 (IViewObject2 *iface)
static DataCache *	impl_from_IOleCache2 (IOleCache2 *iface)
static DataCache *	impl_from_IOleCacheControl (IOleCacheControl *iface)
static DataCache *	impl_from_IAdviseSink (IAdviseSink *iface)
const char *	debugstr_formatetc (const FORMATETC *formatetc)
static int	bitmap_info_size (const BITMAPINFO *info, WORD coloruse)
static void	DataCacheEntry_Destroy (DataCache *cache, DataCacheEntry *cache_entry)
static void	DataCache_Destroy (DataCache *ptrToDestroy)
static DataCacheEntry *	DataCache_GetEntryForFormatEtc (DataCache *This, const FORMATETC *formatetc)
static HRESULT	get_static_entry (DataCache *cache, DataCacheEntry **cache_entry)
static HRESULT	check_valid_formatetc (const FORMATETC *fmt)
static BOOL	init_cache_entry (DataCacheEntry *entry, const FORMATETC *fmt, DWORD advf, DWORD id)
static HRESULT	DataCache_CreateEntry (DataCache *This, const FORMATETC *formatetc, DWORD advf, BOOL automatic, DataCacheEntry **cache_entry)
static void	DataCache_FireOnViewChange (DataCache *this, DWORD aspect, LONG lindex)
static HRESULT	read_clipformat (IStream *stream, CLIPFORMAT *clipformat)
static HRESULT	write_clipformat (IStream *stream, CLIPFORMAT clipformat)
static HRESULT	open_pres_stream (IStorage *stg, int stream_number, IStream **stm)
static HRESULT	synthesize_emf (HMETAFILEPICT data, STGMEDIUM *med)
static HRESULT	load_mf_pict (DataCacheEntry *cache_entry, IStream *stm)
static HRESULT	load_dib (DataCacheEntry *cache_entry, IStream *stm)
static HRESULT	load_emf (DataCacheEntry *cache_entry, IStream *stm)
static HRESULT	DataCacheEntry_LoadData (DataCacheEntry *cache_entry, IStorage *stg)
static void	init_stream_header (DataCacheEntry *entry, PresentationDataHeader *header)
static HRESULT	save_dib (DataCacheEntry *entry, BOOL contents, IStream *stream)
static HRESULT	save_mfpict (DataCacheEntry *entry, BOOL contents, IStream *stream)
static HRESULT	save_emf (DataCacheEntry *entry, BOOL contents, IStream *stream)
static HRESULT	save_view_cache (DataCacheEntry *entry, IStream *stream)
static HRESULT	create_stream (DataCacheEntry *cache_entry, IStorage *storage, BOOL contents, IStream **stream)
static HRESULT	DataCacheEntry_Save (DataCacheEntry *cache_entry, IStorage *storage, BOOL same_as_load)
static HRESULT	copy_stg_medium (CLIPFORMAT cf, STGMEDIUM *dest_stgm, const STGMEDIUM *src_stgm)
static HRESULT	synthesize_dib (HBITMAP bm, STGMEDIUM *med)
static HRESULT	synthesize_bitmap (HGLOBAL dib, STGMEDIUM *med)
static HRESULT	DataCacheEntry_SetData (DataCacheEntry *cache_entry, const FORMATETC *formatetc, STGMEDIUM *stgmedium, BOOL fRelease)
static HRESULT	DataCacheEntry_GetData (DataCacheEntry *cache_entry, IStorage *stg, FORMATETC *fmt, STGMEDIUM *stgmedium)
static HRESULT	DataCacheEntry_DiscardData (DataCacheEntry *cache_entry)
static DWORD	tymed_from_cf (DWORD cf)
static HRESULT	create_automatic_entry (DataCache *cache, const CLSID *clsid)
static HRESULT WINAPI	DataCache_NDIUnknown_QueryInterface (IUnknown *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_NDIUnknown_AddRef (IUnknown *iface)
static ULONG WINAPI	DataCache_NDIUnknown_Release (IUnknown *iface)
static HRESULT WINAPI	DataCache_IDataObject_QueryInterface (IDataObject *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_IDataObject_AddRef (IDataObject *iface)
static ULONG WINAPI	DataCache_IDataObject_Release (IDataObject *iface)
static HRESULT WINAPI	DataCache_GetData (IDataObject *iface, LPFORMATETC pformatetcIn, STGMEDIUM *pmedium)
static HRESULT WINAPI	DataCache_GetDataHere (IDataObject *iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium)
static HRESULT WINAPI	DataCache_QueryGetData (IDataObject *iface, FORMATETC *fmt)
static HRESULT WINAPI	DataCache_GetCanonicalFormatEtc (IDataObject *iface, LPFORMATETC pformatectIn, LPFORMATETC pformatetcOut)
static HRESULT WINAPI	DataCache_IDataObject_SetData (IDataObject *iface, LPFORMATETC pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
static HRESULT WINAPI	DataCache_EnumFormatEtc (IDataObject *iface, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
static HRESULT WINAPI	DataCache_DAdvise (IDataObject *iface, FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
static HRESULT WINAPI	DataCache_DUnadvise (IDataObject *iface, DWORD dwConnection)
static HRESULT WINAPI	DataCache_EnumDAdvise (IDataObject *iface, IEnumSTATDATA **ppenumAdvise)
static HRESULT WINAPI	DataCache_IPersistStorage_QueryInterface (IPersistStorage *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_IPersistStorage_AddRef (IPersistStorage *iface)
static ULONG WINAPI	DataCache_IPersistStorage_Release (IPersistStorage *iface)
static HRESULT WINAPI	DataCache_GetClassID (IPersistStorage *iface, CLSID *clsid)
static HRESULT WINAPI	DataCache_IsDirty (IPersistStorage *iface)
static HRESULT WINAPI	DataCache_InitNew (IPersistStorage *iface, IStorage *pStg)
static HRESULT	add_cache_entry (DataCache *This, const FORMATETC *fmt, DWORD advf, int stream_number)
static HRESULT	parse_pres_streams (DataCache *cache, IStorage *stg)
static HRESULT	parse_contents_stream (DataCache *cache, IStorage *stg)
static HRESULT WINAPI	DataCache_Load (IPersistStorage *iface, IStorage *stg)
static HRESULT WINAPI	DataCache_Save (IPersistStorage *iface, IStorage *stg, BOOL same_as_load)
static HRESULT WINAPI	DataCache_SaveCompleted (IPersistStorage *iface, IStorage *pStgNew)
static HRESULT WINAPI	DataCache_HandsOffStorage (IPersistStorage *iface)
static HRESULT WINAPI	DataCache_IViewObject2_QueryInterface (IViewObject2 *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_IViewObject2_AddRef (IViewObject2 *iface)
static ULONG WINAPI	DataCache_IViewObject2_Release (IViewObject2 *iface)
static HRESULT WINAPI	DataCache_Draw (IViewObject2 *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hdcTargetDev, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds, BOOL(CALLBACK *pfnContinue)(ULONG_PTR dwContinue), ULONG_PTR dwContinue)
static HRESULT WINAPI	DataCache_GetColorSet (IViewObject2 *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDevice, LOGPALETTE **ppColorSet)
static HRESULT WINAPI	DataCache_Freeze (IViewObject2 *iface, DWORD dwDrawAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze)
static HRESULT WINAPI	DataCache_Unfreeze (IViewObject2 *iface, DWORD dwFreeze)
static HRESULT WINAPI	DataCache_SetAdvise (IViewObject2 *iface, DWORD aspects, DWORD advf, IAdviseSink *pAdvSink)
static HRESULT WINAPI	DataCache_GetAdvise (IViewObject2 *iface, DWORD *pAspects, DWORD *pAdvf, IAdviseSink **ppAdvSink)
static HRESULT WINAPI	DataCache_GetExtent (IViewObject2 *iface, DWORD dwDrawAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel)
static HRESULT WINAPI	DataCache_IOleCache2_QueryInterface (IOleCache2 *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_IOleCache2_AddRef (IOleCache2 *iface)
static ULONG WINAPI	DataCache_IOleCache2_Release (IOleCache2 *iface)
static HRESULT	setup_sink (DataCache *This, DataCacheEntry *cache_entry)
static HRESULT WINAPI	DataCache_Cache (IOleCache2 *iface, FORMATETC *pformatetc, DWORD advf, DWORD *pdwConnection)
static HRESULT WINAPI	DataCache_Uncache (IOleCache2 *iface, DWORD dwConnection)
static HRESULT WINAPI	DataCache_EnumCache (IOleCache2 *iface, IEnumSTATDATA **enum_stat)
static HRESULT WINAPI	DataCache_InitCache (IOleCache2 *iface, IDataObject *data)
static HRESULT WINAPI	DataCache_IOleCache2_SetData (IOleCache2 *iface, FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
static BOOL	entry_updatable (DataCacheEntry *entry, DWORD mode)
static HRESULT WINAPI	DataCache_UpdateCache (IOleCache2 *iface, IDataObject *data, DWORD mode, void *reserved)
static HRESULT WINAPI	DataCache_DiscardCache (IOleCache2 *iface, DWORD dwDiscardOptions)
static HRESULT WINAPI	DataCache_IOleCacheControl_QueryInterface (IOleCacheControl *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	DataCache_IOleCacheControl_AddRef (IOleCacheControl *iface)
static ULONG WINAPI	DataCache_IOleCacheControl_Release (IOleCacheControl *iface)
static HRESULT WINAPI	DataCache_OnRun (IOleCacheControl *iface, IDataObject *data_obj)
static HRESULT WINAPI	DataCache_OnStop (IOleCacheControl *iface)
static HRESULT WINAPI	DataCache_IAdviseSink_QueryInterface (IAdviseSink *iface, REFIID iid, void **obj)
static ULONG WINAPI	DataCache_IAdviseSink_AddRef (IAdviseSink *iface)
static ULONG WINAPI	DataCache_IAdviseSink_Release (IAdviseSink *iface)
static void WINAPI	DataCache_OnDataChange (IAdviseSink *iface, FORMATETC *fmt, STGMEDIUM *med)
static void WINAPI	DataCache_OnViewChange (IAdviseSink *iface, DWORD aspect, LONG index)
static void WINAPI	DataCache_OnRename (IAdviseSink *iface, IMoniker *mk)
static void WINAPI	DataCache_OnSave (IAdviseSink *iface)
static void WINAPI	DataCache_OnClose (IAdviseSink *iface)
static DataCache *	DataCache_Construct (REFCLSID clsid, LPUNKNOWN pUnkOuter)
HRESULT WINAPI	CreateDataCache (LPUNKNOWN pUnkOuter, REFCLSID rclsid, REFIID riid, LPVOID *ppvObj)

Variables
static const WCHAR	CONTENTS [] = {'C','O','N','T','E','N','T','S',0}
static const IUnknownVtbl	DataCache_NDIUnknown_VTable
static const IDataObjectVtbl	DataCache_IDataObject_VTable
static const IPersistStorageVtbl	DataCache_IPersistStorage_VTable
static const IViewObject2Vtbl	DataCache_IViewObject2_VTable
static const IOleCache2Vtbl	DataCache_IOleCache2_VTable
static const IOleCacheControlVtbl	DataCache_IOleCacheControl_VTable
static const IAdviseSinkVtbl	DataCache_IAdviseSink_VTable

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 50 of file datacache.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 51 of file datacache.c.

STREAM_NUMBER_CONTENTS

#define STREAM_NUMBER_CONTENTS   -1 /* CONTENTS stream */

Definition at line 93 of file datacache.c.

STREAM_NUMBER_NOT_SET

#define STREAM_NUMBER_NOT_SET   -2

Definition at line 92 of file datacache.c.

Typedef Documentation

DataCache

typedef struct DataCache DataCache

Definition at line 172 of file datacache.c.

DataCacheEntry

typedef struct DataCacheEntry DataCacheEntry

PresentationDataHeader

typedef struct PresentationDataHeader PresentationDataHeader

Function Documentation

add_cache_entry()

static HRESULT add_cache_entry ( DataCache *  This, const FORMATETC *  fmt, DWORD  advf, int  stream_number  )

static

Definition at line 1747 of file datacache.c.

{
    DataCacheEntry *cache_entry;
    HRESULT hr = S_OK;
 
    TRACE( "loading entry with formatetc: %s\n", debugstr_formatetc( fmt ) );
 
    cache_entry = DataCache_GetEntryForFormatEtc( This, fmt );
    if (!cache_entry)
        hr = DataCache_CreateEntry( This, fmt, advf, FALSE, &cache_entry );
    if (SUCCEEDED( hr ))
    {
        DataCacheEntry_DiscardData( cache_entry );
        cache_entry->load_stream_num = stream_number;
        cache_entry->save_stream_num = stream_number;
        cache_entry->dirty = FALSE;
    }
    return hr;
}

Referenced by parse_pres_streams().

bitmap_info_size()

static int bitmap_info_size ( const BITMAPINFO *  info, WORD  coloruse  )

static

Definition at line 228 of file datacache.c.

{
    unsigned int colors, size, masks = 0;
 
    if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
    {
        const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
        colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
        return sizeof(BITMAPCOREHEADER) + colors *
            ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
    }
    else  /* assume BITMAPINFOHEADER */
    {
        colors = info->bmiHeader.biClrUsed;
        if (colors > 256) /* buffer overflow otherwise */
            colors = 256;
        if (!colors && (info->bmiHeader.biBitCount <= 8))
            colors = 1 << info->bmiHeader.biBitCount;
        if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
        size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
        return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
    }
}

Referenced by DataCache_Draw(), load_dib(), PlayMetaFileRecord(), save_dib(), synthesize_bitmap(), and synthesize_dib().

check_valid_formatetc()

static HRESULT check_valid_formatetc ( const FORMATETC *  fmt )

static

Definition at line 340 of file datacache.c.

{
    /* DVASPECT_ICON must be CF_METAFILEPICT */
    if (fmt->dwAspect == DVASPECT_ICON && fmt->cfFormat != CF_METAFILEPICT)
        return DV_E_FORMATETC;
 
    if (!fmt->cfFormat ||
        (fmt->cfFormat == CF_METAFILEPICT && fmt->tymed == TYMED_MFPICT) ||
        (fmt->cfFormat == CF_BITMAP && fmt->tymed == TYMED_GDI) ||
        (fmt->cfFormat == CF_DIB && fmt->tymed == TYMED_HGLOBAL) ||
        (fmt->cfFormat == CF_ENHMETAFILE && fmt->tymed == TYMED_ENHMF))
        return S_OK;
    else if (fmt->tymed == TYMED_HGLOBAL)
        return CACHE_S_FORMATETC_NOTSUPPORTED;
    else
    {
        WARN("invalid clipformat/tymed combination: %d/%d\n", fmt->cfFormat, fmt->tymed);
        return DV_E_TYMED;
    }
}

Referenced by DataCache_CreateEntry().

copy_stg_medium()

static HRESULT copy_stg_medium ( CLIPFORMAT  cf, STGMEDIUM *  dest_stgm, const STGMEDIUM *  src_stgm  )

static

Definition at line 1139 of file datacache.c.

{
    if (src_stgm->tymed == TYMED_MFPICT)
    {
        const METAFILEPICT *src_mfpict = GlobalLock(src_stgm->u.hMetaFilePict);
        METAFILEPICT *dest_mfpict;
 
        if (!src_mfpict)
            return DV_E_STGMEDIUM;
        dest_stgm->u.hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
        dest_mfpict = GlobalLock(dest_stgm->u.hMetaFilePict);
        if (!dest_mfpict)
        {
            GlobalUnlock(src_stgm->u.hMetaFilePict);
            return E_OUTOFMEMORY;
        }
        *dest_mfpict = *src_mfpict;
        dest_mfpict->hMF = CopyMetaFileW(src_mfpict->hMF, NULL);
        GlobalUnlock(src_stgm->u.hMetaFilePict);
        GlobalUnlock(dest_stgm->u.hMetaFilePict);
    }
    else if (src_stgm->tymed != TYMED_NULL)
    {
        dest_stgm->u.hGlobal = OleDuplicateData(src_stgm->u.hGlobal, cf,
                                                GMEM_MOVEABLE);
        if (!dest_stgm->u.hGlobal)
            return E_OUTOFMEMORY;
    }
    dest_stgm->tymed = src_stgm->tymed;
    dest_stgm->pUnkForRelease = src_stgm->pUnkForRelease;
    if (dest_stgm->pUnkForRelease)
        IUnknown_AddRef(dest_stgm->pUnkForRelease);
    return S_OK;
}

Referenced by DataCacheEntry_GetData(), and DataCacheEntry_SetData().

create_automatic_entry()

static HRESULT create_automatic_entry ( DataCache *  cache, const CLSID *  clsid  )

static

Definition at line 1312 of file datacache.c.

{
    static const struct data
    {
        const CLSID *clsid;
        FORMATETC fmt;
    } data[] =
    {
        { &CLSID_Picture_Dib,         { CF_DIB,          0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL } },
        { &CLSID_Picture_Metafile,    { CF_METAFILEPICT, 0, DVASPECT_CONTENT, -1, TYMED_MFPICT } },
        { &CLSID_Picture_EnhMetafile, { CF_ENHMETAFILE,  0, DVASPECT_CONTENT, -1, TYMED_ENHMF } },
        { NULL }
    };
    const struct data *ptr = data;
    struct list *head;
    DataCacheEntry *entry;
 
    if (IsEqualCLSID( &cache->clsid, clsid )) return S_OK;
 
    /* move and reassign any pre-existing automatic entry */
    if ((head = list_head( &cache->cache_list )))
    {
        entry = LIST_ENTRY( head, DataCacheEntry, entry );
        if (entry->id == 1)
        {
            list_remove( &entry->entry );
            entry->id = cache->last_cache_id++;
            list_add_tail( &cache->cache_list, &entry->entry );
        }
    }
 
    while (ptr->clsid)
    {
        if (IsEqualCLSID( clsid, ptr->clsid ))
        {
            cache->clsid_static = TRUE;
            return DataCache_CreateEntry( cache, &ptr->fmt, 0, TRUE, NULL );
        }
        ptr++;
    }
    cache->clsid_static = FALSE;
    return S_OK;
}

Referenced by DataCache_Construct(), DataCache_InitNew(), and DataCache_Load().

create_stream()

static HRESULT create_stream ( DataCacheEntry *  cache_entry, IStorage *  storage, BOOL  contents, IStream **  stream  )

static

Definition at line 1082 of file datacache.c.

{
    WCHAR pres[] = {2,'O','l','e','P','r','e','s',
        '0' + (cache_entry->save_stream_num / 100) % 10,
        '0' + (cache_entry->save_stream_num / 10) % 10,
        '0' + cache_entry->save_stream_num % 10, 0};
    const WCHAR *name;
 
    if (contents)
        name = CONTENTS;
    else
        name = pres;
 
    return IStorage_CreateStream(storage, name,
                                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
                                 0, 0, stream);
}

Referenced by DataCacheEntry_Save().

CreateDataCache()

HRESULT WINAPI CreateDataCache	(	LPUNKNOWN	pUnkOuter,
		REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppvObj
	)

Definition at line 3035 of file datacache.c.

{
  DataCache* newCache = NULL;
  HRESULT    hr       = S_OK;
 
  TRACE("(%s, %p, %s, %p)\n", debugstr_guid(rclsid), pUnkOuter, debugstr_guid(riid), ppvObj);
 
  /*
   * Sanity check
   */
  if (ppvObj==0)
    return E_POINTER;
 
  *ppvObj = 0;
 
  /*
   * If this cache is constructed for aggregation, make sure
   * the caller is requesting the IUnknown interface.
   * This is necessary because it's the only time the non-delegating
   * IUnknown pointer can be returned to the outside.
   */
  if ( pUnkOuter && !IsEqualIID(&IID_IUnknown, riid) )
    return E_INVALIDARG;
 
  /*
   * Try to construct a new instance of the class.
   */
  newCache = DataCache_Construct(rclsid,
                 pUnkOuter);
 
  if (newCache == 0)
    return E_OUTOFMEMORY;
 
  hr = IUnknown_QueryInterface(&newCache->IUnknown_inner, riid, ppvObj);
  IUnknown_Release(&newCache->IUnknown_inner);
 
  return hr;
}

Referenced by DefaultHandler_Construct(), test_data_cache(), test_data_cache_cache(), test_data_cache_contents(), test_data_cache_dib_contents_stream(), test_data_cache_init(), test_data_cache_initnew(), test_data_cache_save(), test_data_cache_save_data(), and test_data_cache_updatecache().

DataCache_Cache()

static HRESULT WINAPI DataCache_Cache ( IOleCache2 *  iface, FORMATETC *  pformatetc, DWORD  advf, DWORD *  pdwConnection  )

static

Definition at line 2439 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2(iface);
    DataCacheEntry *cache_entry;
    HRESULT hr;
    FORMATETC fmt_cpy;
 
    TRACE("(%p, 0x%x, %p)\n", pformatetc, advf, pdwConnection);
 
    if (!pformatetc || !pdwConnection)
        return E_INVALIDARG;
 
    TRACE("pformatetc = %s\n", debugstr_formatetc(pformatetc));
 
    fmt_cpy = *pformatetc; /* No need for a deep copy */
    if (fmt_cpy.cfFormat == CF_BITMAP && fmt_cpy.tymed == TYMED_GDI)
    {
        fmt_cpy.cfFormat = CF_DIB;
        fmt_cpy.tymed = TYMED_HGLOBAL;
    }
 
    /* View caching DVASPECT_ICON gets converted to CF_METAFILEPICT */
    if (fmt_cpy.dwAspect == DVASPECT_ICON && fmt_cpy.cfFormat == 0)
    {
        fmt_cpy.cfFormat = CF_METAFILEPICT;
        fmt_cpy.tymed = TYMED_MFPICT;
    }
 
    *pdwConnection = 0;
 
    cache_entry = DataCache_GetEntryForFormatEtc(This, &fmt_cpy);
    if (cache_entry)
    {
        TRACE("found an existing cache entry\n");
        *pdwConnection = cache_entry->id;
        return CACHE_S_SAMECACHE;
    }
 
    if (This->clsid_static && fmt_cpy.dwAspect != DVASPECT_ICON) return DV_E_FORMATETC;
 
    hr = DataCache_CreateEntry(This, &fmt_cpy, advf, FALSE, &cache_entry);
 
    if (SUCCEEDED(hr))
    {
        *pdwConnection = cache_entry->id;
        setup_sink(This, cache_entry);
    }
 
    return hr;
}

DataCache_Construct()

static DataCache * DataCache_Construct ( REFCLSID  clsid, LPUNKNOWN  pUnkOuter  )

static

Definition at line 2967 of file datacache.c.

{
  DataCache* newObject = 0;
 
  /*
   * Allocate space for the object.
   */
  newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(DataCache));
 
  if (newObject==0)
    return newObject;
 
  /*
   * Initialize the virtual function table.
   */
  newObject->IDataObject_iface.lpVtbl = &DataCache_IDataObject_VTable;
  newObject->IUnknown_inner.lpVtbl = &DataCache_NDIUnknown_VTable;
  newObject->IPersistStorage_iface.lpVtbl = &DataCache_IPersistStorage_VTable;
  newObject->IViewObject2_iface.lpVtbl = &DataCache_IViewObject2_VTable;
  newObject->IOleCache2_iface.lpVtbl = &DataCache_IOleCache2_VTable;
  newObject->IOleCacheControl_iface.lpVtbl = &DataCache_IOleCacheControl_VTable;
  newObject->IAdviseSink_iface.lpVtbl = &DataCache_IAdviseSink_VTable;
  newObject->outer_unk = pUnkOuter ? pUnkOuter : &newObject->IUnknown_inner;
  newObject->ref = 1;
 
  /*
   * Initialize the other members of the structure.
   */
  newObject->sinkAspects = 0;
  newObject->sinkAdviseFlag = 0;
  newObject->sinkInterface = 0;
  newObject->clsid = CLSID_NULL;
  newObject->clsid_static = FALSE;
  newObject->presentationStorage = NULL;
  list_init(&newObject->cache_list);
  newObject->last_cache_id = 2;
  newObject->dirty = FALSE;
  newObject->running_object = NULL;
 
  create_automatic_entry( newObject, clsid );
  newObject->clsid = *clsid;
 
  return newObject;
}

Referenced by CreateDataCache().

DataCache_CreateEntry()

static HRESULT DataCache_CreateEntry ( DataCache *  This, const FORMATETC *  formatetc, DWORD  advf, BOOL  automatic, DataCacheEntry **  cache_entry  )

static

Definition at line 381 of file datacache.c.

{
    HRESULT hr;
    DWORD id = automatic ? 1 : This->last_cache_id;
    DataCacheEntry *entry;
 
    hr = check_valid_formatetc( formatetc );
    if (FAILED(hr))
        return hr;
    if (hr == CACHE_S_FORMATETC_NOTSUPPORTED)
        TRACE("creating unsupported format %d\n", formatetc->cfFormat);
 
    entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
    if (!entry)
        return E_OUTOFMEMORY;
 
    if (!init_cache_entry(entry, formatetc, advf, id))
        goto fail;
 
    if (automatic)
        list_add_head(&This->cache_list, &entry->entry);
    else
    {
        list_add_tail(&This->cache_list, &entry->entry);
        This->last_cache_id++;
    }
 
    if (cache_entry) *cache_entry = entry;
    return hr;
 
fail:
    HeapFree(GetProcessHeap(), 0, entry);
    return E_OUTOFMEMORY;
}

Referenced by add_cache_entry(), create_automatic_entry(), and DataCache_Cache().

DataCache_DAdvise()

static HRESULT WINAPI DataCache_DAdvise ( IDataObject *  iface, FORMATETC *  pformatetc, DWORD  advf, IAdviseSink *  pAdvSink, DWORD *  pdwConnection  )

static

Definition at line 1598 of file datacache.c.

{
  TRACE("()\n");
  return OLE_E_ADVISENOTSUPPORTED;
}

DataCache_Destroy()

static void DataCache_Destroy ( DataCache *  ptrToDestroy )

static

Definition at line 263 of file datacache.c.

{
  DataCacheEntry *cache_entry, *next_cache_entry;
 
  TRACE("()\n");
 
  if (ptrToDestroy->sinkInterface != NULL)
  {
    IAdviseSink_Release(ptrToDestroy->sinkInterface);
    ptrToDestroy->sinkInterface = NULL;
  }
 
  LIST_FOR_EACH_ENTRY_SAFE(cache_entry, next_cache_entry, &ptrToDestroy->cache_list, DataCacheEntry, entry)
    DataCacheEntry_Destroy(ptrToDestroy, cache_entry);
 
  if (ptrToDestroy->presentationStorage != NULL)
  {
    IStorage_Release(ptrToDestroy->presentationStorage);
    ptrToDestroy->presentationStorage = NULL;
  }
 
  /*
   * Free the datacache pointer.
   */
  HeapFree(GetProcessHeap(), 0, ptrToDestroy);
}

Referenced by DataCache_NDIUnknown_Release().

DataCache_DiscardCache()

static HRESULT WINAPI DataCache_DiscardCache ( IOleCache2 *  iface, DWORD  dwDiscardOptions  )

static

Definition at line 2702 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2(iface);
    DataCacheEntry *cache_entry;
    HRESULT hr = S_OK;
 
    TRACE("(%d)\n", dwDiscardOptions);
 
    if (dwDiscardOptions == DISCARDCACHE_SAVEIFDIRTY)
        hr = DataCache_Save(&This->IPersistStorage_iface, This->presentationStorage, TRUE);
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        hr = DataCacheEntry_DiscardData(cache_entry);
        if (FAILED(hr))
            break;
    }
 
    return hr;
}

DataCache_Draw()

static HRESULT WINAPI DataCache_Draw ( IViewObject2 *  iface, DWORD  dwDrawAspect, LONG  lindex, void *  pvAspect, DVTARGETDEVICE *  ptd, HDC  hdcTargetDev, HDC  hdcDraw, LPCRECTL  lprcBounds, LPCRECTL  lprcWBounds, BOOL(CALLBACK *pfnContinue)(ULONG_PTR dwContinue)  , ULONG_PTR  dwContinue  )

static

Definition at line 2006 of file datacache.c.

{
  DataCache *This = impl_from_IViewObject2(iface);
  HRESULT                hres;
  DataCacheEntry        *cache_entry;
 
  TRACE("(%p, %x, %d, %p, %p, %p, %p, %p, %p, %lx)\n",
    iface,
    dwDrawAspect,
    lindex,
    pvAspect,
    hdcTargetDev,
    hdcDraw,
    lprcBounds,
    lprcWBounds,
    pfnContinue,
    dwContinue);
 
  if (lprcBounds==NULL)
    return E_INVALIDARG;
 
  LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
  {
    /* FIXME: compare ptd too */
    if ((cache_entry->fmtetc.dwAspect != dwDrawAspect) ||
        (cache_entry->fmtetc.lindex != lindex))
      continue;
 
    /* if the data hasn't been loaded yet, do it now */
    if ((cache_entry->stgmedium.tymed == TYMED_NULL) && (cache_entry->load_stream_num != STREAM_NUMBER_NOT_SET))
    {
      hres = DataCacheEntry_LoadData(cache_entry, This->presentationStorage);
      if (FAILED(hres))
        continue;
    }
 
    /* no data */
    if (cache_entry->stgmedium.tymed == TYMED_NULL)
      continue;
 
    if (pfnContinue && !pfnContinue(dwContinue)) return E_ABORT;
 
    switch (cache_entry->fmtetc.cfFormat)
    {
      case CF_METAFILEPICT:
      {
        /*
         * We have to be careful not to modify the state of the
         * DC.
         */
        INT   prevMapMode;
        SIZE  oldWindowExt;
        SIZE  oldViewportExt;
        POINT oldViewportOrg;
        METAFILEPICT *mfpict;
 
        if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
            !((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
          continue;
 
        prevMapMode = SetMapMode(hdcDraw, mfpict->mm);
 
        SetWindowExtEx(hdcDraw,
               mfpict->xExt,
               mfpict->yExt,
               &oldWindowExt);
 
        SetViewportExtEx(hdcDraw,
                 lprcBounds->right - lprcBounds->left,
                 lprcBounds->bottom - lprcBounds->top,
                 &oldViewportExt);
 
        SetViewportOrgEx(hdcDraw,
                 lprcBounds->left,
                 lprcBounds->top,
                 &oldViewportOrg);
 
        PlayMetaFile(hdcDraw, mfpict->hMF);
 
        SetWindowExtEx(hdcDraw,
               oldWindowExt.cx,
               oldWindowExt.cy,
               NULL);
 
        SetViewportExtEx(hdcDraw,
                 oldViewportExt.cx,
                 oldViewportExt.cy,
                 NULL);
 
        SetViewportOrgEx(hdcDraw,
                 oldViewportOrg.x,
                 oldViewportOrg.y,
                 NULL);
 
        SetMapMode(hdcDraw, prevMapMode);
 
        GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
 
        return S_OK;
      }
      case CF_DIB:
      {
          BITMAPINFO *info;
          BYTE *bits;
 
          if ((cache_entry->stgmedium.tymed != TYMED_HGLOBAL) ||
              !((info = GlobalLock( cache_entry->stgmedium.u.hGlobal ))))
              continue;
 
          bits = (BYTE *) info + bitmap_info_size( info, DIB_RGB_COLORS );
          StretchDIBits( hdcDraw, lprcBounds->left, lprcBounds->top,
                         lprcBounds->right - lprcBounds->left, lprcBounds->bottom - lprcBounds->top,
                         0, 0, info->bmiHeader.biWidth, info->bmiHeader.biHeight,
                         bits, info, DIB_RGB_COLORS, SRCCOPY );
 
          GlobalUnlock( cache_entry->stgmedium.u.hGlobal );
          return S_OK;
      }
    }
  }
 
  WARN("no data could be found to be drawn\n");
 
  return OLE_E_BLANK;
}

DataCache_DUnadvise()

static HRESULT WINAPI DataCache_DUnadvise ( IDataObject *  iface, DWORD  dwConnection  )

static

Definition at line 1614 of file datacache.c.

{
  TRACE("()\n");
  return OLE_E_NOCONNECTION;
}

DataCache_EnumCache()

static HRESULT WINAPI DataCache_EnumCache ( IOleCache2 *  iface, IEnumSTATDATA **  enum_stat  )

static

Definition at line 2515 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2( iface );
    DataCacheEntry *cache_entry;
    int i = 0, count = 0;
    STATDATA *data;
    HRESULT hr;
 
    TRACE( "(%p, %p)\n", This, enum_stat );
 
    LIST_FOR_EACH_ENTRY( cache_entry, &This->cache_list, DataCacheEntry, entry )
    {
        count++;
        if (cache_entry->fmtetc.cfFormat == CF_DIB)
            count++;
    }
 
    data = CoTaskMemAlloc( count * sizeof(*data) );
    if (!data) return E_OUTOFMEMORY;
 
    LIST_FOR_EACH_ENTRY( cache_entry, &This->cache_list, DataCacheEntry, entry )
    {
        if (i == count) goto fail;
        hr = copy_formatetc( &data[i].formatetc, &cache_entry->fmtetc );
        if (FAILED(hr)) goto fail;
        data[i].advf = cache_entry->advise_flags;
        data[i].pAdvSink = NULL;
        data[i].dwConnection = cache_entry->id;
        i++;
 
        if (cache_entry->fmtetc.cfFormat == CF_DIB)
        {
            if (i == count) goto fail;
            hr = copy_formatetc( &data[i].formatetc, &cache_entry->fmtetc );
            if (FAILED(hr)) goto fail;
            data[i].formatetc.cfFormat = CF_BITMAP;
            data[i].formatetc.tymed = TYMED_GDI;
            data[i].advf = cache_entry->advise_flags;
            data[i].pAdvSink = NULL;
            data[i].dwConnection = cache_entry->id;
            i++;
        }
    }
 
    hr = EnumSTATDATA_Construct( NULL, 0, i, data, FALSE, enum_stat );
    if (SUCCEEDED(hr)) return hr;
 
fail:
    while (i--) CoTaskMemFree( data[i].formatetc.ptd );
    CoTaskMemFree( data );
    return hr;
}

DataCache_EnumDAdvise()

static HRESULT WINAPI DataCache_EnumDAdvise ( IDataObject *  iface, IEnumSTATDATA **  ppenumAdvise  )

static

Definition at line 1627 of file datacache.c.

{
  TRACE("()\n");
  return OLE_E_ADVISENOTSUPPORTED;
}

DataCache_EnumFormatEtc()

static HRESULT WINAPI DataCache_EnumFormatEtc ( IDataObject *  iface, DWORD  dwDirection, IEnumFORMATETC **  ppenumFormatEtc  )

static

Definition at line 1584 of file datacache.c.

{
  TRACE("()\n");
  return E_NOTIMPL;
}

DataCache_FireOnViewChange()

static void DataCache_FireOnViewChange ( DataCache *  this, DWORD  aspect, LONG  lindex  )

static

Definition at line 425 of file datacache.c.

{
  TRACE("(%p, %x, %d)\n", this, aspect, lindex);
 
  /*
   * The sink supplies a filter when it registers
   * we make sure we only send the notifications when that
   * filter matches.
   */
  if ((this->sinkAspects & aspect) != 0)
  {
    if (this->sinkInterface != NULL)
    {
      IAdviseSink_OnViewChange(this->sinkInterface,
                   aspect,
                   lindex);
 
      /*
       * Some sinks want to be unregistered automatically when
       * the first notification goes out.
       */
      if ( (this->sinkAdviseFlag & ADVF_ONLYONCE) != 0)
      {
    IAdviseSink_Release(this->sinkInterface);
 
    this->sinkInterface  = NULL;
    this->sinkAspects    = 0;
    this->sinkAdviseFlag = 0;
      }
    }
  }
}

Referenced by DataCache_IOleCache2_SetData(), and DataCache_SetAdvise().

DataCache_Freeze()

static HRESULT WINAPI DataCache_Freeze ( IViewObject2 *  iface, DWORD  dwDrawAspect, LONG  lindex, void *  pvAspect, DWORD *  pdwFreeze  )

static

Definition at line 2156 of file datacache.c.

{
  FIXME("stub\n");
  return E_NOTIMPL;
}

DataCache_GetAdvise()

static HRESULT WINAPI DataCache_GetAdvise ( IViewObject2 *  iface, DWORD *  pAspects, DWORD *  pAdvf, IAdviseSink **  ppAdvSink  )

static

Definition at line 2232 of file datacache.c.

{
  DataCache *this = impl_from_IViewObject2(iface);
 
  TRACE("(%p, %p, %p, %p)\n", iface, pAspects, pAdvf, ppAdvSink);
 
  /*
   * Just copy all the requested values.
   */
  if (pAspects!=NULL)
    *pAspects = this->sinkAspects;
 
  if (pAdvf!=NULL)
    *pAdvf = this->sinkAdviseFlag;
 
  if (ppAdvSink!=NULL)
  {
    if (this->sinkInterface != NULL)
        IAdviseSink_QueryInterface(this->sinkInterface,
                   &IID_IAdviseSink,
                   (void**)ppAdvSink);
    else *ppAdvSink = NULL;
  }
 
  return S_OK;
}

DataCache_GetCanonicalFormatEtc()

static HRESULT WINAPI DataCache_GetCanonicalFormatEtc ( IDataObject *  iface, LPFORMATETC  pformatectIn, LPFORMATETC  pformatetcOut  )

static

Definition at line 1542 of file datacache.c.

{
  TRACE("()\n");
  return E_NOTIMPL;
}

DataCache_GetClassID()

static HRESULT WINAPI DataCache_GetClassID ( IPersistStorage *  iface, CLSID *  clsid  )

static

Definition at line 1679 of file datacache.c.

{
    DataCache *This = impl_from_IPersistStorage( iface );
 
    TRACE( "(%p, %p) returning %s\n", iface, clsid, debugstr_guid(&This->clsid) );
    *clsid = This->clsid;
 
    return S_OK;
}

DataCache_GetColorSet()

static HRESULT WINAPI DataCache_GetColorSet ( IViewObject2 *  iface, DWORD  dwDrawAspect, LONG  lindex, void *  pvAspect, DVTARGETDEVICE *  ptd, HDC  hicTargetDevice, LOGPALETTE **  ppColorSet  )

static

Definition at line 2143 of file datacache.c.

{
  FIXME("stub\n");
  return E_NOTIMPL;
}

DataCache_GetData()

static HRESULT WINAPI DataCache_GetData ( IDataObject *  iface, LPFORMATETC  pformatetcIn, STGMEDIUM *  pmedium  )

static

Definition at line 1498 of file datacache.c.

{
    DataCache *This = impl_from_IDataObject(iface);
    DataCacheEntry *cache_entry;
 
    TRACE("(%p, %s, %p)\n", iface, debugstr_formatetc(pformatetcIn), pmedium);
 
    memset(pmedium, 0, sizeof(*pmedium));
 
    cache_entry = DataCache_GetEntryForFormatEtc(This, pformatetcIn);
    if (!cache_entry)
        return OLE_E_BLANK;
 
    return DataCacheEntry_GetData(cache_entry, This->presentationStorage, pformatetcIn, pmedium);
}

DataCache_GetDataHere()

static HRESULT WINAPI DataCache_GetDataHere ( IDataObject *  iface, LPFORMATETC  pformatetc, STGMEDIUM *  pmedium  )

static

Definition at line 1517 of file datacache.c.

{
  FIXME("stub\n");
  return E_NOTIMPL;
}

DataCache_GetEntryForFormatEtc()

static DataCacheEntry * DataCache_GetEntryForFormatEtc ( DataCache *  This, const FORMATETC *  formatetc  )

static

Definition at line 291 of file datacache.c.

{
    DataCacheEntry *cache_entry;
    FORMATETC fmt = *formatetc;
 
    if (fmt.cfFormat == CF_BITMAP)
    {
        fmt.cfFormat = CF_DIB;
        fmt.tymed = TYMED_HGLOBAL;
    }
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        /* FIXME: also compare DVTARGETDEVICEs */
        if ((fmt.cfFormat == cache_entry->fmtetc.cfFormat) &&
            (fmt.dwAspect == cache_entry->fmtetc.dwAspect) &&
            (fmt.lindex == cache_entry->fmtetc.lindex) &&
            ((fmt.tymed == cache_entry->fmtetc.tymed) || !cache_entry->fmtetc.cfFormat)) /* tymed is ignored for view caching */
            return cache_entry;
    }
    return NULL;
}

Referenced by add_cache_entry(), DataCache_Cache(), DataCache_GetData(), DataCache_IOleCache2_SetData(), and DataCache_QueryGetData().

DataCache_GetExtent()

static HRESULT WINAPI DataCache_GetExtent ( IViewObject2 *  iface, DWORD  dwDrawAspect, LONG  lindex, DVTARGETDEVICE *  ptd, LPSIZEL  lpsizel  )

static

Definition at line 2268 of file datacache.c.

{
  DataCache *This = impl_from_IViewObject2(iface);
  HRESULT                hres = E_FAIL;
  DataCacheEntry        *cache_entry;
 
  TRACE("(%p, %x, %d, %p, %p)\n",
    iface, dwDrawAspect, lindex, ptd, lpsizel);
 
  if (lpsizel==NULL)
    return E_POINTER;
 
  lpsizel->cx = 0;
  lpsizel->cy = 0;
 
  if (lindex!=-1)
    FIXME("Unimplemented flag lindex = %d\n", lindex);
 
  /*
   * Right now, we support only the callback from
   * the default handler.
   */
  if (ptd!=NULL)
    FIXME("Unimplemented ptd = %p\n", ptd);
 
  LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
  {
    /* FIXME: compare ptd too */
    if ((cache_entry->fmtetc.dwAspect != dwDrawAspect) ||
        (cache_entry->fmtetc.lindex != lindex))
      continue;
 
    /* if the data hasn't been loaded yet, do it now */
    if ((cache_entry->stgmedium.tymed == TYMED_NULL) && (cache_entry->load_stream_num != STREAM_NUMBER_NOT_SET))
    {
      hres = DataCacheEntry_LoadData(cache_entry, This->presentationStorage);
      if (FAILED(hres))
        continue;
    }
 
    /* no data */
    if (cache_entry->stgmedium.tymed == TYMED_NULL)
      continue;
 
 
    switch (cache_entry->fmtetc.cfFormat)
    {
      case CF_METAFILEPICT:
      {
          METAFILEPICT *mfpict;
 
          if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
              !((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
            continue;
 
        lpsizel->cx = mfpict->xExt;
        lpsizel->cy = mfpict->yExt;
 
        GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
 
        return S_OK;
      }
      case CF_DIB:
      {
          BITMAPINFOHEADER *info;
          LONG x_pels_m, y_pels_m;
 
 
          if ((cache_entry->stgmedium.tymed != TYMED_HGLOBAL) ||
              !((info = GlobalLock( cache_entry->stgmedium.u.hGlobal ))))
              continue;
 
          x_pels_m = info->biXPelsPerMeter;
          y_pels_m = info->biYPelsPerMeter;
 
          /* Size in units of 0.01mm (ie. MM_HIMETRIC) */
          if (x_pels_m != 0 && y_pels_m != 0)
          {
              lpsizel->cx = info->biWidth  * 100000 / x_pels_m;
              lpsizel->cy = info->biHeight * 100000 / y_pels_m;
          }
          else
          {
              HDC hdc = GetDC( 0 );
              lpsizel->cx = info->biWidth  * 2540 / GetDeviceCaps( hdc, LOGPIXELSX );
              lpsizel->cy = info->biHeight * 2540 / GetDeviceCaps( hdc, LOGPIXELSY );
 
              ReleaseDC( 0, hdc );
          }
 
          GlobalUnlock( cache_entry->stgmedium.u.hGlobal );
 
          return S_OK;
      }
    }
  }
 
  WARN("no data could be found to get the extents from\n");
 
  /*
   * This method returns OLE_E_BLANK when it fails.
   */
  return OLE_E_BLANK;
}

DataCache_HandsOffStorage()

static HRESULT WINAPI DataCache_HandsOffStorage ( IPersistStorage *  iface )

static

Definition at line 1944 of file datacache.c.

{
  DataCache *this = impl_from_IPersistStorage(iface);
 
  TRACE("(%p)\n", iface);
 
  if (this->presentationStorage != NULL)
  {
    IStorage_Release(this->presentationStorage);
    this->presentationStorage = NULL;
  }
 
  return S_OK;
}

DataCache_IAdviseSink_AddRef()

static ULONG WINAPI DataCache_IAdviseSink_AddRef ( IAdviseSink *  iface )

static

Definition at line 2838 of file datacache.c.

{
    return 2;
}

DataCache_IAdviseSink_QueryInterface()

static HRESULT WINAPI DataCache_IAdviseSink_QueryInterface ( IAdviseSink *  iface, REFIID  iid, void **  obj  )

static

Definition at line 2821 of file datacache.c.

{
    *obj = NULL;
    if (IsEqualIID(&IID_IUnknown, iid) ||
        IsEqualIID(&IID_IAdviseSink, iid))
    {
        *obj = iface;
    }
 
    if(*obj)
    {
        IAdviseSink_AddRef(iface);
        return S_OK;
    }
    return E_NOINTERFACE;
}

DataCache_IAdviseSink_Release()

static ULONG WINAPI DataCache_IAdviseSink_Release ( IAdviseSink *  iface )

static

Definition at line 2843 of file datacache.c.

{
    return 1;
}

DataCache_IDataObject_AddRef()

static ULONG WINAPI DataCache_IDataObject_AddRef ( IDataObject *  iface )

static

Definition at line 1474 of file datacache.c.

{
  DataCache *this = impl_from_IDataObject(iface);
 
  return IUnknown_AddRef(this->outer_unk);
}

DataCache_IDataObject_QueryInterface()

static HRESULT WINAPI DataCache_IDataObject_QueryInterface ( IDataObject *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1461 of file datacache.c.

{
  DataCache *this = impl_from_IDataObject(iface);
 
  return IUnknown_QueryInterface(this->outer_unk, riid, ppvObject);
}

DataCache_IDataObject_Release()

static ULONG WINAPI DataCache_IDataObject_Release ( IDataObject *  iface )

static

Definition at line 1485 of file datacache.c.

{
  DataCache *this = impl_from_IDataObject(iface);
 
  return IUnknown_Release(this->outer_unk);
}

DataCache_IDataObject_SetData()

static HRESULT WINAPI DataCache_IDataObject_SetData ( IDataObject *  iface, LPFORMATETC  pformatetc, STGMEDIUM *  pmedium, BOOL  fRelease  )

static

Definition at line 1556 of file datacache.c.

{
  IOleCache2* oleCache = NULL;
  HRESULT     hres;
 
  TRACE("(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
 
  hres = IDataObject_QueryInterface(iface, &IID_IOleCache2, (void**)&oleCache);
 
  if (FAILED(hres))
    return E_UNEXPECTED;
 
  hres = IOleCache2_SetData(oleCache, pformatetc, pmedium, fRelease);
 
  IOleCache2_Release(oleCache);
 
  return hres;
}

DataCache_InitCache()

static HRESULT WINAPI DataCache_InitCache ( IOleCache2 *  iface, IDataObject *  data  )

static

Definition at line 2569 of file datacache.c.

{
    TRACE( "(%p %p)\n", iface, data );
    return IOleCache2_UpdateCache( iface, data, UPDFCACHE_ALLBUTNODATACACHE, NULL );
}

DataCache_InitNew()

static HRESULT WINAPI DataCache_InitNew ( IPersistStorage *  iface, IStorage *  pStg  )

static

Definition at line 1716 of file datacache.c.

{
    DataCache *This = impl_from_IPersistStorage(iface);
    CLSID clsid;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", iface, pStg);
 
    if (This->presentationStorage != NULL)
        return CO_E_ALREADYINITIALIZED;
 
    This->presentationStorage = pStg;
 
    IStorage_AddRef(This->presentationStorage);
    This->dirty = TRUE;
    ReadClassStg( pStg, &clsid );
    hr = create_automatic_entry( This, &clsid );
    if (FAILED(hr))
    {
        IStorage_Release( pStg );
        This->presentationStorage = NULL;
        return hr;
    }
    This->clsid = clsid;
 
    return S_OK;
}

DataCache_IOleCache2_AddRef()

static ULONG WINAPI DataCache_IOleCache2_AddRef ( IOleCache2 *  iface )

static

Definition at line 2400 of file datacache.c.

{
  DataCache *this = impl_from_IOleCache2(iface);
 
  return IUnknown_AddRef(this->outer_unk);
}

DataCache_IOleCache2_QueryInterface()

static HRESULT WINAPI DataCache_IOleCache2_QueryInterface ( IOleCache2 *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2387 of file datacache.c.

{
  DataCache *this = impl_from_IOleCache2(iface);
 
  return IUnknown_QueryInterface(this->outer_unk, riid, ppvObject);
}

DataCache_IOleCache2_Release()

static ULONG WINAPI DataCache_IOleCache2_Release ( IOleCache2 *  iface )

static

Definition at line 2411 of file datacache.c.

{
  DataCache *this = impl_from_IOleCache2(iface);
 
  return IUnknown_Release(this->outer_unk);
}

DataCache_IOleCache2_SetData()

static HRESULT WINAPI DataCache_IOleCache2_SetData ( IOleCache2 *  iface, FORMATETC *  pformatetc, STGMEDIUM *  pmedium, BOOL  fRelease  )

static

Definition at line 2575 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2(iface);
    DataCacheEntry *cache_entry;
    HRESULT hr;
 
    TRACE("(%p, %p, %s)\n", pformatetc, pmedium, fRelease ? "TRUE" : "FALSE");
    TRACE("formatetc = %s\n", debugstr_formatetc(pformatetc));
 
    cache_entry = DataCache_GetEntryForFormatEtc(This, pformatetc);
    if (cache_entry)
    {
        hr = DataCacheEntry_SetData(cache_entry, pformatetc, pmedium, fRelease);
 
        if (SUCCEEDED(hr))
            DataCache_FireOnViewChange(This, cache_entry->fmtetc.dwAspect,
                                       cache_entry->fmtetc.lindex);
 
        return hr;
    }
    WARN("cache entry not found\n");
 
    return OLE_E_BLANK;
}

DataCache_IOleCacheControl_AddRef()

static ULONG WINAPI DataCache_IOleCacheControl_AddRef ( IOleCacheControl *  iface )

static

Definition at line 2747 of file datacache.c.

{
  DataCache *this = impl_from_IOleCacheControl(iface);
 
  return IUnknown_AddRef(this->outer_unk);
}

DataCache_IOleCacheControl_QueryInterface()

static HRESULT WINAPI DataCache_IOleCacheControl_QueryInterface ( IOleCacheControl *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 2734 of file datacache.c.

{
  DataCache *this = impl_from_IOleCacheControl(iface);
 
  return IUnknown_QueryInterface(this->outer_unk, riid, ppvObject);
}

DataCache_IOleCacheControl_Release()

static ULONG WINAPI DataCache_IOleCacheControl_Release ( IOleCacheControl *  iface )

static

Definition at line 2758 of file datacache.c.

{
  DataCache *this = impl_from_IOleCacheControl(iface);
 
  return IUnknown_Release(this->outer_unk);
}

DataCache_IPersistStorage_AddRef()

static ULONG WINAPI DataCache_IPersistStorage_AddRef ( IPersistStorage *  iface )

static

Definition at line 1656 of file datacache.c.

{
  DataCache *this = impl_from_IPersistStorage(iface);
 
  return IUnknown_AddRef(this->outer_unk);
}

DataCache_IPersistStorage_QueryInterface()

static HRESULT WINAPI DataCache_IPersistStorage_QueryInterface ( IPersistStorage *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1643 of file datacache.c.

{
  DataCache *this = impl_from_IPersistStorage(iface);
 
  return IUnknown_QueryInterface(this->outer_unk, riid, ppvObject);
}

DataCache_IPersistStorage_Release()

static ULONG WINAPI DataCache_IPersistStorage_Release ( IPersistStorage *  iface )

static

Definition at line 1667 of file datacache.c.

{
  DataCache *this = impl_from_IPersistStorage(iface);
 
  return IUnknown_Release(this->outer_unk);
}

DataCache_IsDirty()

static HRESULT WINAPI DataCache_IsDirty ( IPersistStorage *  iface )

static

Definition at line 1692 of file datacache.c.

{
    DataCache *This = impl_from_IPersistStorage(iface);
    DataCacheEntry *cache_entry;
 
    TRACE("(%p)\n", iface);
 
    if (This->dirty)
        return S_OK;
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
        if (cache_entry->dirty)
            return S_OK;
 
    return S_FALSE;
}

DataCache_IViewObject2_AddRef()

static ULONG WINAPI DataCache_IViewObject2_AddRef ( IViewObject2 *  iface )

static

Definition at line 1981 of file datacache.c.

{
  DataCache *this = impl_from_IViewObject2(iface);
 
  return IUnknown_AddRef(this->outer_unk);
}

DataCache_IViewObject2_QueryInterface()

static HRESULT WINAPI DataCache_IViewObject2_QueryInterface ( IViewObject2 *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1968 of file datacache.c.

{
  DataCache *this = impl_from_IViewObject2(iface);
 
  return IUnknown_QueryInterface(this->outer_unk, riid, ppvObject);
}

DataCache_IViewObject2_Release()

static ULONG WINAPI DataCache_IViewObject2_Release ( IViewObject2 *  iface )

static

Definition at line 1992 of file datacache.c.

{
  DataCache *this = impl_from_IViewObject2(iface);
 
  return IUnknown_Release(this->outer_unk);
}

DataCache_Load()

static HRESULT WINAPI DataCache_Load ( IPersistStorage *  iface, IStorage *  stg  )

static

Definition at line 1832 of file datacache.c.

{
    DataCache *This = impl_from_IPersistStorage(iface);
    HRESULT hr;
    CLSID clsid;
    DataCacheEntry *entry, *cursor2;
 
    TRACE("(%p, %p)\n", iface, stg);
 
    IPersistStorage_HandsOffStorage( iface );
 
    LIST_FOR_EACH_ENTRY_SAFE( entry, cursor2, &This->cache_list, DataCacheEntry, entry )
        DataCacheEntry_Destroy( This, entry );
    This->clsid = CLSID_NULL;
 
    ReadClassStg( stg, &clsid );
    hr = create_automatic_entry( This, &clsid );
    if (FAILED( hr )) return hr;
 
    This->clsid = clsid;
 
    if (This->clsid_static)
    {
        hr = parse_contents_stream( This, stg );
        if (FAILED(hr)) hr = parse_pres_streams( This, stg );
    }
    else
        hr = parse_pres_streams( This, stg );
 
    if (SUCCEEDED( hr ))
    {
        This->dirty = FALSE;
        This->presentationStorage = stg;
        IStorage_AddRef( This->presentationStorage );
    }
 
    return hr;
}

Referenced by DataCache_SaveCompleted().

DataCache_NDIUnknown_AddRef()

static ULONG WINAPI DataCache_NDIUnknown_AddRef ( IUnknown *  iface )

static

Definition at line 1427 of file datacache.c.

{
  DataCache *this = impl_from_IUnknown(iface);
  return InterlockedIncrement(&this->ref);
}

DataCache_NDIUnknown_QueryInterface()

static HRESULT WINAPI DataCache_NDIUnknown_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 1367 of file datacache.c.

{
  DataCache *this = impl_from_IUnknown(iface);
 
  if ( ppvObject==0 )
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualIID(&IID_IUnknown, riid))
  {
    if (this->outer_unk == iface) /* non-aggregated, return IUnknown from IOleCache2 */
      *ppvObject = &this->IOleCache2_iface;
    else
      *ppvObject = iface;
  }
  else if (IsEqualIID(&IID_IDataObject, riid))
  {
    *ppvObject = &this->IDataObject_iface;
  }
  else if ( IsEqualIID(&IID_IPersistStorage, riid)  ||
            IsEqualIID(&IID_IPersist, riid) )
  {
    *ppvObject = &this->IPersistStorage_iface;
  }
  else if ( IsEqualIID(&IID_IViewObject, riid) ||
            IsEqualIID(&IID_IViewObject2, riid) )
  {
    *ppvObject = &this->IViewObject2_iface;
  }
  else if ( IsEqualIID(&IID_IOleCache, riid) ||
            IsEqualIID(&IID_IOleCache2, riid) )
  {
    *ppvObject = &this->IOleCache2_iface;
  }
  else if ( IsEqualIID(&IID_IOleCacheControl, riid) )
  {
    *ppvObject = &this->IOleCacheControl_iface;
  }
 
  if ((*ppvObject)==0)
  {
    WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
  }
 
  IUnknown_AddRef((IUnknown*)*ppvObject);
 
  return S_OK;
}

DataCache_NDIUnknown_Release()

static ULONG WINAPI DataCache_NDIUnknown_Release ( IUnknown *  iface )

static

Definition at line 1440 of file datacache.c.

{
  DataCache *this = impl_from_IUnknown(iface);
  ULONG ref;
 
  ref = InterlockedDecrement(&this->ref);
 
  if (ref == 0) DataCache_Destroy(this);
 
  return ref;
}

DataCache_OnClose()

static void WINAPI DataCache_OnClose ( IAdviseSink *  iface )

static

Definition at line 2870 of file datacache.c.

{
    FIXME("stub\n");
}

DataCache_OnDataChange()

static void WINAPI DataCache_OnDataChange ( IAdviseSink *  iface, FORMATETC *  fmt, STGMEDIUM *  med  )

static

Definition at line 2848 of file datacache.c.

{
    DataCache *This = impl_from_IAdviseSink(iface);
    TRACE("(%p)->(%s, %p)\n", This, debugstr_formatetc(fmt), med);
    IOleCache2_SetData(&This->IOleCache2_iface, fmt, med, FALSE);
}

DataCache_OnRename()

static void WINAPI DataCache_OnRename ( IAdviseSink *  iface, IMoniker *  mk  )

static

Definition at line 2860 of file datacache.c.

{
    FIXME("stub\n");
}

DataCache_OnRun()

static HRESULT WINAPI DataCache_OnRun ( IOleCacheControl *  iface, IDataObject *  data_obj  )

static

Definition at line 2769 of file datacache.c.

{
    DataCache *This = impl_from_IOleCacheControl(iface);
    DataCacheEntry *cache_entry;
 
    TRACE("(%p)->(%p)\n", iface, data_obj);
 
    if(This->running_object) return S_OK;
 
    /* No reference is taken on the data object */
    This->running_object = data_obj;
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        setup_sink(This, cache_entry);
    }
 
    return S_OK;
}

DataCache_OnSave()

static void WINAPI DataCache_OnSave ( IAdviseSink *  iface )

static

Definition at line 2865 of file datacache.c.

{
    FIXME("stub\n");
}

DataCache_OnStop()

static HRESULT WINAPI DataCache_OnStop ( IOleCacheControl *  iface )

static

Definition at line 2792 of file datacache.c.

{
    DataCache *This = impl_from_IOleCacheControl(iface);
    DataCacheEntry *cache_entry;
 
    TRACE("(%p)\n", iface);
 
    if(!This->running_object) return S_OK;
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        if(cache_entry->sink_id)
        {
            IDataObject_DUnadvise(This->running_object, cache_entry->sink_id);
            cache_entry->sink_id = 0;
        }
    }
 
    /* No ref taken in OnRun, so no Release call here */
    This->running_object = NULL;
    return S_OK;
}

DataCache_OnViewChange()

static void WINAPI DataCache_OnViewChange ( IAdviseSink *  iface, DWORD  aspect, LONG  index  )

static

Definition at line 2855 of file datacache.c.

{
    FIXME("stub\n");
}

DataCache_QueryGetData()

static HRESULT WINAPI DataCache_QueryGetData ( IDataObject *  iface, FORMATETC *  fmt  )

static

Definition at line 1526 of file datacache.c.

{
    DataCache *This = impl_from_IDataObject( iface );
    DataCacheEntry *cache_entry;
 
    TRACE( "(%p)->(%s)\n", iface, debugstr_formatetc( fmt ) );
    cache_entry = DataCache_GetEntryForFormatEtc( This, fmt );
 
    return cache_entry ? S_OK : S_FALSE;
}

DataCache_Save()

static HRESULT WINAPI DataCache_Save ( IPersistStorage *  iface, IStorage *  stg, BOOL  same_as_load  )

static

Definition at line 1879 of file datacache.c.

{
    DataCache *This = impl_from_IPersistStorage(iface);
    DataCacheEntry *cache_entry;
    HRESULT hr = S_OK;
    int stream_number = 0;
 
    TRACE("(%p, %p, %d)\n", iface, stg, same_as_load);
 
    /* assign stream numbers to the cache entries */
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        if (cache_entry->save_stream_num != stream_number)
        {
            cache_entry->dirty = TRUE; /* needs to be written out again */
            cache_entry->save_stream_num = stream_number;
        }
        stream_number++;
    }
 
    /* write out the cache entries */
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
    {
        if (!same_as_load || cache_entry->dirty)
        {
            hr = DataCacheEntry_Save(cache_entry, stg, same_as_load);
            if (FAILED(hr))
                break;
 
            if (same_as_load) cache_entry->dirty = FALSE;
        }
    }
 
    if (same_as_load) This->dirty = FALSE;
    return hr;
}

Referenced by DataCache_DiscardCache().

DataCache_SaveCompleted()

static HRESULT WINAPI DataCache_SaveCompleted ( IPersistStorage *  iface, IStorage *  pStgNew  )

static

Definition at line 1922 of file datacache.c.

{
  TRACE("(%p, %p)\n", iface, pStgNew);
 
  if (pStgNew)
  {
    IPersistStorage_HandsOffStorage(iface);
 
    DataCache_Load(iface, pStgNew);
  }
 
  return S_OK;
}

DataCache_SetAdvise()

static HRESULT WINAPI DataCache_SetAdvise ( IViewObject2 *  iface, DWORD  aspects, DWORD  advf, IAdviseSink *  pAdvSink  )

static

Definition at line 2181 of file datacache.c.

{
  DataCache *this = impl_from_IViewObject2(iface);
 
  TRACE("(%p, %x, %x, %p)\n", iface, aspects, advf, pAdvSink);
 
  /*
   * A call to this function removes the previous sink
   */
  if (this->sinkInterface != NULL)
  {
    IAdviseSink_Release(this->sinkInterface);
    this->sinkInterface  = NULL;
    this->sinkAspects    = 0;
    this->sinkAdviseFlag = 0;
  }
 
  /*
   * Now, setup the new one.
   */
  if (pAdvSink!=NULL)
  {
    this->sinkInterface  = pAdvSink;
    this->sinkAspects    = aspects;
    this->sinkAdviseFlag = advf;
 
    IAdviseSink_AddRef(this->sinkInterface);
  }
 
  /*
   * When the ADVF_PRIMEFIRST flag is set, we have to advise the
   * sink immediately.
   */
  if (advf & ADVF_PRIMEFIRST)
  {
    DataCache_FireOnViewChange(this, aspects, -1);
  }
 
  return S_OK;
}

DataCache_Uncache()

static HRESULT WINAPI DataCache_Uncache ( IOleCache2 *  iface, DWORD  dwConnection  )

static

Definition at line 2494 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2(iface);
    DataCacheEntry *cache_entry;
 
    TRACE("(%d)\n", dwConnection);
 
    LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
        if (cache_entry->id == dwConnection)
        {
            DataCacheEntry_Destroy(This, cache_entry);
            return S_OK;
        }
 
    WARN("no connection found for %d\n", dwConnection);
 
    return OLE_E_NOCONNECTION;
}

DataCache_Unfreeze()

static HRESULT WINAPI DataCache_Unfreeze ( IViewObject2 *  iface, DWORD  dwFreeze  )

static

Definition at line 2167 of file datacache.c.

{
  FIXME("stub\n");
  return E_NOTIMPL;
}

DataCache_UpdateCache()

static HRESULT WINAPI DataCache_UpdateCache ( IOleCache2 *  iface, IDataObject *  data, DWORD  mode, void *  reserved  )

static

Definition at line 2619 of file datacache.c.

{
    DataCache *This = impl_from_IOleCache2(iface);
    DataCacheEntry *cache_entry;
    STGMEDIUM med;
    HRESULT hr = S_OK;
    CLIPFORMAT view_list[] = { CF_METAFILEPICT, CF_ENHMETAFILE, CF_DIB, CF_BITMAP };
    FORMATETC fmt;
    int i, slots = 0;
    BOOL done_one = FALSE;
 
    TRACE( "(%p %p %08x %p)\n", iface, data, mode, reserved );
 
    LIST_FOR_EACH_ENTRY( cache_entry, &This->cache_list, DataCacheEntry, entry )
    {
        slots++;
 
        if (!entry_updatable( cache_entry, mode ))
        {
            done_one = TRUE;
            continue;
        }
 
        fmt = cache_entry->fmtetc;
 
        if (fmt.cfFormat)
        {
            hr = IDataObject_GetData( data, &fmt, &med );
            if (hr != S_OK && fmt.cfFormat == CF_DIB)
            {
                fmt.cfFormat = CF_BITMAP;
                fmt.tymed = TYMED_GDI;
                hr = IDataObject_GetData( data, &fmt, &med );
            }
            if (hr != S_OK && fmt.cfFormat == CF_ENHMETAFILE)
            {
                fmt.cfFormat = CF_METAFILEPICT;
                fmt.tymed = TYMED_MFPICT;
                hr = IDataObject_GetData( data, &fmt, &med );
            }
            if (hr == S_OK)
            {
                hr = DataCacheEntry_SetData( cache_entry, &fmt, &med, TRUE );
                if (hr != S_OK) ReleaseStgMedium( &med );
                else done_one = TRUE;
            }
        }
        else
        {
            for (i = 0; i < ARRAY_SIZE(view_list); i++)
            {
                fmt.cfFormat = view_list[i];
                fmt.tymed = tymed_from_cf( fmt.cfFormat );
                hr = IDataObject_QueryGetData( data, &fmt );
                if (hr == S_OK)
                {
                    hr = IDataObject_GetData( data, &fmt, &med );
                    if (hr == S_OK)
                    {
                        if (fmt.cfFormat == CF_BITMAP)
                        {
                            cache_entry->fmtetc.cfFormat = CF_DIB;
                            cache_entry->fmtetc.tymed = TYMED_HGLOBAL;
                        }
                        else
                        {
                            cache_entry->fmtetc.cfFormat = fmt.cfFormat;
                            cache_entry->fmtetc.tymed = fmt.tymed;
                        }
                        hr = DataCacheEntry_SetData( cache_entry, &fmt, &med, TRUE );
                        if (hr != S_OK) ReleaseStgMedium( &med );
                        else done_one = TRUE;
                        break;
                    }
                }
            }
        }
    }
 
    return (!slots || done_one) ? S_OK : CACHE_E_NOCACHE_UPDATED;
}

DataCacheEntry_Destroy()

static void DataCacheEntry_Destroy ( DataCache *  cache, DataCacheEntry *  cache_entry  )

static

Definition at line 252 of file datacache.c.

{
    list_remove(&cache_entry->entry);
    CoTaskMemFree(cache_entry->fmtetc.ptd);
    ReleaseStgMedium(&cache_entry->stgmedium);
    if(cache_entry->sink_id)
        IDataObject_DUnadvise(cache->running_object, cache_entry->sink_id);
 
    HeapFree(GetProcessHeap(), 0, cache_entry);
}

Referenced by DataCache_Destroy(), DataCache_Load(), and DataCache_Uncache().

DataCacheEntry_DiscardData()

static HRESULT DataCacheEntry_DiscardData ( DataCacheEntry *  cache_entry )

inlinestatic

Definition at line 1286 of file datacache.c.

{
    ReleaseStgMedium(&cache_entry->stgmedium);
    return S_OK;
}

Referenced by add_cache_entry(), and DataCache_DiscardCache().

DataCacheEntry_GetData()

static HRESULT DataCacheEntry_GetData ( DataCacheEntry *  cache_entry, IStorage *  stg, FORMATETC *  fmt, STGMEDIUM *  stgmedium  )

static

Definition at line 1269 of file datacache.c.

{
    if (cache_entry->stgmedium.tymed == TYMED_NULL && cache_entry->load_stream_num != STREAM_NUMBER_NOT_SET)
    {
        HRESULT hr = DataCacheEntry_LoadData(cache_entry, stg);
        if (FAILED(hr))
            return hr;
    }
    if (cache_entry->stgmedium.tymed == TYMED_NULL)
        return OLE_E_BLANK;
 
    if (fmt->cfFormat == CF_BITMAP)
        return synthesize_bitmap( cache_entry->stgmedium.u.hGlobal, stgmedium );
 
    return copy_stg_medium(cache_entry->fmtetc.cfFormat, stgmedium, &cache_entry->stgmedium);
}

Referenced by DataCache_GetData().

DataCacheEntry_LoadData()

static HRESULT DataCacheEntry_LoadData ( DataCacheEntry *  cache_entry, IStorage *  stg  )

static

Definition at line 831 of file datacache.c.

{
    HRESULT hr;
    IStream *stm;
 
    if (!stg) return OLE_E_BLANK;
    hr = open_pres_stream( stg, cache_entry->load_stream_num, &stm );
    if (FAILED(hr)) return hr;
 
    switch (cache_entry->fmtetc.cfFormat)
    {
    case CF_METAFILEPICT:
        hr = load_mf_pict( cache_entry, stm );
        break;
 
    case CF_DIB:
        hr = load_dib( cache_entry, stm );
        break;
 
    case CF_ENHMETAFILE:
        hr = load_emf( cache_entry, stm );
        break;
 
    default:
        FIXME( "Unimplemented clip format %x\n", cache_entry->fmtetc.cfFormat );
        hr = E_NOTIMPL;
    }
 
    IStream_Release( stm );
    return hr;
}

Referenced by DataCache_Draw(), DataCache_GetExtent(), and DataCacheEntry_GetData().

DataCacheEntry_Save()

static HRESULT DataCacheEntry_Save ( DataCacheEntry *  cache_entry, IStorage *  storage, BOOL  same_as_load  )

static

Definition at line 1101 of file datacache.c.

{
    HRESULT hr;
    IStream *stream;
    BOOL contents = (cache_entry->id == 1);
 
    TRACE("stream_number = %d, fmtetc = %s\n", cache_entry->save_stream_num, debugstr_formatetc(&cache_entry->fmtetc));
 
    hr = create_stream(cache_entry, storage, contents, &stream);
    if (FAILED(hr))
        return hr;
 
    switch (cache_entry->fmtetc.cfFormat)
    {
    case CF_DIB:
        hr = save_dib(cache_entry, contents, stream);
        break;
    case CF_METAFILEPICT:
        hr = save_mfpict(cache_entry, contents, stream);
        break;
    case CF_ENHMETAFILE:
        hr = save_emf(cache_entry, contents, stream);
        break;
    case 0:
        hr = save_view_cache(cache_entry, stream);
        break;
    default:
        FIXME("got unsupported clipboard format %x\n", cache_entry->fmtetc.cfFormat);
    }
 
    IStream_Release(stream);
    return hr;
}

Referenced by DataCache_Save().

DataCacheEntry_SetData()

static HRESULT DataCacheEntry_SetData ( DataCacheEntry *  cache_entry, const FORMATETC *  formatetc, STGMEDIUM *  stgmedium, BOOL  fRelease  )

static

Definition at line 1224 of file datacache.c.

{
    STGMEDIUM copy;
    HRESULT hr;
 
    if ((!cache_entry->fmtetc.cfFormat && !formatetc->cfFormat) ||
        (cache_entry->fmtetc.tymed == TYMED_NULL && formatetc->tymed == TYMED_NULL) ||
        stgmedium->tymed == TYMED_NULL)
    {
        WARN("invalid formatetc\n");
        return DV_E_FORMATETC;
    }
 
    cache_entry->dirty = TRUE;
    ReleaseStgMedium(&cache_entry->stgmedium);
 
    if (formatetc->cfFormat == CF_BITMAP)
    {
        hr = synthesize_dib( stgmedium->u.hBitmap, &copy );
        if (FAILED(hr)) return hr;
        if (fRelease) ReleaseStgMedium(stgmedium);
        stgmedium = ©
        fRelease = TRUE;
    }
    else if (formatetc->cfFormat == CF_METAFILEPICT && cache_entry->fmtetc.cfFormat == CF_ENHMETAFILE)
    {
        hr = synthesize_emf( stgmedium->u.hMetaFilePict, &copy );
        if (FAILED(hr)) return hr;
        if (fRelease) ReleaseStgMedium(stgmedium);
        stgmedium = ©
        fRelease = TRUE;
    }
 
    if (fRelease)
    {
        cache_entry->stgmedium = *stgmedium;
        return S_OK;
    }
    else
        return copy_stg_medium(cache_entry->fmtetc.cfFormat, &cache_entry->stgmedium, stgmedium);
}

Referenced by DataCache_IOleCache2_SetData(), and DataCache_UpdateCache().

debugstr_formatetc()

const char * debugstr_formatetc

(

const FORMATETC *

formatetc

)

Definition at line 216 of file datacache.c.

{
    return wine_dbg_sprintf("{ cfFormat = 0x%x, ptd = %p, dwAspect = %d, lindex = %d, tymed = %d }",
        formatetc->cfFormat, formatetc->ptd, formatetc->dwAspect,
        formatetc->lindex, formatetc->tymed);
}

Referenced by add_cache_entry(), DataCache_Cache(), DataCache_GetData(), DataCache_IOleCache2_SetData(), DataCache_OnDataChange(), DataCache_QueryGetData(), DataCacheEntry_Save(), and OleCreateFromFileEx().

entry_updatable()

static BOOL entry_updatable ( DataCacheEntry *  entry, DWORD  mode  )

static

Definition at line 2604 of file datacache.c.

{
    BOOL is_blank = entry->stgmedium.tymed == TYMED_NULL;
 
    if ((mode & UPDFCACHE_ONLYIFBLANK) && !is_blank) return FALSE;
 
    if ((mode & UPDFCACHE_NODATACACHE) && (entry->advise_flags & ADVF_NODATA)) return TRUE;
    if ((mode & UPDFCACHE_ONSAVECACHE) && (entry->advise_flags & ADVFCACHE_ONSAVE)) return TRUE;
    if ((mode & UPDFCACHE_ONSTOPCACHE) && (entry->advise_flags & ADVF_DATAONSTOP)) return TRUE;
    if ((mode & UPDFCACHE_NORMALCACHE) && (entry->advise_flags == 0)) return TRUE;
    if ((mode & UPDFCACHE_IFBLANK) && (is_blank && !(entry->advise_flags & ADVF_NODATA))) return TRUE;
 
    return FALSE;
}

Referenced by DataCache_UpdateCache().

get_static_entry()

static HRESULT get_static_entry ( DataCache *  cache, DataCacheEntry **  cache_entry  )

static

Definition at line 316 of file datacache.c.

{
    DataCacheEntry *entry;
    struct list *head = list_head( &cache->cache_list );
    HRESULT hr = E_FAIL;
 
    *cache_entry = NULL;
 
    if (head)
    {
        entry = LIST_ENTRY( head, DataCacheEntry, entry );
        if (entry->id == 1)
        {
            *cache_entry = entry;
            hr = S_OK;
        }
    }
 
    return hr;
}

Referenced by parse_contents_stream().

impl_from_IAdviseSink()

static DataCache * impl_from_IAdviseSink ( IAdviseSink *  iface )

inlinestatic

Definition at line 211 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IAdviseSink_iface);
}

Referenced by DataCache_OnDataChange().

impl_from_IDataObject()

static DataCache * impl_from_IDataObject ( IDataObject *  iface )

inlinestatic

Definition at line 181 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IDataObject_iface);
}

Referenced by DataCache_GetData(), DataCache_IDataObject_AddRef(), DataCache_IDataObject_QueryInterface(), DataCache_IDataObject_Release(), and DataCache_QueryGetData().

impl_from_IOleCache2()

static DataCache * impl_from_IOleCache2 ( IOleCache2 *  iface )

inlinestatic

Definition at line 201 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IOleCache2_iface);
}

Referenced by DataCache_Cache(), DataCache_DiscardCache(), DataCache_EnumCache(), DataCache_IOleCache2_AddRef(), DataCache_IOleCache2_QueryInterface(), DataCache_IOleCache2_Release(), DataCache_IOleCache2_SetData(), DataCache_Uncache(), and DataCache_UpdateCache().

impl_from_IOleCacheControl()

static DataCache * impl_from_IOleCacheControl ( IOleCacheControl *  iface )

inlinestatic

Definition at line 206 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IOleCacheControl_iface);
}

Referenced by DataCache_IOleCacheControl_AddRef(), DataCache_IOleCacheControl_QueryInterface(), DataCache_IOleCacheControl_Release(), DataCache_OnRun(), and DataCache_OnStop().

impl_from_IPersistStorage()

static DataCache * impl_from_IPersistStorage ( IPersistStorage *  iface )

inlinestatic

Definition at line 191 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IPersistStorage_iface);
}

Referenced by DataCache_GetClassID(), DataCache_HandsOffStorage(), DataCache_InitNew(), DataCache_IPersistStorage_AddRef(), DataCache_IPersistStorage_QueryInterface(), DataCache_IPersistStorage_Release(), DataCache_IsDirty(), DataCache_Load(), and DataCache_Save().

impl_from_IUnknown()

static DataCache * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 186 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IUnknown_inner);
}

Referenced by DataCache_NDIUnknown_AddRef(), DataCache_NDIUnknown_QueryInterface(), and DataCache_NDIUnknown_Release().

impl_from_IViewObject2()

static DataCache * impl_from_IViewObject2 ( IViewObject2 *  iface )

inlinestatic

Definition at line 196 of file datacache.c.

{
    return CONTAINING_RECORD(iface, DataCache, IViewObject2_iface);
}

Referenced by DataCache_Draw(), DataCache_GetAdvise(), DataCache_GetExtent(), DataCache_IViewObject2_AddRef(), DataCache_IViewObject2_QueryInterface(), DataCache_IViewObject2_Release(), and DataCache_SetAdvise().

init_cache_entry()

static BOOL init_cache_entry ( DataCacheEntry *  entry, const FORMATETC *  fmt, DWORD  advf, DWORD  id  )

static

Definition at line 361 of file datacache.c.

{
    HRESULT hr;
 
    hr = copy_formatetc(&entry->fmtetc, fmt);
    if (FAILED(hr)) return FALSE;
 
    entry->stgmedium.tymed = TYMED_NULL;
    entry->stgmedium.pUnkForRelease = NULL;
    entry->id = id;
    entry->dirty = TRUE;
    entry->load_stream_num = STREAM_NUMBER_NOT_SET;
    entry->save_stream_num = STREAM_NUMBER_NOT_SET;
    entry->sink_id = 0;
    entry->advise_flags = advf;
 
    return TRUE;
}

Referenced by DataCache_CreateEntry().

init_stream_header()

static void init_stream_header ( DataCacheEntry *  entry, PresentationDataHeader *  header  )

static

Definition at line 863 of file datacache.c.

{
    if (entry->fmtetc.ptd)
        FIXME("ptd not serialized\n");
    header->tdSize = sizeof(header->tdSize);
    header->dvAspect = entry->fmtetc.dwAspect;
    header->lindex = entry->fmtetc.lindex;
    header->advf = entry->advise_flags;
    header->unknown7 = 0;
    header->dwObjectExtentX = 0;
    header->dwObjectExtentY = 0;
    header->dwSize = 0;
}

Referenced by save_dib(), save_emf(), save_mfpict(), and save_view_cache().

load_dib()

static HRESULT load_dib ( DataCacheEntry *  cache_entry, IStream *  stm  )

static

Definition at line 666 of file datacache.c.

{
    HRESULT hr;
    STATSTG stat;
    BYTE *dib;
    HGLOBAL hglobal;
    ULONG read, info_size, bi_size;
    BITMAPFILEHEADER file;
    BITMAPINFOHEADER *info;
    CLIPFORMAT cf;
    PresentationDataHeader pres;
    ULARGE_INTEGER current_pos;
    static const LARGE_INTEGER offset_zero;
 
    hr = IStream_Stat( stm, &stat, STATFLAG_NONAME );
    if (FAILED( hr )) return hr;
 
    if (cache_entry->load_stream_num != STREAM_NUMBER_CONTENTS)
    {
        hr = read_clipformat( stm, &cf );
        if (hr != S_OK) return hr;
        hr = IStream_Read( stm, &pres, sizeof(pres), &read );
        if (hr != S_OK) return hr;
    }
    else
    {
        hr = IStream_Read( stm, &file, sizeof(BITMAPFILEHEADER), &read );
        if (hr != S_OK) return hr;
    }
 
    hr = IStream_Seek( stm, offset_zero, STREAM_SEEK_CUR, &current_pos );
    if (FAILED( hr )) return hr;
    stat.cbSize.QuadPart -= current_pos.QuadPart;
 
    hglobal = GlobalAlloc( GMEM_MOVEABLE, stat.cbSize.u.LowPart );
    if (!hglobal) return E_OUTOFMEMORY;
    dib = GlobalLock( hglobal );
 
    /* read first DWORD of BITMAPINFOHEADER */
    hr = IStream_Read( stm, dib, sizeof(DWORD), &read );
    if (hr != S_OK) goto fail;
    bi_size = *(DWORD *)dib;
    if (stat.cbSize.QuadPart < bi_size) goto fail;
 
    /* read rest of BITMAPINFOHEADER */
    hr = IStream_Read( stm, dib + sizeof(DWORD), bi_size - sizeof(DWORD), &read );
    if (hr != S_OK) goto fail;
 
    info_size = bitmap_info_size( (BITMAPINFO *)dib, DIB_RGB_COLORS );
    if (stat.cbSize.QuadPart < info_size) goto fail;
    if (info_size > bi_size)
    {
        hr = IStream_Read( stm, dib + bi_size, info_size - bi_size, &read );
        if (hr != S_OK) goto fail;
    }
    stat.cbSize.QuadPart -= info_size;
 
    /* set Stream pointer to beginning of bitmap bits */
    if (cache_entry->load_stream_num == STREAM_NUMBER_CONTENTS && file.bfOffBits)
    {
        LARGE_INTEGER skip;
 
        skip.QuadPart = file.bfOffBits - sizeof(file) - info_size;
        if (stat.cbSize.QuadPart < skip.QuadPart) goto fail;
        hr = IStream_Seek( stm, skip, STREAM_SEEK_CUR, NULL );
        if (hr != S_OK) goto fail;
        stat.cbSize.QuadPart -= skip.QuadPart;
    }
 
    hr = IStream_Read( stm, dib + info_size, stat.cbSize.u.LowPart, &read );
    if (hr != S_OK) goto fail;
 
    if (bi_size >= sizeof(*info))
    {
        info = (BITMAPINFOHEADER *)dib;
        if (info->biXPelsPerMeter == 0 || info->biYPelsPerMeter == 0)
        {
            HDC hdc = GetDC( 0 );
            info->biXPelsPerMeter = MulDiv( GetDeviceCaps( hdc, LOGPIXELSX ), 10000, 254 );
            info->biYPelsPerMeter = MulDiv( GetDeviceCaps( hdc, LOGPIXELSY ), 10000, 254 );
            ReleaseDC( 0, hdc );
        }
    }
 
    GlobalUnlock( hglobal );
 
    cache_entry->stgmedium.tymed = TYMED_HGLOBAL;
    cache_entry->stgmedium.u.hGlobal = hglobal;
 
    return hr;
 
fail:
    GlobalUnlock( hglobal );
    GlobalFree( hglobal );
    return hr;
 
}

Referenced by DataCacheEntry_LoadData().

load_emf()

static HRESULT load_emf ( DataCacheEntry *  cache_entry, IStream *  stm  )

static

Definition at line 764 of file datacache.c.

{
    HRESULT hr;
 
    if (cache_entry->load_stream_num != STREAM_NUMBER_CONTENTS)
    {
        STGMEDIUM stgmed;
 
        hr = load_mf_pict( cache_entry, stm );
        if (SUCCEEDED( hr ))
        {
            hr = synthesize_emf( cache_entry->stgmedium.u.hMetaFilePict, &stgmed );
            ReleaseStgMedium( &cache_entry->stgmedium );
        }
        if (SUCCEEDED( hr ))
            cache_entry->stgmedium = stgmed;
    }
    else
    {
        STATSTG stat;
        BYTE *data;
        ULONG read, size_bits;
 
        hr = IStream_Stat( stm, &stat, STATFLAG_NONAME );
 
        if (SUCCEEDED( hr ))
        {
            data = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.u.LowPart );
            if (!data) return E_OUTOFMEMORY;
 
            hr = IStream_Read( stm, data, stat.cbSize.u.LowPart, &read );
            if (hr != S_OK)
            {
                HeapFree( GetProcessHeap(), 0, data );
                return hr;
            }
 
            if (read <= sizeof(DWORD) + sizeof(ENHMETAHEADER))
            {
                HeapFree( GetProcessHeap(), 0, data );
                return E_FAIL;
            }
            size_bits = read - sizeof(DWORD) - sizeof(ENHMETAHEADER);
            cache_entry->stgmedium.u.hEnhMetaFile = SetEnhMetaFileBits( size_bits, data + (read - size_bits) );
            cache_entry->stgmedium.tymed = TYMED_ENHMF;
            cache_entry->stgmedium.pUnkForRelease = NULL;
 
            HeapFree( GetProcessHeap(), 0, data );
        }
    }
 
    return hr;
}

Referenced by DataCacheEntry_LoadData().

load_mf_pict()

static HRESULT load_mf_pict ( DataCacheEntry *  cache_entry, IStream *  stm  )

static

Definition at line 584 of file datacache.c.

{
    HRESULT hr;
    STATSTG stat;
    ULARGE_INTEGER current_pos;
    void *bits;
    METAFILEPICT *mfpict;
    HGLOBAL hmfpict;
    PresentationDataHeader header;
    CLIPFORMAT clipformat;
    static const LARGE_INTEGER offset_zero;
    ULONG read;
    struct meta_placeable mf_place;
 
    hr = IStream_Stat( stm, &stat, STATFLAG_NONAME );
    if (FAILED( hr )) return hr;
 
    if (cache_entry->load_stream_num != STREAM_NUMBER_CONTENTS)
    {
        hr = read_clipformat( stm, &clipformat );
        if (hr != S_OK) return hr;
        hr = IStream_Read( stm, &header, sizeof(header), &read );
        if (hr != S_OK) return hr;
    }
    else
    {
        hr = IStream_Read( stm, &mf_place, sizeof(mf_place), &read );
        if (hr != S_OK) return hr;
    }
 
    hr = IStream_Seek( stm, offset_zero, STREAM_SEEK_CUR, &current_pos );
    if (FAILED( hr )) return hr;
    stat.cbSize.QuadPart -= current_pos.QuadPart;
 
    hmfpict = GlobalAlloc( GMEM_MOVEABLE, sizeof(METAFILEPICT) );
    if (!hmfpict) return E_OUTOFMEMORY;
    mfpict = GlobalLock( hmfpict );
 
    bits = HeapAlloc( GetProcessHeap(), 0, stat.cbSize.u.LowPart);
    if (!bits)
    {
        GlobalFree( hmfpict );
        return E_OUTOFMEMORY;
    }
 
    hr = IStream_Read( stm, bits, stat.cbSize.u.LowPart, &read );
 
    if (SUCCEEDED( hr ))
    {
        mfpict->mm = MM_ANISOTROPIC;
        /* FIXME: get this from the stream */
        if (cache_entry->load_stream_num != STREAM_NUMBER_CONTENTS)
        {
            mfpict->xExt = header.dwObjectExtentX;
            mfpict->yExt = header.dwObjectExtentY;
        }
        else
        {
            mfpict->xExt = ((mf_place.bounding_box[2] - mf_place.bounding_box[0])
                            * 2540) / mf_place.inch;
            mfpict->yExt = ((mf_place.bounding_box[3] - mf_place.bounding_box[1])
                            * 2540) / mf_place.inch;
        }
        mfpict->hMF = SetMetaFileBitsEx( stat.cbSize.u.LowPart, bits );
        if (!mfpict->hMF)
            hr = E_FAIL;
    }
 
    GlobalUnlock( hmfpict );
    if (SUCCEEDED( hr ))
    {
        cache_entry->stgmedium.tymed = TYMED_MFPICT;
        cache_entry->stgmedium.u.hMetaFilePict = hmfpict;
    }
    else
        GlobalFree( hmfpict );
 
    HeapFree( GetProcessHeap(), 0, bits );
 
    return hr;
}

Referenced by DataCacheEntry_LoadData(), and load_emf().

open_pres_stream()

static HRESULT open_pres_stream ( IStorage *  stg, int  stream_number, IStream **  stm  )

static

Definition at line 535 of file datacache.c.

{
    WCHAR pres[] = {2,'O','l','e','P','r','e','s',
                    '0' + (stream_number / 100) % 10,
                    '0' + (stream_number / 10) % 10,
                    '0' + stream_number % 10, 0};
    const WCHAR *name = pres;
 
    if (stream_number == STREAM_NUMBER_NOT_SET) return E_FAIL;
    if (stream_number == STREAM_NUMBER_CONTENTS) name = CONTENTS;
 
    return IStorage_OpenStream( stg, name, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, stm );
}

Referenced by DataCacheEntry_LoadData(), parse_contents_stream(), and parse_pres_streams().

parse_contents_stream()

static HRESULT parse_contents_stream ( DataCache *  cache, IStorage *  stg  )

static

Definition at line 1803 of file datacache.c.

{
    HRESULT hr;
    IStream *stm;
    DataCacheEntry *cache_entry;
 
    hr = open_pres_stream( stg, STREAM_NUMBER_CONTENTS, &stm );
    if (FAILED( hr )) return hr;
 
    hr = get_static_entry( cache, &cache_entry );
    if (hr == S_OK)
    {
        cache_entry->load_stream_num = STREAM_NUMBER_CONTENTS;
        cache_entry->save_stream_num = STREAM_NUMBER_CONTENTS;
        cache_entry->dirty = FALSE;
    }
 
    IStream_Release( stm );
    return hr;
}

Referenced by DataCache_Load().

parse_pres_streams()

static HRESULT parse_pres_streams ( DataCache *  cache, IStorage *  stg  )

static

Definition at line 1767 of file datacache.c.

{
    HRESULT hr;
    IStream *stm;
    PresentationDataHeader header;
    ULONG actual_read;
    CLIPFORMAT clipformat;
    FORMATETC fmtetc;
    int stream_number = 0;
 
    do
    {
        hr = open_pres_stream( stg, stream_number, &stm );
        if (FAILED(hr)) break;
 
        hr = read_clipformat( stm, &clipformat );
 
        if (hr == S_OK) hr = IStream_Read( stm, &header, sizeof(header), &actual_read );
 
        if (hr == S_OK && actual_read == sizeof(header))
        {
            fmtetc.cfFormat = clipformat;
            fmtetc.ptd = NULL; /* FIXME */
            fmtetc.dwAspect = header.dvAspect;
            fmtetc.lindex = header.lindex;
            fmtetc.tymed = tymed_from_cf( clipformat );
 
            add_cache_entry( cache, &fmtetc, header.advf, stream_number );
        }
        IStream_Release( stm );
        stream_number++;
    } while (hr == S_OK);
 
    return S_OK;
}

Referenced by DataCache_Load().

read_clipformat()

static HRESULT read_clipformat ( IStream *  stream, CLIPFORMAT *  clipformat  )

static

Definition at line 461 of file datacache.c.

{
    DWORD length;
    HRESULT hr;
    ULONG read;
 
    *clipformat = 0;
 
    hr = IStream_Read(stream, &length, sizeof(length), &read);
    if (hr != S_OK || read != sizeof(length))
        return DV_E_CLIPFORMAT;
    if (!length) {
        /* No clipboard format present */
        return S_OK;
    }
    if (length == -1)
    {
        DWORD cf;
        hr = IStream_Read(stream, &cf, sizeof(cf), &read);
        if (hr != S_OK || read != sizeof(cf))
            return DV_E_CLIPFORMAT;
        *clipformat = cf;
    }
    else
    {
        char *format_name = HeapAlloc(GetProcessHeap(), 0, length);
        if (!format_name)
            return E_OUTOFMEMORY;
        hr = IStream_Read(stream, format_name, length, &read);
        if (hr != S_OK || read != length || format_name[length - 1] != '\0')
        {
            HeapFree(GetProcessHeap(), 0, format_name);
            return DV_E_CLIPFORMAT;
        }
        *clipformat = RegisterClipboardFormatA(format_name);
        HeapFree(GetProcessHeap(), 0, format_name);
    }
    return S_OK;
}

Referenced by load_dib(), load_mf_pict(), and parse_pres_streams().

save_dib()

static HRESULT save_dib ( DataCacheEntry *  entry, BOOL  contents, IStream *  stream  )

static

Definition at line 877 of file datacache.c.

{
    HRESULT hr = S_OK;
    int data_size = 0;
    BITMAPINFO *bmi = NULL;
 
    if (entry->stgmedium.tymed != TYMED_NULL)
    {
        data_size = GlobalSize(entry->stgmedium.u.hGlobal);
        bmi = GlobalLock(entry->stgmedium.u.hGlobal);
    }
 
    if (!contents)
    {
        PresentationDataHeader header;
 
        init_stream_header(entry, &header);
        hr = write_clipformat(stream, entry->fmtetc.cfFormat);
        if (FAILED(hr)) goto end;
        if (data_size)
        {
            header.dwSize = data_size;
            /* Size in units of 0.01mm (ie. MM_HIMETRIC) */
            if (bmi->bmiHeader.biXPelsPerMeter != 0 && bmi->bmiHeader.biYPelsPerMeter != 0)
            {
                header.dwObjectExtentX = MulDiv(bmi->bmiHeader.biWidth, 100000, bmi->bmiHeader.biXPelsPerMeter);
                header.dwObjectExtentY = MulDiv(bmi->bmiHeader.biHeight, 100000, bmi->bmiHeader.biYPelsPerMeter);
            }
            else
            {
                HDC hdc = GetDC(0);
                header.dwObjectExtentX = MulDiv(bmi->bmiHeader.biWidth, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
                header.dwObjectExtentY = MulDiv(bmi->bmiHeader.biHeight, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
                ReleaseDC(0, hdc);
            }
        }
        hr = IStream_Write(stream, &header, sizeof(PresentationDataHeader), NULL);
        if (hr == S_OK && data_size)
            hr = IStream_Write(stream, bmi, data_size, NULL);
    }
    else if(data_size)
    {
        BITMAPFILEHEADER bmp_fhdr;
 
        bmp_fhdr.bfType = 0x4d42;
        bmp_fhdr.bfSize = data_size + sizeof(BITMAPFILEHEADER);
        bmp_fhdr.bfReserved1 = bmp_fhdr.bfReserved2 = 0;
        bmp_fhdr.bfOffBits = bitmap_info_size(bmi, DIB_RGB_COLORS) + sizeof(BITMAPFILEHEADER);
        hr = IStream_Write(stream, &bmp_fhdr, sizeof(BITMAPFILEHEADER), NULL);
        if (hr == S_OK)
            hr = IStream_Write(stream, bmi, data_size, NULL);
    }
 
end:
    if (bmi) GlobalUnlock(entry->stgmedium.u.hGlobal);
    return hr;
}

Referenced by DataCacheEntry_Save().

save_emf()

static HRESULT save_emf ( DataCacheEntry *  entry, BOOL  contents, IStream *  stream  )

static

Definition at line 1016 of file datacache.c.

{
    HRESULT hr = S_OK;
    int data_size = 0;
    BYTE *data;
 
    if (!contents)
    {
        PresentationDataHeader header;
        METAFILEPICT *mfpict;
        HDC hdc = GetDC(0);
 
        init_stream_header(entry, &header);
        hr = write_clipformat(stream, entry->fmtetc.cfFormat);
        if (FAILED(hr))
        {
            ReleaseDC(0, hdc);
            return hr;
        }
        data_size = GetWinMetaFileBits(entry->stgmedium.u.hEnhMetaFile, 0, NULL, MM_ANISOTROPIC, hdc);
        header.dwSize = data_size;
        data = HeapAlloc(GetProcessHeap(), 0, header.dwSize);
        if (!data)
        {
            ReleaseDC(0, hdc);
            return E_OUTOFMEMORY;
        }
        GetWinMetaFileBits(entry->stgmedium.u.hEnhMetaFile, header.dwSize, data, MM_ANISOTROPIC, hdc);
        ReleaseDC(0, hdc);
        mfpict = (METAFILEPICT *)data;
        header.dwObjectExtentX = mfpict->xExt;
        header.dwObjectExtentY = mfpict->yExt;
        hr = IStream_Write(stream, &header, sizeof(PresentationDataHeader), NULL);
        if (hr == S_OK && data_size)
            hr = IStream_Write(stream, data, data_size, NULL);
        HeapFree(GetProcessHeap(), 0, data);
    }
    else if (entry->stgmedium.tymed != TYMED_NULL)
    {
        data_size = GetEnhMetaFileBits(entry->stgmedium.u.hEnhMetaFile, 0, NULL);
        data = HeapAlloc(GetProcessHeap(), 0, sizeof(DWORD) + sizeof(ENHMETAHEADER) + data_size);
        if (!data) return E_OUTOFMEMORY;
        *((DWORD *)data) = sizeof(ENHMETAHEADER);
        GetEnhMetaFileBits(entry->stgmedium.u.hEnhMetaFile, data_size, data + sizeof(DWORD) + sizeof(ENHMETAHEADER));
        memcpy(data + sizeof(DWORD), data + sizeof(DWORD) + sizeof(ENHMETAHEADER), sizeof(ENHMETAHEADER));
        data_size += sizeof(DWORD) + sizeof(ENHMETAHEADER);
        hr = IStream_Write(stream, data, data_size, NULL);
        HeapFree(GetProcessHeap(), 0, data);
    }
 
    return hr;
}

Referenced by DataCacheEntry_Save().

save_mfpict()

static HRESULT save_mfpict ( DataCacheEntry *  entry, BOOL  contents, IStream *  stream  )

static

Definition at line 935 of file datacache.c.

{
    HRESULT hr = S_OK;
    int data_size = 0;
    void *data = NULL;
    METAFILEPICT *mfpict = NULL;
 
    if (!contents)
    {
        PresentationDataHeader header;
 
        init_stream_header(entry, &header);
        hr = write_clipformat(stream, entry->fmtetc.cfFormat);
        if (FAILED(hr)) return hr;
        if (entry->stgmedium.tymed != TYMED_NULL)
        {
            mfpict = GlobalLock(entry->stgmedium.u.hMetaFilePict);
            if (!mfpict)
                return DV_E_STGMEDIUM;
            data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
            header.dwObjectExtentX = mfpict->xExt;
            header.dwObjectExtentY = mfpict->yExt;
            header.dwSize = data_size;
            data = HeapAlloc(GetProcessHeap(), 0, header.dwSize);
            if (!data)
            {
                GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
                return E_OUTOFMEMORY;
            }
            GetMetaFileBitsEx(mfpict->hMF, header.dwSize, data);
            GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
        }
        hr = IStream_Write(stream, &header, sizeof(PresentationDataHeader), NULL);
        if (hr == S_OK && data_size)
            hr = IStream_Write(stream, data, data_size, NULL);
        HeapFree(GetProcessHeap(), 0, data);
    }
    else if (entry->stgmedium.tymed != TYMED_NULL)
    {
        struct meta_placeable meta_place_rec;
        WORD *check;
 
        mfpict = GlobalLock(entry->stgmedium.u.hMetaFilePict);
        if (!mfpict)
            return DV_E_STGMEDIUM;
        data_size = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
        data = HeapAlloc(GetProcessHeap(), 0, data_size);
        if (!data)
        {
            GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
            return E_OUTOFMEMORY;
        }
        GetMetaFileBitsEx(mfpict->hMF, data_size, data);
 
        /* units are in 1/8th of a point (1 point is 1/72th of an inch) */
        meta_place_rec.key = 0x9ac6cdd7;
        meta_place_rec.hwmf = 0;
        meta_place_rec.inch = 576;
        meta_place_rec.bounding_box[0] = 0;
        meta_place_rec.bounding_box[1] = 0;
        meta_place_rec.bounding_box[2] = 0;
        meta_place_rec.bounding_box[3] = 0;
        meta_place_rec.checksum = 0;
        meta_place_rec.reserved = 0;
 
        /* These values are rounded down so MulDiv won't do the right thing */
        meta_place_rec.bounding_box[2] = (LONGLONG)mfpict->xExt * meta_place_rec.inch / 2540;
        meta_place_rec.bounding_box[3] = (LONGLONG)mfpict->yExt * meta_place_rec.inch / 2540;
        GlobalUnlock(entry->stgmedium.u.hMetaFilePict);
 
        for (check = (WORD *)&meta_place_rec; check != &meta_place_rec.checksum; check++)
            meta_place_rec.checksum ^= *check;
        hr = IStream_Write(stream, &meta_place_rec, sizeof(struct meta_placeable), NULL);
        if (hr == S_OK && data_size)
            hr = IStream_Write(stream, data, data_size, NULL);
        HeapFree(GetProcessHeap(), 0, data);
    }
 
    return hr;
}

Referenced by DataCacheEntry_Save().

save_view_cache()

static HRESULT save_view_cache ( DataCacheEntry *  entry, IStream *  stream  )

static

Definition at line 1069 of file datacache.c.

{
    HRESULT hr;
    PresentationDataHeader header;
 
    init_stream_header(entry, &header);
    hr = write_clipformat(stream, entry->fmtetc.cfFormat);
    if (SUCCEEDED(hr))
        hr = IStream_Write(stream, &header, FIELD_OFFSET(PresentationDataHeader, unknown7), NULL);
 
    return hr;
}

Referenced by DataCacheEntry_Save().

setup_sink()

static HRESULT setup_sink ( DataCache *  This, DataCacheEntry *  cache_entry  )

static

Definition at line 2424 of file datacache.c.

{
    HRESULT hr = S_FALSE;
    DWORD flags;
 
    /* Clear the ADVFCACHE_* bits.  Native also sets the two highest bits for some reason. */
    flags = cache_entry->advise_flags & ~(ADVFCACHE_NOHANDLER | ADVFCACHE_FORCEBUILTIN | ADVFCACHE_ONSAVE);
 
    if(This->running_object)
        if(!(flags & ADVF_NODATA))
            hr = IDataObject_DAdvise(This->running_object, &cache_entry->fmtetc, flags,
                                     &This->IAdviseSink_iface, &cache_entry->sink_id);
    return hr;
}

Referenced by DataCache_Cache(), and DataCache_OnRun().

synthesize_bitmap()

static HRESULT synthesize_bitmap ( HGLOBAL  dib, STGMEDIUM *  med  )

static

Definition at line 1203 of file datacache.c.

{
    HRESULT hr = E_FAIL;
    BITMAPINFO *bmi;
    HDC hdc = GetDC( 0 );
 
    if ((bmi = GlobalLock( dib )))
    {
        /* FIXME: validate data size */
        med->u.hBitmap = CreateDIBitmap( hdc, &bmi->bmiHeader, CBM_INIT,
                                         (char *)bmi + bitmap_info_size( bmi, DIB_RGB_COLORS ),
                                         bmi, DIB_RGB_COLORS );
        GlobalUnlock( dib );
        med->tymed = TYMED_GDI;
        med->pUnkForRelease = NULL;
        hr = S_OK;
    }
    ReleaseDC( 0, hdc );
    return hr;
}

Referenced by DataCacheEntry_GetData().

synthesize_dib()

static HRESULT synthesize_dib ( HBITMAP  bm, STGMEDIUM *  med  )

static

Definition at line 1175 of file datacache.c.

{
    HDC hdc = GetDC( 0 );
    BITMAPINFOHEADER header;
    BITMAPINFO *bmi;
    HRESULT hr = E_FAIL;
    DWORD header_size;
 
    memset( &header, 0, sizeof(header) );
    header.biSize = sizeof(header);
    if (!GetDIBits( hdc, bm, 0, 0, NULL, (BITMAPINFO *)&header, DIB_RGB_COLORS )) goto done;
 
    header_size = bitmap_info_size( (BITMAPINFO *)&header, DIB_RGB_COLORS );
    if (!(med->u.hGlobal = GlobalAlloc( GMEM_MOVEABLE, header_size + header.biSizeImage ))) goto done;
    bmi = GlobalLock( med->u.hGlobal );
    memset( bmi, 0, header_size );
    memcpy( bmi, &header, header.biSize );
    GetDIBits( hdc, bm, 0, abs(header.biHeight), (char *)bmi + header_size, bmi, DIB_RGB_COLORS );
    GlobalUnlock( med->u.hGlobal );
    med->tymed = TYMED_HGLOBAL;
    med->pUnkForRelease = NULL;
    hr = S_OK;
 
done:
    ReleaseDC( 0, hdc );
    return hr;
}

Referenced by DataCacheEntry_SetData().

synthesize_emf()

static HRESULT synthesize_emf ( HMETAFILEPICT  data, STGMEDIUM *  med  )

static

Definition at line 549 of file datacache.c.

{
    METAFILEPICT *pict;
    HRESULT hr = E_FAIL;
    UINT size;
    void *bits;
 
    if (!(pict = GlobalLock( data ))) return hr;
 
    size = GetMetaFileBitsEx( pict->hMF, 0, NULL );
    if ((bits = HeapAlloc( GetProcessHeap(), 0, size )))
    {
        GetMetaFileBitsEx( pict->hMF, size, bits );
        med->u.hEnhMetaFile = SetWinMetaFileBits( size, bits, NULL, pict );
        HeapFree( GetProcessHeap(), 0, bits );
        med->tymed = TYMED_ENHMF;
        med->pUnkForRelease = NULL;
        hr = S_OK;
    }
 
    GlobalUnlock( data );
    return hr;
}

Referenced by DataCacheEntry_SetData(), and load_emf().

tymed_from_cf()

static DWORD tymed_from_cf ( DWORD  cf )

inlinestatic

Definition at line 1292 of file datacache.c.

{
    switch( cf )
    {
    case CF_BITMAP:       return TYMED_GDI;
    case CF_METAFILEPICT: return TYMED_MFPICT;
    case CF_ENHMETAFILE:  return TYMED_ENHMF;
    case CF_DIB:
    default:              return TYMED_HGLOBAL;
    }
}

Referenced by DataCache_UpdateCache(), and parse_pres_streams().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

write_clipformat()

static HRESULT write_clipformat ( IStream *  stream, CLIPFORMAT  clipformat  )

static

Definition at line 501 of file datacache.c.

{
    DWORD length;
    HRESULT hr;
    char format_name[256];
 
    if (clipformat == 0)
        length = 0;
    else if (clipformat < 0xc000)
        length = -1;
    else
    {
        length = GetClipboardFormatNameA(clipformat, format_name, sizeof(format_name));
        /* If there is a clipboard format name, we need to include its terminating \0 */
        if (length) length++;
    }
    hr = IStream_Write(stream, &length, sizeof(length), NULL);
    if (FAILED(hr) || clipformat == 0)
        return hr;
 
    if (clipformat < 0xc000)
    {
        DWORD cf = clipformat;
        hr = IStream_Write(stream, &cf, sizeof(cf), NULL);
    }
    else
    {
        hr = IStream_Write(stream, format_name, length, NULL);
    }
    return hr;
}

Referenced by save_dib(), save_emf(), save_mfpict(), and save_view_cache().

Variable Documentation

CONTENTS

const WCHAR CONTENTS[] = {'C','O','N','T','E','N','T','S',0}

static

Definition at line 533 of file datacache.c.

Referenced by create_stream(), and open_pres_stream().

DataCache_IAdviseSink_VTable

const IAdviseSinkVtbl DataCache_IAdviseSink_VTable

static

Initial value:

=
{
    DataCache_IAdviseSink_QueryInterface,
    DataCache_IAdviseSink_AddRef,
    DataCache_IAdviseSink_Release,
    DataCache_OnDataChange,
    DataCache_OnViewChange,
    DataCache_OnRename,
    DataCache_OnSave,
    DataCache_OnClose
}

Definition at line 2952 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_IDataObject_VTable

const IDataObjectVtbl DataCache_IDataObject_VTable

static

Initial value:

=
{
  DataCache_IDataObject_QueryInterface,
  DataCache_IDataObject_AddRef,
  DataCache_IDataObject_Release,
  DataCache_GetData,
  DataCache_GetDataHere,
  DataCache_QueryGetData,
  DataCache_GetCanonicalFormatEtc,
  DataCache_IDataObject_SetData,
  DataCache_EnumFormatEtc,
  DataCache_DAdvise,
  DataCache_DUnadvise,
  DataCache_EnumDAdvise
}

Definition at line 2885 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_IOleCache2_VTable

const IOleCache2Vtbl DataCache_IOleCache2_VTable

static

Initial value:

=
{
  DataCache_IOleCache2_QueryInterface,
  DataCache_IOleCache2_AddRef,
  DataCache_IOleCache2_Release,
  DataCache_Cache,
  DataCache_Uncache,
  DataCache_EnumCache,
  DataCache_InitCache,
  DataCache_IOleCache2_SetData,
  DataCache_UpdateCache,
  DataCache_DiscardCache
}

Definition at line 2929 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_IOleCacheControl_VTable

const IOleCacheControlVtbl DataCache_IOleCacheControl_VTable

static

Initial value:

=
{
  DataCache_IOleCacheControl_QueryInterface,
  DataCache_IOleCacheControl_AddRef,
  DataCache_IOleCacheControl_Release,
  DataCache_OnRun,
  DataCache_OnStop
}

Definition at line 2943 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_IPersistStorage_VTable

const IPersistStorageVtbl DataCache_IPersistStorage_VTable

static

Initial value:

=
{
  DataCache_IPersistStorage_QueryInterface,
  DataCache_IPersistStorage_AddRef,
  DataCache_IPersistStorage_Release,
  DataCache_GetClassID,
  DataCache_IsDirty,
  DataCache_InitNew,
  DataCache_Load,
  DataCache_Save,
  DataCache_SaveCompleted,
  DataCache_HandsOffStorage
}

Definition at line 2901 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_IViewObject2_VTable

const IViewObject2Vtbl DataCache_IViewObject2_VTable

static

Initial value:

=
{
  DataCache_IViewObject2_QueryInterface,
  DataCache_IViewObject2_AddRef,
  DataCache_IViewObject2_Release,
  DataCache_Draw,
  DataCache_GetColorSet,
  DataCache_Freeze,
  DataCache_Unfreeze,
  DataCache_SetAdvise,
  DataCache_GetAdvise,
  DataCache_GetExtent
}

Definition at line 2915 of file datacache.c.

Referenced by DataCache_Construct().

DataCache_NDIUnknown_VTable

const IUnknownVtbl DataCache_NDIUnknown_VTable

static

Initial value:

=
{
  DataCache_NDIUnknown_QueryInterface,
  DataCache_NDIUnknown_AddRef,
  DataCache_NDIUnknown_Release
}

Definition at line 2878 of file datacache.c.

Referenced by DataCache_Construct().