1 /*
2 * OLE 2 Data cache
3 *
4 * Copyright 1999 Francis Beaudet
5 * Copyright 2000 Abey George
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES:
22 * The OLE2 data cache supports a whole whack of
23 * interfaces including:
24 * IDataObject, IPersistStorage, IViewObject2,
25 * IOleCache2 and IOleCacheControl.
26 *
27 * Most of the implementation details are taken from: Inside OLE
28 * second edition by Kraig Brockschmidt,
29 *
30 * NOTES
31 * - This implementation of the datacache will let your application
32 * load documents that have embedded OLE objects in them and it will
33 * also retrieve the metafile representation of those objects.
34 * - This implementation of the datacache will also allow your
35 * application to save new documents with OLE objects in them.
36 * - The main thing that it doesn't do is allow you to activate
37 * or modify the OLE objects in any way.
38 * - I haven't found any good documentation on the real usage of
39 * the streams created by the data cache. In particular, How to
40 * determine what the XXX stands for in the stream name
41 * "\002OlePresXXX". It appears to just be a counter.
42 * - Also, I don't know the real content of the presentation stream
43 * header. I was able to figure-out where the extent of the object
44 * was stored and the aspect, but that's about it.
45 */
46 #include <stdarg.h>
47 #include <string.h>
48
49 #define COBJMACROS
50 #define NONAMELESSUNION
51 #define NONAMELESSSTRUCT
52
53 #include "windef.h"
54 #include "winbase.h"
55 #include "wingdi.h"
56 #include "winuser.h"
57 #include "winerror.h"
58 #include "wine/unicode.h"
59 #include "ole2.h"
60 #include "wine/list.h"
61 #include "wine/debug.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(ole);
64
65 /****************************************************************************
66 * PresentationDataHeader
67 *
68 * This structure represents the header of the \002OlePresXXX stream in
69 * the OLE object storage.
70 */
71 typedef struct PresentationDataHeader
72 {
73 /* clipformat:
74 * - standard clipformat:
75 * DWORD length = 0xffffffff;
76 * DWORD cfFormat;
77 * - or custom clipformat:
78 * DWORD length;
79 * CHAR format_name[length]; (null-terminated)
80 */
81 DWORD unknown3; /* 4, possibly TYMED_ISTREAM */
82 DVASPECT dvAspect;
83 DWORD lindex;
84 DWORD tymed;
85 DWORD unknown7; /* 0 */
86 DWORD dwObjectExtentX;
87 DWORD dwObjectExtentY;
88 DWORD dwSize;
89 } PresentationDataHeader;
90
91 typedef struct DataCacheEntry
92 {
93 struct list entry;
94 /* format of this entry */
95 FORMATETC fmtetc;
96 /* the clipboard format of the data */
97 CLIPFORMAT data_cf;
98 /* cached data */
99 STGMEDIUM stgmedium;
100 /*
101 * This storage pointer is set through a call to
102 * IPersistStorage_Load. This is where the visual
103 * representation of the object is stored.
104 */
105 IStorage *storage;
106 /* connection ID */
107 DWORD id;
108 /* dirty flag */
109 BOOL dirty;
110 /* stream number (-1 if not set ) */
111 unsigned short stream_number;
112 } DataCacheEntry;
113
114 /****************************************************************************
115 * DataCache
116 */
117 struct DataCache
118 {
119 /*
120 * List all interface VTables here
121 */
122 const IDataObjectVtbl* lpVtbl;
123 const IUnknownVtbl* lpvtblNDIUnknown;
124 const IPersistStorageVtbl* lpvtblIPersistStorage;
125 const IViewObject2Vtbl* lpvtblIViewObject;
126 const IOleCache2Vtbl* lpvtblIOleCache2;
127 const IOleCacheControlVtbl* lpvtblIOleCacheControl;
128
129 /*
130 * Reference count of this object
131 */
132 LONG ref;
133
134 /*
135 * IUnknown implementation of the outer object.
136 */
137 IUnknown* outerUnknown;
138
139 /*
140 * The user of this object can setup ONE advise sink
141 * connection with the object. These parameters describe
142 * that connection.
143 */
144 DWORD sinkAspects;
145 DWORD sinkAdviseFlag;
146 IAdviseSink* sinkInterface;
147 IStorage *presentationStorage;
148
149 /* list of cache entries */
150 struct list cache_list;
151 /* last id assigned to an entry */
152 DWORD last_cache_id;
153 /* dirty flag */
154 BOOL dirty;
155 };
156
157 typedef struct DataCache DataCache;
158
159 /*
160 * Here, I define utility macros to help with the casting of the
161 * "this" parameter.
162 * There is a version to accommodate all of the VTables implemented
163 * by this object.
164 */
165
166 static inline DataCache *impl_from_IDataObject( IDataObject *iface )
167 {
168 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpVtbl));
169 }
170
171 static inline DataCache *impl_from_NDIUnknown( IUnknown *iface )
172 {
173 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpvtblNDIUnknown));
174 }
175
176 static inline DataCache *impl_from_IPersistStorage( IPersistStorage *iface )
177 {
178 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpvtblIPersistStorage));
179 }
180
181 static inline DataCache *impl_from_IViewObject2( IViewObject2 *iface )
182 {
183 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpvtblIViewObject));
184 }
185
186 static inline DataCache *impl_from_IOleCache2( IOleCache2 *iface )
187 {
188 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpvtblIOleCache2));
189 }
190
191 static inline DataCache *impl_from_IOleCacheControl( IOleCacheControl *iface )
192 {
193 return (DataCache *)((char*)iface - FIELD_OFFSET(DataCache, lpvtblIOleCacheControl));
194 }
195
196 static const char * debugstr_formatetc(const FORMATETC *formatetc)
197 {
198 return wine_dbg_sprintf("{ cfFormat = 0x%x, ptd = %p, dwAspect = %d, lindex = %d, tymed = %d }",
199 formatetc->cfFormat, formatetc->ptd, formatetc->dwAspect,
200 formatetc->lindex, formatetc->tymed);
201 }
202
203 /*
204 * Prototypes for the methods of the DataCache class.
205 */
206 static DataCache* DataCache_Construct(REFCLSID clsid,
207 LPUNKNOWN pUnkOuter);
208 static HRESULT DataCacheEntry_OpenPresStream(DataCacheEntry *This,
209 IStream **pStm);
210
211 static void DataCacheEntry_Destroy(DataCacheEntry *This)
212 {
213 list_remove(&This->entry);
214 if (This->storage)
215 IStorage_Release(This->storage);
216 HeapFree(GetProcessHeap(), 0, This->fmtetc.ptd);
217 ReleaseStgMedium(&This->stgmedium);
218 HeapFree(GetProcessHeap(), 0, This);
219 }
220
221 static void DataCache_Destroy(
222 DataCache* ptrToDestroy)
223 {
224 DataCacheEntry *cache_entry, *next_cache_entry;
225
226 TRACE("()\n");
227
228 if (ptrToDestroy->sinkInterface != NULL)
229 {
230 IAdviseSink_Release(ptrToDestroy->sinkInterface);
231 ptrToDestroy->sinkInterface = NULL;
232 }
233
234 LIST_FOR_EACH_ENTRY_SAFE(cache_entry, next_cache_entry, &ptrToDestroy->cache_list, DataCacheEntry, entry)
235 DataCacheEntry_Destroy(cache_entry);
236
237 /*
238 * Free the datacache pointer.
239 */
240 HeapFree(GetProcessHeap(), 0, ptrToDestroy);
241 }
242
243 static DataCacheEntry *DataCache_GetEntryForFormatEtc(DataCache *This, const FORMATETC *formatetc)
244 {
245 DataCacheEntry *cache_entry;
246 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
247 {
248 /* FIXME: also compare DVTARGETDEVICEs */
249 if ((!cache_entry->fmtetc.cfFormat || !formatetc->cfFormat || (formatetc->cfFormat == cache_entry->fmtetc.cfFormat)) &&
250 (formatetc->dwAspect == cache_entry->fmtetc.dwAspect) &&
251 (formatetc->lindex == cache_entry->fmtetc.lindex) &&
252 (!cache_entry->fmtetc.tymed || !formatetc->tymed || (formatetc->tymed == cache_entry->fmtetc.tymed)))
253 return cache_entry;
254 }
255 return NULL;
256 }
257
258 /* checks that the clipformat and tymed are valid and returns an error if they
259 * aren't and CACHE_S_NOTSUPPORTED if they are valid, but can't be rendered by
260 * DataCache_Draw */
261 static HRESULT check_valid_clipformat_and_tymed(CLIPFORMAT cfFormat, DWORD tymed)
262 {
263 if (!cfFormat || !tymed ||
264 (cfFormat == CF_METAFILEPICT && tymed == TYMED_MFPICT) ||
265 (cfFormat == CF_BITMAP && tymed == TYMED_GDI) ||
266 (cfFormat == CF_DIB && tymed == TYMED_HGLOBAL) ||
267 (cfFormat == CF_ENHMETAFILE && tymed == TYMED_ENHMF))
268 return S_OK;
269 else if (tymed == TYMED_HGLOBAL)
270 return CACHE_S_FORMATETC_NOTSUPPORTED;
271 else
272 {
273 WARN("invalid clipformat/tymed combination: %d/%d\n", cfFormat, tymed);
274 return DV_E_TYMED;
275 }
276 }
277
278 static HRESULT DataCache_CreateEntry(DataCache *This, const FORMATETC *formatetc, DataCacheEntry **cache_entry)
279 {
280 HRESULT hr;
281
282 hr = check_valid_clipformat_and_tymed(formatetc->cfFormat, formatetc->tymed);
283 if (FAILED(hr))
284 return hr;
285 if (hr == CACHE_S_FORMATETC_NOTSUPPORTED)
286 TRACE("creating unsupported format %d\n", formatetc->cfFormat);
287
288 *cache_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(**cache_entry));
289 if (!*cache_entry)
290 return E_OUTOFMEMORY;
291
292 (*cache_entry)->fmtetc = *formatetc;
293 if (formatetc->ptd)
294 {
295 (*cache_entry)->fmtetc.ptd = HeapAlloc(GetProcessHeap(), 0, formatetc->ptd->tdSize);
296 memcpy((*cache_entry)->fmtetc.ptd, formatetc->ptd, formatetc->ptd->tdSize);
297 }
298 (*cache_entry)->data_cf = 0;
299 (*cache_entry)->stgmedium.tymed = TYMED_NULL;
300 (*cache_entry)->stgmedium.pUnkForRelease = NULL;
301 (*cache_entry)->storage = NULL;
302 (*cache_entry)->id = This->last_cache_id++;
303 (*cache_entry)->dirty = TRUE;
304 (*cache_entry)->stream_number = -1;
305 list_add_tail(&This->cache_list, &(*cache_entry)->entry);
306 return hr;
307 }
308
309 /************************************************************************
310 * DataCache_FireOnViewChange
311 *
312 * This method will fire an OnViewChange notification to the advise
313 * sink registered with the datacache.
314 *
315 * See IAdviseSink::OnViewChange for more details.
316 */
317 static void DataCache_FireOnViewChange(
318 DataCache* this,
319 DWORD aspect,
320 LONG lindex)
321 {
322 TRACE("(%p, %x, %d)\n", this, aspect, lindex);
323
324 /*
325 * The sink supplies a filter when it registers
326 * we make sure we only send the notifications when that
327 * filter matches.
328 */
329 if ((this->sinkAspects & aspect) != 0)
330 {
331 if (this->sinkInterface != NULL)
332 {
333 IAdviseSink_OnViewChange(this->sinkInterface,
334 aspect,
335 lindex);
336
337 /*
338 * Some sinks want to be unregistered automatically when
339 * the first notification goes out.
340 */
341 if ( (this->sinkAdviseFlag & ADVF_ONLYONCE) != 0)
342 {
343 IAdviseSink_Release(this->sinkInterface);
344
345 this->sinkInterface = NULL;
346 this->sinkAspects = 0;
347 this->sinkAdviseFlag = 0;
348 }
349 }
350 }
351 }
352
353 /* Helper for DataCacheEntry_OpenPresStream */
354 static BOOL DataCache_IsPresentationStream(const STATSTG *elem)
355 {
356 /* The presentation streams have names of the form "\002OlePresXXX",
357 * where XXX goes from 000 to 999. */
358 static const WCHAR OlePres[] = { 2,'O','l','e','P','r','e','s' };
359
360 LPCWSTR name = elem->pwcsName;
361
362 return (elem->type == STGTY_STREAM)
363 && (strlenW(name) == 11)
364 && (strncmpW(name, OlePres, 8) == 0)
365 && (name[8] >= '') && (name[8] <= '9')
366 && (name[9] >= '') && (name[9] <= '9')
367 && (name[10] >= '') && (name[10] <= '9');
368 }
369
370 static HRESULT read_clipformat(IStream *stream, CLIPFORMAT *clipformat)
371 {
372 DWORD length;
373 HRESULT hr;
374 ULONG read;
375
376 *clipformat = 0;
377
378 hr = IStream_Read(stream, &length, sizeof(length), &read);
379 if (hr != S_OK || read != sizeof(length))
380 return DV_E_CLIPFORMAT;
381 if (length == -1)
382 {
383 DWORD cf;
384 hr = IStream_Read(stream, &cf, sizeof(cf), 0);
385 if (hr != S_OK || read != sizeof(cf))
386 return DV_E_CLIPFORMAT;
387 *clipformat = cf;
388 }
389 else
390 {
391 char *format_name = HeapAlloc(GetProcessHeap(), 0, length);
392 if (!format_name)
393 return E_OUTOFMEMORY;
394 hr = IStream_Read(stream, format_name, length, &read);
395 if (hr != S_OK || read != length || format_name[length - 1] != '\0')
396 {
397 HeapFree(GetProcessHeap(), 0, format_name);
398 return DV_E_CLIPFORMAT;
399 }
400 *clipformat = RegisterClipboardFormatA(format_name);
401 HeapFree(GetProcessHeap(), 0, format_name);
402 }
403 return S_OK;
404 }
405
406 static HRESULT write_clipformat(IStream *stream, CLIPFORMAT clipformat)
407 {
408 DWORD length;
409 HRESULT hr;
410
411 if (clipformat < 0xc000)
412 length = -1;
413 else
414 length = GetClipboardFormatNameA(clipformat, NULL, 0);
415 hr = IStream_Write(stream, &length, sizeof(length), NULL);
416 if (FAILED(hr))
417 return hr;
418 if (clipformat < 0xc000)
419 {
420 DWORD cf = clipformat;
421 hr = IStream_Write(stream, &cf, sizeof(cf), NULL);
422 }
423 else
424 {
425 char *format_name = HeapAlloc(GetProcessHeap(), 0, length);
426 if (!format_name)
427 return E_OUTOFMEMORY;
428 GetClipboardFormatNameA(clipformat, format_name, length);
429 hr = IStream_Write(stream, format_name, length, NULL);
430 HeapFree(GetProcessHeap(), 0, format_name);
431 }
432 return hr;
433 }
434
435 /************************************************************************
436 * DataCacheEntry_OpenPresStream
437 *
438 * This method will find the stream for the given presentation. It makes
439 * no attempt at fallback.
440 *
441 * Param:
442 * this - Pointer to the DataCache object
443 * drawAspect - The aspect of the object that we wish to draw.
444 * pStm - A returned stream. It points to the beginning of the
445 * - presentation data, including the header.
446 *
447 * Errors:
448 * S_OK The requested stream has been opened.
449 * OLE_E_BLANK The requested stream could not be found.
450 * Quite a few others I'm too lazy to map correctly.
451 *
452 * Notes:
453 * Algorithm: Scan the elements of the presentation storage, looking
454 * for presentation streams. For each presentation stream,
455 * load the header and check to see if the aspect matches.
456 *
457 * If a fallback is desired, just opening the first presentation stream
458 * is a possibility.
459 */
460 static HRESULT DataCacheEntry_OpenPresStream(
461 DataCacheEntry *This,
462 IStream **ppStm)
463 {
464 STATSTG elem;
465 IEnumSTATSTG *pEnum;
466 HRESULT hr;
467
468 if (!ppStm) return E_POINTER;
469
470 hr = IStorage_EnumElements(This->storage, 0, NULL, 0, &pEnum);
471 if (FAILED(hr)) return hr;
472
473 while ((hr = IEnumSTATSTG_Next(pEnum, 1, &elem, NULL)) == S_OK)
474 {
475 if (DataCache_IsPresentationStream(&elem))
476 {
477 IStream *pStm;
478
479 hr = IStorage_OpenStream(This->storage, elem.pwcsName,
480 NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0,
481 &pStm);
482 if (SUCCEEDED(hr))
483 {
484 PresentationDataHeader header;
485 ULONG actual_read;
486 CLIPFORMAT clipformat;
487
488 hr = read_clipformat(pStm, &clipformat);
489
490 if (hr == S_OK)
491 hr = IStream_Read(pStm, &header, sizeof(header), &actual_read);
492
493 /* can't use SUCCEEDED(hr): S_FALSE counts as an error */
494 if (hr == S_OK && actual_read == sizeof(header)
495 && header.dvAspect == This->fmtetc.dwAspect)
496 {
497 /* Rewind the stream before returning it. */
498 LARGE_INTEGER offset;
499 offset.u.LowPart = 0;
500 offset.u.HighPart = 0;
501 IStream_Seek(pStm, offset, STREAM_SEEK_SET, NULL);
502
503 *ppStm = pStm;
504
505 CoTaskMemFree(elem.pwcsName);
506 IEnumSTATSTG_Release(pEnum);
507
508 return S_OK;
509 }
510
511 IStream_Release(pStm);
512 }
513 }
514
515 CoTaskMemFree(elem.pwcsName);
516 }
517
518 IEnumSTATSTG_Release(pEnum);
519
520 return (hr == S_FALSE ? OLE_E_BLANK : hr);
521 }
522
523 /************************************************************************
524 * DataCacheEntry_LoadData
525 *
526 * This method will read information for the requested presentation
527 * into the given structure.
528 *
529 * Param:
530 * This - The entry to load the data from.
531 *
532 * Returns:
533 * This method returns a metafile handle if it is successful.
534 * it will return 0 if not.
535 */
536 static HRESULT DataCacheEntry_LoadData(DataCacheEntry *This)
537 {
538 IStream* presStream = NULL;
539 HRESULT hres;
540 ULARGE_INTEGER current_pos;
541 STATSTG streamInfo;
542 void* metafileBits;
543 METAFILEPICT *mfpict;
544 HGLOBAL hmfpict;
545 PresentationDataHeader header;
546 CLIPFORMAT clipformat;
547 static const LARGE_INTEGER offset_zero;
548
549 /*
550 * Open the presentation stream.
551 */
552 hres = DataCacheEntry_OpenPresStream(
553 This,
554 &presStream);
555
556 if (FAILED(hres))
557 return hres;
558
559 /*
560 * Get the size of the stream.
561 */
562 hres = IStream_Stat(presStream,
563 &streamInfo,
564 STATFLAG_NONAME);
565
566 /*
567 * Read the header.
568 */
569
570 hres = read_clipformat(presStream, &clipformat);
571 if (FAILED(hres))
572 {
573 IStream_Release(presStream);
574 return hres;
575 }
576
577 hres = IStream_Read(
578 presStream,
579 &header,
580 sizeof(PresentationDataHeader),
581 NULL);
582 if (hres != S_OK)
583 {
584 IStream_Release(presStream);
585 return E_FAIL;
586 }
587
588 hres = IStream_Seek(presStream, offset_zero, STREAM_SEEK_CUR, ¤t_pos);
589
590 streamInfo.cbSize.QuadPart -= current_pos.QuadPart;
591
592 hmfpict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
593 if (!hmfpict)
594 {
595 IStream_Release(presStream);
596 return E_OUTOFMEMORY;
597 }
598 mfpict = GlobalLock(hmfpict);
599
600 /*
601 * Allocate a buffer for the metafile bits.
602 */
603 metafileBits = HeapAlloc(GetProcessHeap(),
604 0,
605 streamInfo.cbSize.u.LowPart);
606
607 /*
608 * Read the metafile bits.
609 */
610 hres = IStream_Read(
611 presStream,
612 metafileBits,
613 streamInfo.cbSize.u.LowPart,
614 NULL);
615
616 /*
617 * Create a metafile with those bits.
618 */
619 if (SUCCEEDED(hres))
620 {
621 /* FIXME: get this from the stream */
622 mfpict->mm = MM_ANISOTROPIC;
623 mfpict->xExt = header.dwObjectExtentX;
624 mfpict->yExt = header.dwObjectExtentY;
625 mfpict->hMF = SetMetaFileBitsEx(streamInfo.cbSize.u.LowPart, metafileBits);
626 if (!mfpict->hMF)
627 hres = E_FAIL;
628 }
629
630 GlobalUnlock(hmfpict);
631 if (SUCCEEDED(hres))
632 {
633 This->data_cf = This->fmtetc.cfFormat;
634 This->stgmedium.tymed = TYMED_MFPICT;
635 This->stgmedium.u.hMetaFilePict = hmfpict;
636 }
637 else
638 GlobalFree(hmfpict);
639
640 /*
641 * Cleanup.
642 */
643 HeapFree(GetProcessHeap(), 0, metafileBits);
644 IStream_Release(presStream);
645
646 return hres;
647 }
648
649 static HRESULT DataCacheEntry_CreateStream(DataCacheEntry *This,
650 IStorage *storage, IStream **stream)
651 {
652 HRESULT hr;
653 WCHAR wszName[] = {2,'O','l','e','P','r','e','s',
654 '' + (This->stream_number / 100) % 10,
655 '' + (This->stream_number / 10) % 10,
656 '' + This->stream_number % 10, 0};
657
658 /* FIXME: cache the created stream in This? */
659 hr = IStorage_CreateStream(storage, wszName,
660 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
661 0, 0, stream);
662 return hr;
663 }
664
665 static HRESULT DataCacheEntry_Save(DataCacheEntry *This, IStorage *storage,
666 BOOL same_as_load)
667 {
668 PresentationDataHeader header;
669 HRESULT hr;
670 IStream *pres_stream;
671 void *data = NULL;
672
673 TRACE("stream_number = %d, fmtetc = %s\n", This->stream_number, debugstr_formatetc(&This->fmtetc));
674
675 hr = DataCacheEntry_CreateStream(This, storage, &pres_stream);
676 if (FAILED(hr))
677 return hr;
678
679 hr = write_clipformat(pres_stream, This->data_cf);
680 if (FAILED(hr))
681 return hr;
682
683 if (This->fmtetc.ptd)
684 FIXME("ptd not serialized\n");
685 header.unknown3 = 4;
686 header.dvAspect = This->fmtetc.dwAspect;
687 header.lindex = This->fmtetc.lindex;
688 header.tymed = This->stgmedium.tymed;
689 header.unknown7 = 0;
690 header.dwObjectExtentX = 0;
691 header.dwObjectExtentY = 0;
692 header.dwSize = 0;
693
694 /* size the data */
695 switch (This->data_cf)
696 {
697 case CF_METAFILEPICT:
698 {
699 if (This->stgmedium.tymed != TYMED_NULL)
700 {
701 const METAFILEPICT *mfpict = GlobalLock(This->stgmedium.u.hMetaFilePict);
702 if (!mfpict)
703 {
704 IStream_Release(pres_stream);
705 return DV_E_STGMEDIUM;
706 }
707 header.dwObjectExtentX = mfpict->xExt;
708 header.dwObjectExtentY = mfpict->yExt;
709 header.dwSize = GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
710 GlobalUnlock(This->stgmedium.u.hMetaFilePict);
711 }
712 break;
713 }
714 default:
715 break;
716 }
717
718 /*
719 * Write the header.
720 */
721 hr = IStream_Write(pres_stream, &header, sizeof(PresentationDataHeader),
722 NULL);
723 if (FAILED(hr))
724 {
725 IStream_Release(pres_stream);
726 return hr;
727 }
728
729 /* get the data */
730 switch (This->data_cf)
731 {
732 case CF_METAFILEPICT:
733 {
734 if (This->stgmedium.tymed != TYMED_NULL)
735 {
736 const METAFILEPICT *mfpict = GlobalLock(This->stgmedium.u.hMetaFilePict);
737 if (!mfpict)
738 {
739 IStream_Release(pres_stream);
740 return DV_E_STGMEDIUM;
741 }
742 data = HeapAlloc(GetProcessHeap(), 0, header.dwSize);
743 GetMetaFileBitsEx(mfpict->hMF, header.dwSize, data);
744 GlobalUnlock(This->stgmedium.u.hMetaFilePict);
745 }
746 break;
747 }
748 default:
749 break;
750 }
751
752 if (data)
753 hr = IStream_Write(pres_stream, data, header.dwSize, NULL);
754 HeapFree(GetProcessHeap(), 0, data);
755
756 IStream_Release(pres_stream);
757 return hr;
758 }
759
760 /* helper for copying STGMEDIUM of type bitmap, MF, EMF or HGLOBAL.
761 * does no checking of whether src_stgm has a supported tymed, so this should be
762 * done in the caller */
763 static HRESULT copy_stg_medium(CLIPFORMAT cf, STGMEDIUM *dest_stgm,
764 const STGMEDIUM *src_stgm)
765 {
766 if (src_stgm->tymed == TYMED_MFPICT)
767 {
768 const METAFILEPICT *src_mfpict = GlobalLock(src_stgm->u.hMetaFilePict);
769 METAFILEPICT *dest_mfpict;
770
771 if (!src_mfpict)
772 return DV_E_STGMEDIUM;
773 dest_stgm->u.hMetaFilePict = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
774 dest_mfpict = GlobalLock(dest_stgm->u.hMetaFilePict);
775 if (!dest_mfpict)
776 {
777 GlobalUnlock(src_stgm->u.hMetaFilePict);
778 return E_OUTOFMEMORY;
779 }
780 *dest_mfpict = *src_mfpict;
781 dest_mfpict->hMF = CopyMetaFileW(src_mfpict->hMF, NULL);
782 GlobalUnlock(src_stgm->u.hMetaFilePict);
783 GlobalUnlock(dest_stgm->u.hMetaFilePict);
784 }
785 else if (src_stgm->tymed != TYMED_NULL)
786 {
787 dest_stgm->u.hGlobal = OleDuplicateData(src_stgm->u.hGlobal, cf,
788 GMEM_MOVEABLE);
789 if (!dest_stgm->u.hGlobal)
790 return E_OUTOFMEMORY;
791 }
792 dest_stgm->tymed = src_stgm->tymed;
793 dest_stgm->pUnkForRelease = src_stgm->pUnkForRelease;
794 if (dest_stgm->pUnkForRelease)
795 IUnknown_AddRef(dest_stgm->pUnkForRelease);
796 return S_OK;
797 }
798
799 static HRESULT DataCacheEntry_SetData(DataCacheEntry *This,
800 const FORMATETC *formatetc,
801 const STGMEDIUM *stgmedium,
802 BOOL fRelease)
803 {
804 if ((!This->fmtetc.cfFormat && !formatetc->cfFormat) ||
805 (This->fmtetc.tymed == TYMED_NULL && formatetc->tymed == TYMED_NULL) ||
806 stgmedium->tymed == TYMED_NULL)
807 {
808 WARN("invalid formatetc\n");
809 return DV_E_FORMATETC;
810 }
811
812 This->dirty = TRUE;
813 ReleaseStgMedium(&This->stgmedium);
814 This->data_cf = This->fmtetc.cfFormat ? This->fmtetc.cfFormat : formatetc->cfFormat;
815 if (fRelease)
816 {
817 This->stgmedium = *stgmedium;
818 return S_OK;
819 }
820 else
821 return copy_stg_medium(This->data_cf,
822 &This->stgmedium, stgmedium);
823 }
824
825 static HRESULT DataCacheEntry_GetData(DataCacheEntry *This,
826 STGMEDIUM *stgmedium)
827 {
828 if (stgmedium->tymed == TYMED_NULL && This->storage)
829 {
830 HRESULT hr = DataCacheEntry_LoadData(This);
831 if (FAILED(hr))
832 return hr;
833 }
834 if (This->stgmedium.tymed == TYMED_NULL)
835 return OLE_E_BLANK;
836 return copy_stg_medium(This->data_cf, stgmedium, &This->stgmedium);
837 }
838
839 static inline HRESULT DataCacheEntry_DiscardData(DataCacheEntry *This)
840 {
841 ReleaseStgMedium(&This->stgmedium);
842 This->data_cf = This->fmtetc.cfFormat;
843 return S_OK;
844 }
845
846 static inline void DataCacheEntry_HandsOffStorage(DataCacheEntry *This)
847 {
848 if (This->storage)
849 {
850 IStorage_Release(This->storage);
851 This->storage = NULL;
852 }
853 }
854
855 /*********************************************************
856 * Method implementation for the non delegating IUnknown
857 * part of the DataCache class.
858 */
859
860 /************************************************************************
861 * DataCache_NDIUnknown_QueryInterface (IUnknown)
862 *
863 * See Windows documentation for more details on IUnknown methods.
864 *
865 * This version of QueryInterface will not delegate it's implementation
866 * to the outer unknown.
867 */
868 static HRESULT WINAPI DataCache_NDIUnknown_QueryInterface(
869 IUnknown* iface,
870 REFIID riid,
871 void** ppvObject)
872 {
873 DataCache *this = impl_from_NDIUnknown(iface);
874
875 /*
876 * Perform a sanity check on the parameters.
877 */
878 if ( (this==0) || (ppvObject==0) )
879 return E_INVALIDARG;
880
881 /*
882 * Initialize the return parameter.
883 */
884 *ppvObject = 0;
885
886 /*
887 * Compare the riid with the interface IDs implemented by this object.
888 */
889 if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
890 {
891 *ppvObject = iface;
892 }
893 else if (memcmp(&IID_IDataObject, riid, sizeof(IID_IDataObject)) == 0)
894 {
895 *ppvObject = &this->lpVtbl;
896 }
897 else if ( (memcmp(&IID_IPersistStorage, riid, sizeof(IID_IPersistStorage)) == 0) ||
898 (memcmp(&IID_IPersist, riid, sizeof(IID_IPersist)) == 0) )
899 {
900 *ppvObject = &this->lpvtblIPersistStorage;
901 }
902 else if ( (memcmp(&IID_IViewObject, riid, sizeof(IID_IViewObject)) == 0) ||
903 (memcmp(&IID_IViewObject2, riid, sizeof(IID_IViewObject2)) == 0) )
904 {
905 *ppvObject = &this->lpvtblIViewObject;
906 }
907 else if ( (memcmp(&IID_IOleCache, riid, sizeof(IID_IOleCache)) == 0) ||
908 (memcmp(&IID_IOleCache2, riid, sizeof(IID_IOleCache2)) == 0) )
909 {
910 *ppvObject = &this->lpvtblIOleCache2;
911 }
912 else if (memcmp(&IID_IOleCacheControl, riid, sizeof(IID_IOleCacheControl)) == 0)
913 {
914 *ppvObject = &this->lpvtblIOleCacheControl;
915 }
916
917 /*
918 * Check that we obtained an interface.
919 */
920 if ((*ppvObject)==0)
921 {
922 WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
923 return E_NOINTERFACE;
924 }
925
926 /*
927 * Query Interface always increases the reference count by one when it is
928 * successful.
929 */
930 IUnknown_AddRef((IUnknown*)*ppvObject);
931
932 return S_OK;
933 }
934
935 /************************************************************************
936 * DataCache_NDIUnknown_AddRef (IUnknown)
937 *
938 * See Windows documentation for more details on IUnknown methods.
939 *
940 * This version of QueryInterface will not delegate it's implementation
941 * to the outer unknown.
942 */
943 static ULONG WINAPI DataCache_NDIUnknown_AddRef(
944 IUnknown* iface)
945 {
946 DataCache *this = impl_from_NDIUnknown(iface);
947 return InterlockedIncrement(&this->ref);
948 }
949
950 /************************************************************************
951 * DataCache_NDIUnknown_Release (IUnknown)
952 *
953 * See Windows documentation for more details on IUnknown methods.
954 *
955 * This version of QueryInterface will not delegate it's implementation
956 * to the outer unknown.
957 */
958 static ULONG WINAPI DataCache_NDIUnknown_Release(
959 IUnknown* iface)
960 {
961 DataCache *this = impl_from_NDIUnknown(iface);
962 ULONG ref;
963
964 /*
965 * Decrease the reference count on this object.
966 */
967 ref = InterlockedDecrement(&this->ref);
968
969 /*
970 * If the reference count goes down to 0, perform suicide.
971 */
972 if (ref == 0) DataCache_Destroy(this);
973
974 return ref;
975 }
976
977 /*********************************************************
978 * Method implementation for the IDataObject
979 * part of the DataCache class.
980 */
981
982 /************************************************************************
983 * DataCache_IDataObject_QueryInterface (IUnknown)
984 *
985 * See Windows documentation for more details on IUnknown methods.
986 */
987 static HRESULT WINAPI DataCache_IDataObject_QueryInterface(
988 IDataObject* iface,
989 REFIID riid,
990 void** ppvObject)
991 {
992 DataCache *this = impl_from_IDataObject(iface);
993
994 return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
995 }
996
997 /************************************************************************
998 * DataCache_IDataObject_AddRef (IUnknown)
999 *
1000 * See Windows documentation for more details on IUnknown methods.
1001 */
1002 static ULONG WINAPI DataCache_IDataObject_AddRef(
1003 IDataObject* iface)
1004 {
1005 DataCache *this = impl_from_IDataObject(iface);
1006
1007 return IUnknown_AddRef(this->outerUnknown);
1008 }
1009
1010 /************************************************************************
1011 * DataCache_IDataObject_Release (IUnknown)
1012 *
1013 * See Windows documentation for more details on IUnknown methods.
1014 */
1015 static ULONG WINAPI DataCache_IDataObject_Release(
1016 IDataObject* iface)
1017 {
1018 DataCache *this = impl_from_IDataObject(iface);
1019
1020 return IUnknown_Release(this->outerUnknown);
1021 }
1022
1023 /************************************************************************
1024 * DataCache_GetData
1025 *
1026 * Get Data from a source dataobject using format pformatetcIn->cfFormat
1027 * See Windows documentation for more details on GetData.
1028 */
1029 static HRESULT WINAPI DataCache_GetData(
1030 IDataObject* iface,
1031 LPFORMATETC pformatetcIn,
1032 STGMEDIUM* pmedium)
1033 {
1034 DataCache *This = impl_from_IDataObject(iface);
1035 DataCacheEntry *cache_entry;
1036
1037 memset(pmedium, 0, sizeof(*pmedium));
1038
1039 cache_entry = DataCache_GetEntryForFormatEtc(This, pformatetcIn);
1040 if (!cache_entry)
1041 return OLE_E_BLANK;
1042
1043 return DataCacheEntry_GetData(cache_entry, pmedium);
1044 }
1045
1046 static HRESULT WINAPI DataCache_GetDataHere(
1047 IDataObject* iface,
1048 LPFORMATETC pformatetc,
1049 STGMEDIUM* pmedium)
1050 {
1051 FIXME("stub\n");
1052 return E_NOTIMPL;
1053 }
1054
1055 static HRESULT WINAPI DataCache_QueryGetData(
1056 IDataObject* iface,
1057 LPFORMATETC pformatetc)
1058 {
1059 FIXME("stub\n");
1060 return E_NOTIMPL;
1061 }
1062
1063 /************************************************************************
1064 * DataCache_EnumFormatEtc (IDataObject)
1065 *
1066 * The data cache doesn't implement this method.
1067 *
1068 * See Windows documentation for more details on IDataObject methods.
1069 */
1070 static HRESULT WINAPI DataCache_GetCanonicalFormatEtc(
1071 IDataObject* iface,
1072 LPFORMATETC pformatectIn,
1073 LPFORMATETC pformatetcOut)
1074 {
1075 TRACE("()\n");
1076 return E_NOTIMPL;
1077 }
1078
1079 /************************************************************************
1080 * DataCache_IDataObject_SetData (IDataObject)
1081 *
1082 * This method is delegated to the IOleCache2 implementation.
1083 *
1084 * See Windows documentation for more details on IDataObject methods.
1085 */
1086 static HRESULT WINAPI DataCache_IDataObject_SetData(
1087 IDataObject* iface,
1088 LPFORMATETC pformatetc,
1089 STGMEDIUM* pmedium,
1090 BOOL fRelease)
1091 {
1092 IOleCache2* oleCache = NULL;
1093 HRESULT hres;
1094
1095 TRACE("(%p, %p, %p, %d)\n", iface, pformatetc, pmedium, fRelease);
1096
1097 hres = IDataObject_QueryInterface(iface, &IID_IOleCache2, (void**)&oleCache);
1098
1099 if (FAILED(hres))
1100 return E_UNEXPECTED;
1101
1102 hres = IOleCache2_SetData(oleCache, pformatetc, pmedium, fRelease);
1103
1104 IOleCache2_Release(oleCache);
1105
1106 return hres;
1107 }
1108
1109 /************************************************************************
1110 * DataCache_EnumFormatEtc (IDataObject)
1111 *
1112 * The data cache doesn't implement this method.
1113 *
1114 * See Windows documentation for more details on IDataObject methods.
1115 */
1116 static HRESULT WINAPI DataCache_EnumFormatEtc(
1117 IDataObject* iface,
1118 DWORD dwDirection,
1119 IEnumFORMATETC** ppenumFormatEtc)
1120 {
1121 TRACE("()\n");
1122 return E_NOTIMPL;
1123 }
1124
1125 /************************************************************************
1126 * DataCache_DAdvise (IDataObject)
1127 *
1128 * The data cache doesn't support connections.
1129 *
1130 * See Windows documentation for more details on IDataObject methods.
1131 */
1132 static HRESULT WINAPI DataCache_DAdvise(
1133 IDataObject* iface,
1134 FORMATETC* pformatetc,
1135 DWORD advf,
1136 IAdviseSink* pAdvSink,
1137 DWORD* pdwConnection)
1138 {
1139 TRACE("()\n");
1140 return OLE_E_ADVISENOTSUPPORTED;
1141 }
1142
1143 /************************************************************************
1144 * DataCache_DUnadvise (IDataObject)
1145 *
1146 * The data cache doesn't support connections.
1147 *
1148 * See Windows documentation for more details on IDataObject methods.
1149 */
1150 static HRESULT WINAPI DataCache_DUnadvise(
1151 IDataObject* iface,
1152 DWORD dwConnection)
1153 {
1154 TRACE("()\n");
1155 return OLE_E_NOCONNECTION;
1156 }
1157
1158 /************************************************************************
1159 * DataCache_EnumDAdvise (IDataObject)
1160 *
1161 * The data cache doesn't support connections.
1162 *
1163 * See Windows documentation for more details on IDataObject methods.
1164 */
1165 static HRESULT WINAPI DataCache_EnumDAdvise(
1166 IDataObject* iface,
1167 IEnumSTATDATA** ppenumAdvise)
1168 {
1169 TRACE("()\n");
1170 return OLE_E_ADVISENOTSUPPORTED;
1171 }
1172
1173 /*********************************************************
1174 * Method implementation for the IDataObject
1175 * part of the DataCache class.
1176 */
1177
1178 /************************************************************************
1179 * DataCache_IPersistStorage_QueryInterface (IUnknown)
1180 *
1181 * See Windows documentation for more details on IUnknown methods.
1182 */
1183 static HRESULT WINAPI DataCache_IPersistStorage_QueryInterface(
1184 IPersistStorage* iface,
1185 REFIID riid,
1186 void** ppvObject)
1187 {
1188 DataCache *this = impl_from_IPersistStorage(iface);
1189
1190 return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1191 }
1192
1193 /************************************************************************
1194 * DataCache_IPersistStorage_AddRef (IUnknown)
1195 *
1196 * See Windows documentation for more details on IUnknown methods.
1197 */
1198 static ULONG WINAPI DataCache_IPersistStorage_AddRef(
1199 IPersistStorage* iface)
1200 {
1201 DataCache *this = impl_from_IPersistStorage(iface);
1202
1203 return IUnknown_AddRef(this->outerUnknown);
1204 }
1205
1206 /************************************************************************
1207 * DataCache_IPersistStorage_Release (IUnknown)
1208 *
1209 * See Windows documentation for more details on IUnknown methods.
1210 */
1211 static ULONG WINAPI DataCache_IPersistStorage_Release(
1212 IPersistStorage* iface)
1213 {
1214 DataCache *this = impl_from_IPersistStorage(iface);
1215
1216 return IUnknown_Release(this->outerUnknown);
1217 }
1218
1219 /************************************************************************
1220 * DataCache_GetClassID (IPersistStorage)
1221 *
1222 * The data cache doesn't implement this method.
1223 *
1224 * See Windows documentation for more details on IPersistStorage methods.
1225 */
1226 static HRESULT WINAPI DataCache_GetClassID(
1227 IPersistStorage* iface,
1228 CLSID* pClassID)
1229 {
1230 DataCache *This = impl_from_IPersistStorage(iface);
1231 DataCacheEntry *cache_entry;
1232
1233 TRACE("(%p, %p)\n", iface, pClassID);
1234
1235 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1236 {
1237 if (cache_entry->storage != NULL)
1238 {
1239 STATSTG statstg;
1240 HRESULT hr = IStorage_Stat(cache_entry->storage, &statstg, STATFLAG_NONAME);
1241 if (SUCCEEDED(hr))
1242 {
1243 *pClassID = statstg.clsid;
1244 return S_OK;
1245 }
1246 }
1247 }
1248
1249 *pClassID = CLSID_NULL;
1250
1251 return S_OK;
1252 }
1253
1254 /************************************************************************
1255 * DataCache_IsDirty (IPersistStorage)
1256 *
1257 * See Windows documentation for more details on IPersistStorage methods.
1258 */
1259 static HRESULT WINAPI DataCache_IsDirty(
1260 IPersistStorage* iface)
1261 {
1262 DataCache *This = impl_from_IPersistStorage(iface);
1263 DataCacheEntry *cache_entry;
1264
1265 TRACE("(%p)\n", iface);
1266
1267 if (This->dirty)
1268 return S_OK;
1269
1270 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1271 if (cache_entry->dirty)
1272 return S_OK;
1273
1274 return S_FALSE;
1275 }
1276
1277 /************************************************************************
1278 * DataCache_InitNew (IPersistStorage)
1279 *
1280 * The data cache implementation of IPersistStorage_InitNew simply stores
1281 * the storage pointer.
1282 *
1283 * See Windows documentation for more details on IPersistStorage methods.
1284 */
1285 static HRESULT WINAPI DataCache_InitNew(
1286 IPersistStorage* iface,
1287 IStorage* pStg)
1288 {
1289 DataCache *This = impl_from_IPersistStorage(iface);
1290
1291 TRACE("(%p, %p)\n", iface, pStg);
1292
1293 if (This->presentationStorage != NULL)
1294 IStorage_Release(This->presentationStorage);
1295
1296 This->presentationStorage = pStg;
1297
1298 IStorage_AddRef(This->presentationStorage);
1299 This->dirty = TRUE;
1300
1301 return S_OK;
1302 }
1303
1304 /************************************************************************
1305 * DataCache_Load (IPersistStorage)
1306 *
1307 * The data cache implementation of IPersistStorage_Load doesn't
1308 * actually load anything. Instead, it holds on to the storage pointer
1309 * and it will load the presentation information when the
1310 * IDataObject_GetData or IViewObject2_Draw methods are called.
1311 *
1312 * See Windows documentation for more details on IPersistStorage methods.
1313 */
1314 static HRESULT WINAPI DataCache_Load(
1315 IPersistStorage* iface,
1316 IStorage* pStg)
1317 {
1318 DataCache *This = impl_from_IPersistStorage(iface);
1319 STATSTG elem;
1320 IEnumSTATSTG *pEnum;
1321 HRESULT hr;
1322
1323 TRACE("(%p, %p)\n", iface, pStg);
1324
1325 if (This->presentationStorage != NULL)
1326 IStorage_Release(This->presentationStorage);
1327
1328 This->presentationStorage = pStg;
1329
1330 hr = IStorage_EnumElements(pStg, 0, NULL, 0, &pEnum);
1331 if (FAILED(hr)) return hr;
1332
1333 while ((hr = IEnumSTATSTG_Next(pEnum, 1, &elem, NULL)) == S_OK)
1334 {
1335 if (DataCache_IsPresentationStream(&elem))
1336 {
1337 IStream *pStm;
1338
1339 hr = IStorage_OpenStream(This->presentationStorage, elem.pwcsName,
1340 NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0,
1341 &pStm);
1342 if (SUCCEEDED(hr))
1343 {
1344 PresentationDataHeader header;
1345 ULONG actual_read;
1346 CLIPFORMAT clipformat;
1347
1348 hr = read_clipformat(pStm, &clipformat);
1349
1350 if (hr == S_OK)
1351 hr = IStream_Read(pStm, &header, sizeof(header),
1352 &actual_read);
1353
1354 /* can't use SUCCEEDED(hr): S_FALSE counts as an error */
1355 if (hr == S_OK && actual_read == sizeof(header))
1356 {
1357 DataCacheEntry *cache_entry;
1358 FORMATETC fmtetc;
1359
1360 fmtetc.cfFormat = clipformat;
1361 fmtetc.ptd = NULL; /* FIXME */
1362 fmtetc.dwAspect = header.dvAspect;
1363 fmtetc.lindex = header.lindex;
1364 fmtetc.tymed = header.tymed;
1365
1366 TRACE("loading entry with formatetc: %s\n", debugstr_formatetc(&fmtetc));
1367
1368 cache_entry = DataCache_GetEntryForFormatEtc(This, &fmtetc);
1369 if (!cache_entry)
1370 hr = DataCache_CreateEntry(This, &fmtetc, &cache_entry);
1371 if (SUCCEEDED(hr))
1372 {
1373 DataCacheEntry_DiscardData(cache_entry);
1374 if (cache_entry->storage) IStorage_Release(cache_entry->storage);
1375 cache_entry->storage = pStg;
1376 IStorage_AddRef(pStg);
1377 cache_entry->dirty = FALSE;
1378 }
1379 }
1380
1381 IStream_Release(pStm);
1382 }
1383 }
1384
1385 CoTaskMemFree(elem.pwcsName);
1386 }
1387
1388 This->dirty = FALSE;
1389
1390 IEnumSTATSTG_Release(pEnum);
1391
1392 IStorage_AddRef(This->presentationStorage);
1393 return S_OK;
1394 }
1395
1396 /************************************************************************
1397 * DataCache_Save (IPersistStorage)
1398 *
1399 * Until we actually connect to a running object and retrieve new
1400 * information to it, we never have to save anything. However, it is
1401 * our responsibility to copy the information when saving to a new
1402 * storage.
1403 *
1404 * See Windows documentation for more details on IPersistStorage methods.
1405 */
1406 static HRESULT WINAPI DataCache_Save(
1407 IPersistStorage* iface,
1408 IStorage* pStg,
1409 BOOL fSameAsLoad)
1410 {
1411 DataCache *This = impl_from_IPersistStorage(iface);
1412 DataCacheEntry *cache_entry;
1413 BOOL dirty = FALSE;
1414 HRESULT hr = S_OK;
1415 unsigned short stream_number = 0;
1416
1417 TRACE("(%p, %p, %d)\n", iface, pStg, fSameAsLoad);
1418
1419 dirty = This->dirty;
1420 if (!dirty)
1421 {
1422 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1423 {
1424 dirty = cache_entry->dirty;
1425 if (dirty)
1426 break;
1427 }
1428 }
1429
1430 /* this is a shortcut if nothing changed */
1431 if (!dirty && !fSameAsLoad && This->presentationStorage)
1432 {
1433 return IStorage_CopyTo(This->presentationStorage, 0, NULL, NULL, pStg);
1434 }
1435
1436 /* assign stream numbers to the cache entries */
1437 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1438 {
1439 if (cache_entry->stream_number != stream_number)
1440 {
1441 cache_entry->dirty = TRUE; /* needs to be written out again */
1442 cache_entry->stream_number = stream_number;
1443 }
1444 stream_number++;
1445 }
1446
1447 /* write out the cache entries */
1448 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1449 {
1450 if (!fSameAsLoad || cache_entry->dirty)
1451 {
1452 hr = DataCacheEntry_Save(cache_entry, pStg, fSameAsLoad);
1453 if (FAILED(hr))
1454 break;
1455
1456 cache_entry->dirty = FALSE;
1457 }
1458 }
1459
1460 This->dirty = FALSE;
1461 return hr;
1462 }
1463
1464 /************************************************************************
1465 * DataCache_SaveCompleted (IPersistStorage)
1466 *
1467 * This method is called to tell the cache to release the storage
1468 * pointer it's currently holding.
1469 *
1470 * See Windows documentation for more details on IPersistStorage methods.
1471 */
1472 static HRESULT WINAPI DataCache_SaveCompleted(
1473 IPersistStorage* iface,
1474 IStorage* pStgNew)
1475 {
1476 TRACE("(%p, %p)\n", iface, pStgNew);
1477
1478 if (pStgNew)
1479 {
1480 /*
1481 * First, make sure we get our hands off any storage we have.
1482 */
1483
1484 IPersistStorage_HandsOffStorage(iface);
1485
1486 /*
1487 * Then, attach to the new storage.
1488 */
1489
1490 DataCache_Load(iface, pStgNew);
1491 }
1492
1493 return S_OK;
1494 }
1495
1496 /************************************************************************
1497 * DataCache_HandsOffStorage (IPersistStorage)
1498 *
1499 * This method is called to tell the cache to release the storage
1500 * pointer it's currently holding.
1501 *
1502 * See Windows documentation for more details on IPersistStorage methods.
1503 */
1504 static HRESULT WINAPI DataCache_HandsOffStorage(
1505 IPersistStorage* iface)
1506 {
1507 DataCache *this = impl_from_IPersistStorage(iface);
1508 DataCacheEntry *cache_entry;
1509
1510 TRACE("(%p)\n", iface);
1511
1512 if (this->presentationStorage != NULL)
1513 {
1514 IStorage_Release(this->presentationStorage);
1515 this->presentationStorage = NULL;
1516 }
1517
1518 LIST_FOR_EACH_ENTRY(cache_entry, &this->cache_list, DataCacheEntry, entry)
1519 DataCacheEntry_HandsOffStorage(cache_entry);
1520
1521 return S_OK;
1522 }
1523
1524 /*********************************************************
1525 * Method implementation for the IViewObject2
1526 * part of the DataCache class.
1527 */
1528
1529 /************************************************************************
1530 * DataCache_IViewObject2_QueryInterface (IUnknown)
1531 *
1532 * See Windows documentation for more details on IUnknown methods.
1533 */
1534 static HRESULT WINAPI DataCache_IViewObject2_QueryInterface(
1535 IViewObject2* iface,
1536 REFIID riid,
1537 void** ppvObject)
1538 {
1539 DataCache *this = impl_from_IViewObject2(iface);
1540
1541 return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1542 }
1543
1544 /************************************************************************
1545 * DataCache_IViewObject2_AddRef (IUnknown)
1546 *
1547 * See Windows documentation for more details on IUnknown methods.
1548 */
1549 static ULONG WINAPI DataCache_IViewObject2_AddRef(
1550 IViewObject2* iface)
1551 {
1552 DataCache *this = impl_from_IViewObject2(iface);
1553
1554 return IUnknown_AddRef(this->outerUnknown);
1555 }
1556
1557 /************************************************************************
1558 * DataCache_IViewObject2_Release (IUnknown)
1559 *
1560 * See Windows documentation for more details on IUnknown methods.
1561 */
1562 static ULONG WINAPI DataCache_IViewObject2_Release(
1563 IViewObject2* iface)
1564 {
1565 DataCache *this = impl_from_IViewObject2(iface);
1566
1567 return IUnknown_Release(this->outerUnknown);
1568 }
1569
1570 /************************************************************************
1571 * DataCache_Draw (IViewObject2)
1572 *
1573 * This method will draw the cached representation of the object
1574 * to the given device context.
1575 *
1576 * See Windows documentation for more details on IViewObject2 methods.
1577 */
1578 static HRESULT WINAPI DataCache_Draw(
1579 IViewObject2* iface,
1580 DWORD dwDrawAspect,
1581 LONG lindex,
1582 void* pvAspect,
1583 DVTARGETDEVICE* ptd,
1584 HDC hdcTargetDev,
1585 HDC hdcDraw,
1586 LPCRECTL lprcBounds,
1587 LPCRECTL lprcWBounds,
1588 BOOL (CALLBACK *pfnContinue)(ULONG_PTR dwContinue),
1589 ULONG_PTR dwContinue)
1590 {
1591 DataCache *This = impl_from_IViewObject2(iface);
1592 HRESULT hres;
1593 DataCacheEntry *cache_entry;
1594
1595 TRACE("(%p, %x, %d, %p, %p, %p, %p, %p, %p, %lx)\n",
1596 iface,
1597 dwDrawAspect,
1598 lindex,
1599 pvAspect,
1600 hdcTargetDev,
1601 hdcDraw,
1602 lprcBounds,
1603 lprcWBounds,
1604 pfnContinue,
1605 dwContinue);
1606
1607 /*
1608 * Sanity check
1609 */
1610 if (lprcBounds==NULL)
1611 return E_INVALIDARG;
1612
1613 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1614 {
1615 /* FIXME: compare ptd too */
1616 if ((cache_entry->fmtetc.dwAspect != dwDrawAspect) ||
1617 (cache_entry->fmtetc.lindex != lindex))
1618 continue;
1619
1620 /* if the data hasn't been loaded yet, do it now */
1621 if ((cache_entry->stgmedium.tymed == TYMED_NULL) && cache_entry->storage)
1622 {
1623 hres = DataCacheEntry_LoadData(cache_entry);
1624 if (FAILED(hres))
1625 continue;
1626 }
1627
1628 /* no data */
1629 if (cache_entry->stgmedium.tymed == TYMED_NULL)
1630 continue;
1631
1632 switch (cache_entry->data_cf)
1633 {
1634 case CF_METAFILEPICT:
1635 {
1636 /*
1637 * We have to be careful not to modify the state of the
1638 * DC.
1639 */
1640 INT prevMapMode;
1641 SIZE oldWindowExt;
1642 SIZE oldViewportExt;
1643 POINT oldViewportOrg;
1644 METAFILEPICT *mfpict;
1645
1646 if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
1647 !((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
1648 continue;
1649
1650 prevMapMode = SetMapMode(hdcDraw, mfpict->mm);
1651
1652 SetWindowExtEx(hdcDraw,
1653 mfpict->xExt,
1654 mfpict->yExt,
1655 &oldWindowExt);
1656
1657 SetViewportExtEx(hdcDraw,
1658 lprcBounds->right - lprcBounds->left,
1659 lprcBounds->bottom - lprcBounds->top,
1660 &oldViewportExt);
1661
1662 SetViewportOrgEx(hdcDraw,
1663 lprcBounds->left,
1664 lprcBounds->top,
1665 &oldViewportOrg);
1666
1667 PlayMetaFile(hdcDraw, mfpict->hMF);
1668
1669 SetWindowExtEx(hdcDraw,
1670 oldWindowExt.cx,
1671 oldWindowExt.cy,
1672 NULL);
1673
1674 SetViewportExtEx(hdcDraw,
1675 oldViewportExt.cx,
1676 oldViewportExt.cy,
1677 NULL);
1678
1679 SetViewportOrgEx(hdcDraw,
1680 oldViewportOrg.x,
1681 oldViewportOrg.y,
1682 NULL);
1683
1684 SetMapMode(hdcDraw, prevMapMode);
1685
1686 GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
1687
1688 return S_OK;
1689 }
1690 }
1691 }
1692
1693 WARN("no data could be found to be drawn\n");
1694
1695 return OLE_E_BLANK;
1696 }
1697
1698 static HRESULT WINAPI DataCache_GetColorSet(
1699 IViewObject2* iface,
1700 DWORD dwDrawAspect,
1701 LONG lindex,
1702 void* pvAspect,
1703 DVTARGETDEVICE* ptd,
1704 HDC hicTargetDevice,
1705 LOGPALETTE** ppColorSet)
1706 {
1707 FIXME("stub\n");
1708 return E_NOTIMPL;
1709 }
1710
1711 static HRESULT WINAPI DataCache_Freeze(
1712 IViewObject2* iface,
1713 DWORD dwDrawAspect,
1714 LONG lindex,
1715 void* pvAspect,
1716 DWORD* pdwFreeze)
1717 {
1718 FIXME("stub\n");
1719 return E_NOTIMPL;
1720 }
1721
1722 static HRESULT WINAPI DataCache_Unfreeze(
1723 IViewObject2* iface,
1724 DWORD dwFreeze)
1725 {
1726 FIXME("stub\n");
1727 return E_NOTIMPL;
1728 }
1729
1730 /************************************************************************
1731 * DataCache_SetAdvise (IViewObject2)
1732 *
1733 * This sets-up an advisory sink with the data cache. When the object's
1734 * view changes, this sink is called.
1735 *
1736 * See Windows documentation for more details on IViewObject2 methods.
1737 */
1738 static HRESULT WINAPI DataCache_SetAdvise(
1739 IViewObject2* iface,
1740 DWORD aspects,
1741 DWORD advf,
1742 IAdviseSink* pAdvSink)
1743 {
1744 DataCache *this = impl_from_IViewObject2(iface);
1745
1746 TRACE("(%p, %x, %x, %p)\n", iface, aspects, advf, pAdvSink);
1747
1748 /*
1749 * A call to this function removes the previous sink
1750 */
1751 if (this->sinkInterface != NULL)
1752 {
1753 IAdviseSink_Release(this->sinkInterface);
1754 this->sinkInterface = NULL;
1755 this->sinkAspects = 0;
1756 this->sinkAdviseFlag = 0;
1757 }
1758
1759 /*
1760 * Now, setup the new one.
1761 */
1762 if (pAdvSink!=NULL)
1763 {
1764 this->sinkInterface = pAdvSink;
1765 this->sinkAspects = aspects;
1766 this->sinkAdviseFlag = advf;
1767
1768 IAdviseSink_AddRef(this->sinkInterface);
1769 }
1770
1771 /*
1772 * When the ADVF_PRIMEFIRST flag is set, we have to advise the
1773 * sink immediately.
1774 */
1775 if (advf & ADVF_PRIMEFIRST)
1776 {
1777 DataCache_FireOnViewChange(this, aspects, -1);
1778 }
1779
1780 return S_OK;
1781 }
1782
1783 /************************************************************************
1784 * DataCache_GetAdvise (IViewObject2)
1785 *
1786 * This method queries the current state of the advise sink
1787 * installed on the data cache.
1788 *
1789 * See Windows documentation for more details on IViewObject2 methods.
1790 */
1791 static HRESULT WINAPI DataCache_GetAdvise(
1792 IViewObject2* iface,
1793 DWORD* pAspects,
1794 DWORD* pAdvf,
1795 IAdviseSink** ppAdvSink)
1796 {
1797 DataCache *this = impl_from_IViewObject2(iface);
1798
1799 TRACE("(%p, %p, %p, %p)\n", iface, pAspects, pAdvf, ppAdvSink);
1800
1801 /*
1802 * Just copy all the requested values.
1803 */
1804 if (pAspects!=NULL)
1805 *pAspects = this->sinkAspects;
1806
1807 if (pAdvf!=NULL)
1808 *pAdvf = this->sinkAdviseFlag;
1809
1810 if (ppAdvSink!=NULL)
1811 {
1812 if (this->sinkInterface != NULL)
1813 IAdviseSink_QueryInterface(this->sinkInterface,
1814 &IID_IAdviseSink,
1815 (void**)ppAdvSink);
1816 else *ppAdvSink = NULL;
1817 }
1818
1819 return S_OK;
1820 }
1821
1822 /************************************************************************
1823 * DataCache_GetExtent (IViewObject2)
1824 *
1825 * This method retrieves the "natural" size of this cached object.
1826 *
1827 * See Windows documentation for more details on IViewObject2 methods.
1828 */
1829 static HRESULT WINAPI DataCache_GetExtent(
1830 IViewObject2* iface,
1831 DWORD dwDrawAspect,
1832 LONG lindex,
1833 DVTARGETDEVICE* ptd,
1834 LPSIZEL lpsizel)
1835 {
1836 DataCache *This = impl_from_IViewObject2(iface);
1837 HRESULT hres = E_FAIL;
1838 DataCacheEntry *cache_entry;
1839
1840 TRACE("(%p, %x, %d, %p, %p)\n",
1841 iface, dwDrawAspect, lindex, ptd, lpsizel);
1842
1843 /*
1844 * Sanity check
1845 */
1846 if (lpsizel==NULL)
1847 return E_POINTER;
1848
1849 /*
1850 * Initialize the out parameter.
1851 */
1852 lpsizel->cx = 0;
1853 lpsizel->cy = 0;
1854
1855 /*
1856 * This flag should be set to -1.
1857 */
1858 if (lindex!=-1)
1859 FIXME("Unimplemented flag lindex = %d\n", lindex);
1860
1861 /*
1862 * Right now, we support only the callback from
1863 * the default handler.
1864 */
1865 if (ptd!=NULL)
1866 FIXME("Unimplemented ptd = %p\n", ptd);
1867
1868 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
1869 {
1870 /* FIXME: compare ptd too */
1871 if ((cache_entry->fmtetc.dwAspect != dwDrawAspect) ||
1872 (cache_entry->fmtetc.lindex != lindex))
1873 continue;
1874
1875 /* if the data hasn't been loaded yet, do it now */
1876 if ((cache_entry->stgmedium.tymed == TYMED_NULL) && cache_entry->storage)
1877 {
1878 hres = DataCacheEntry_LoadData(cache_entry);
1879 if (FAILED(hres))
1880 continue;
1881 }
1882
1883 /* no data */
1884 if (cache_entry->stgmedium.tymed == TYMED_NULL)
1885 continue;
1886
1887
1888 switch (cache_entry->data_cf)
1889 {
1890 case CF_METAFILEPICT:
1891 {
1892 METAFILEPICT *mfpict;
1893
1894 if ((cache_entry->stgmedium.tymed != TYMED_MFPICT) ||
1895 !((mfpict = GlobalLock(cache_entry->stgmedium.u.hMetaFilePict))))
1896 continue;
1897
1898 lpsizel->cx = mfpict->xExt;
1899 lpsizel->cy = mfpict->yExt;
1900
1901 GlobalUnlock(cache_entry->stgmedium.u.hMetaFilePict);
1902
1903 return S_OK;
1904 }
1905 }
1906 }
1907
1908 WARN("no data could be found to get the extents from\n");
1909
1910 /*
1911 * This method returns OLE_E_BLANK when it fails.
1912 */
1913 return OLE_E_BLANK;
1914 }
1915
1916
1917 /*********************************************************
1918 * Method implementation for the IOleCache2
1919 * part of the DataCache class.
1920 */
1921
1922 /************************************************************************
1923 * DataCache_IOleCache2_QueryInterface (IUnknown)
1924 *
1925 * See Windows documentation for more details on IUnknown methods.
1926 */
1927 static HRESULT WINAPI DataCache_IOleCache2_QueryInterface(
1928 IOleCache2* iface,
1929 REFIID riid,
1930 void** ppvObject)
1931 {
1932 DataCache *this = impl_from_IOleCache2(iface);
1933
1934 return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
1935 }
1936
1937 /************************************************************************
1938 * DataCache_IOleCache2_AddRef (IUnknown)
1939 *
1940 * See Windows documentation for more details on IUnknown methods.
1941 */
1942 static ULONG WINAPI DataCache_IOleCache2_AddRef(
1943 IOleCache2* iface)
1944 {
1945 DataCache *this = impl_from_IOleCache2(iface);
1946
1947 return IUnknown_AddRef(this->outerUnknown);
1948 }
1949
1950 /************************************************************************
1951 * DataCache_IOleCache2_Release (IUnknown)
1952 *
1953 * See Windows documentation for more details on IUnknown methods.
1954 */
1955 static ULONG WINAPI DataCache_IOleCache2_Release(
1956 IOleCache2* iface)
1957 {
1958 DataCache *this = impl_from_IOleCache2(iface);
1959
1960 return IUnknown_Release(this->outerUnknown);
1961 }
1962
1963 static HRESULT WINAPI DataCache_Cache(
1964 IOleCache2* iface,
1965 FORMATETC* pformatetc,
1966 DWORD advf,
1967 DWORD* pdwConnection)
1968 {
1969 DataCache *This = impl_from_IOleCache2(iface);
1970 DataCacheEntry *cache_entry;
1971 HRESULT hr;
1972
1973 TRACE("(%p, 0x%x, %p)\n", pformatetc, advf, pdwConnection);
1974
1975 if (!pformatetc || !pdwConnection)
1976 return E_INVALIDARG;
1977
1978 TRACE("pformatetc = %s\n", debugstr_formatetc(pformatetc));
1979
1980 *pdwConnection = 0;
1981
1982 cache_entry = DataCache_GetEntryForFormatEtc(This, pformatetc);
1983 if (cache_entry)
1984 {
1985 TRACE("found an existing cache entry\n");
1986 *pdwConnection = cache_entry->id;
1987 return CACHE_S_SAMECACHE;
1988 }
1989
1990 hr = DataCache_CreateEntry(This, pformatetc, &cache_entry);
1991
1992 if (SUCCEEDED(hr))
1993 *pdwConnection = cache_entry->id;
1994
1995 return hr;
1996 }
1997
1998 static HRESULT WINAPI DataCache_Uncache(
1999 IOleCache2* iface,
2000 DWORD dwConnection)
2001 {
2002 DataCache *This = impl_from_IOleCache2(iface);
2003 DataCacheEntry *cache_entry;
2004
2005 TRACE("(%d)\n", dwConnection);
2006
2007 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
2008 if (cache_entry->id == dwConnection)
2009 {
2010 DataCacheEntry_Destroy(cache_entry);
2011 return S_OK;
2012 }
2013
2014 WARN("no connection found for %d\n", dwConnection);
2015
2016 return OLE_E_NOCONNECTION;
2017 }
2018
2019 static HRESULT WINAPI DataCache_EnumCache(
2020 IOleCache2* iface,
2021 IEnumSTATDATA** ppenumSTATDATA)
2022 {
2023 FIXME("stub\n");
2024 return E_NOTIMPL;
2025 }
2026
2027 static HRESULT WINAPI DataCache_InitCache(
2028 IOleCache2* iface,
2029 IDataObject* pDataObject)
2030 {
2031 FIXME("stub\n");
2032 return E_NOTIMPL;
2033 }
2034
2035 static HRESULT WINAPI DataCache_IOleCache2_SetData(
2036 IOleCache2* iface,
2037 FORMATETC* pformatetc,
2038 STGMEDIUM* pmedium,
2039 BOOL fRelease)
2040 {
2041 DataCache *This = impl_from_IOleCache2(iface);
2042 DataCacheEntry *cache_entry;
2043 HRESULT hr;
2044
2045 TRACE("(%p, %p, %s)\n", pformatetc, pmedium, fRelease ? "TRUE" : "FALSE");
2046 TRACE("formatetc = %s\n", debugstr_formatetc(pformatetc));
2047
2048 cache_entry = DataCache_GetEntryForFormatEtc(This, pformatetc);
2049 if (cache_entry)
2050 {
2051 hr = DataCacheEntry_SetData(cache_entry, pformatetc, pmedium, fRelease);
2052
2053 if (SUCCEEDED(hr))
2054 DataCache_FireOnViewChange(This, cache_entry->fmtetc.dwAspect,
2055 cache_entry->fmtetc.lindex);
2056
2057 return hr;
2058 }
2059 WARN("cache entry not found\n");
2060
2061 return OLE_E_BLANK;
2062 }
2063
2064 static HRESULT WINAPI DataCache_UpdateCache(
2065 IOleCache2* iface,
2066 LPDATAOBJECT pDataObject,
2067 DWORD grfUpdf,
2068 LPVOID pReserved)
2069 {
2070 FIXME("(%p, 0x%x, %p): stub\n", pDataObject, grfUpdf, pReserved);
2071 return E_NOTIMPL;
2072 }
2073
2074 static HRESULT WINAPI DataCache_DiscardCache(
2075 IOleCache2* iface,
2076 DWORD dwDiscardOptions)
2077 {
2078 DataCache *This = impl_from_IOleCache2(iface);
2079 DataCacheEntry *cache_entry;
2080 HRESULT hr = S_OK;
2081
2082 TRACE("(%d)\n", dwDiscardOptions);
2083
2084 if (dwDiscardOptions == DISCARDCACHE_SAVEIFDIRTY)
2085 hr = DataCache_Save((IPersistStorage *)&This->lpvtblIPersistStorage,
2086 This->presentationStorage, TRUE);
2087
2088 LIST_FOR_EACH_ENTRY(cache_entry, &This->cache_list, DataCacheEntry, entry)
2089 {
2090 hr = DataCacheEntry_DiscardData(cache_entry);
2091 if (FAILED(hr))
2092 break;
2093 }
2094
2095 return hr;
2096 }
2097
2098
2099 /*********************************************************
2100 * Method implementation for the IOleCacheControl
2101 * part of the DataCache class.
2102 */
2103
2104 /************************************************************************
2105 * DataCache_IOleCacheControl_QueryInterface (IUnknown)
2106 *
2107 * See Windows documentation for more details on IUnknown methods.
2108 */
2109 static HRESULT WINAPI DataCache_IOleCacheControl_QueryInterface(
2110 IOleCacheControl* iface,
2111 REFIID riid,
2112 void** ppvObject)
2113 {
2114 DataCache *this = impl_from_IOleCacheControl(iface);
2115
2116 return IUnknown_QueryInterface(this->outerUnknown, riid, ppvObject);
2117 }
2118
2119 /************************************************************************
2120 * DataCache_IOleCacheControl_AddRef (IUnknown)
2121 *
2122 * See Windows documentation for more details on IUnknown methods.
2123 */
2124 static ULONG WINAPI DataCache_IOleCacheControl_AddRef(
2125 IOleCacheControl* iface)
2126 {
2127 DataCache *this = impl_from_IOleCacheControl(iface);
2128
2129 return IUnknown_AddRef(this->outerUnknown);
2130 }
2131
2132 /************************************************************************
2133 * DataCache_IOleCacheControl_Release (IUnknown)
2134 *
2135 * See Windows documentation for more details on IUnknown methods.
2136 */
2137 static ULONG WINAPI DataCache_IOleCacheControl_Release(
2138 IOleCacheControl* iface)
2139 {
2140 DataCache *this = impl_from_IOleCacheControl(iface);
2141
2142 return IUnknown_Release(this->outerUnknown);
2143 }
2144
2145 static HRESULT WINAPI DataCache_OnRun(
2146 IOleCacheControl* iface,
2147 LPDATAOBJECT pDataObject)
2148 {
2149 FIXME("stub\n");
2150 return E_NOTIMPL;
2151 }
2152
2153 static HRESULT WINAPI DataCache_OnStop(
2154 IOleCacheControl* iface)
2155 {
2156 FIXME("stub\n");
2157 return E_NOTIMPL;
2158 }
2159
2160 /*
2161 * Virtual function tables for the DataCache class.
2162 */
2163 static const IUnknownVtbl DataCache_NDIUnknown_VTable =
2164 {
2165 DataCache_NDIUnknown_QueryInterface,
2166 DataCache_NDIUnknown_AddRef,
2167 DataCache_NDIUnknown_Release
2168 };
2169
2170 static const IDataObjectVtbl DataCache_IDataObject_VTable =
2171 {
2172 DataCache_IDataObject_QueryInterface,
2173 DataCache_IDataObject_AddRef,
2174 DataCache_IDataObject_Release,
2175 DataCache_GetData,
2176 DataCache_GetDataHere,
2177 DataCache_QueryGetData,
2178 DataCache_GetCanonicalFormatEtc,
2179 DataCache_IDataObject_SetData,
2180 DataCache_EnumFormatEtc,
2181 DataCache_DAdvise,
2182 DataCache_DUnadvise,
2183 DataCache_EnumDAdvise
2184 };
2185
2186 static const IPersistStorageVtbl DataCache_IPersistStorage_VTable =
2187 {
2188 DataCache_IPersistStorage_QueryInterface,
2189 DataCache_IPersistStorage_AddRef,
2190 DataCache_IPersistStorage_Release,
2191 DataCache_GetClassID,
2192 DataCache_IsDirty,
2193 DataCache_InitNew,
2194 DataCache_Load,
2195 DataCache_Save,
2196 DataCache_SaveCompleted,
2197 DataCache_HandsOffStorage
2198 };
2199
2200 static const IViewObject2Vtbl DataCache_IViewObject2_VTable =
2201 {
2202 DataCache_IViewObject2_QueryInterface,
2203 DataCache_IViewObject2_AddRef,
2204 DataCache_IViewObject2_Release,
2205 DataCache_Draw,
2206 DataCache_GetColorSet,
2207 DataCache_Freeze,
2208 DataCache_Unfreeze,
2209 DataCache_SetAdvise,
2210 DataCache_GetAdvise,
2211 DataCache_GetExtent
2212 };
2213
2214 static const IOleCache2Vtbl DataCache_IOleCache2_VTable =
2215 {
2216 DataCache_IOleCache2_QueryInterface,
2217 DataCache_IOleCache2_AddRef,
2218 DataCache_IOleCache2_Release,
2219 DataCache_Cache,
2220 DataCache_Uncache,
2221 DataCache_EnumCache,
2222 DataCache_InitCache,
2223 DataCache_IOleCache2_SetData,
2224 DataCache_UpdateCache,
2225 DataCache_DiscardCache
2226 };
2227
2228 static const IOleCacheControlVtbl DataCache_IOleCacheControl_VTable =
2229 {
2230 DataCache_IOleCacheControl_QueryInterface,
2231 DataCache_IOleCacheControl_AddRef,
2232 DataCache_IOleCacheControl_Release,
2233 DataCache_OnRun,
2234 DataCache_OnStop
2235 };
2236
2237 /******************************************************************************
2238 * CreateDataCache [OLE32.@]
2239 *
2240 * Creates a data cache to allow an object to render one or more of its views,
2241 * whether running or not.
2242 *
2243 * PARAMS
2244 * pUnkOuter [I] Outer unknown for the object.
2245 * rclsid [I]
2246 * riid [I] IID of interface to return.
2247 * ppvObj [O] Address where the data cache object will be stored on return.
2248 *
2249 * RETURNS
2250 * Success: S_OK.
2251 * Failure: HRESULT code.
2252 *
2253 * NOTES
2254 * The following interfaces are supported by the returned data cache object:
2255 * IOleCache, IOleCache2, IOleCacheControl, IPersistStorage, IDataObject,
2256 * IViewObject and IViewObject2.
2257 */
2258 HRESULT WINAPI CreateDataCache(
2259 LPUNKNOWN pUnkOuter,
2260 REFCLSID rclsid,
2261 REFIID riid,
2262 LPVOID* ppvObj)
2263 {
2264 DataCache* newCache = NULL;
2265 HRESULT hr = S_OK;
2266
2267 TRACE("(%s, %p, %s, %p)\n", debugstr_guid(rclsid), pUnkOuter, debugstr_guid(riid), ppvObj);
2268
2269 /*
2270 * Sanity check
2271 */
2272 if (ppvObj==0)
2273 return E_POINTER;
2274
2275 *ppvObj = 0;
2276
2277 /*
2278 * If this cache is constructed for aggregation, make sure
2279 * the caller is requesting the IUnknown interface.
2280 * This is necessary because it's the only time the non-delegating
2281 * IUnknown pointer can be returned to the outside.
2282 */
2283 if ( (pUnkOuter!=NULL) &&
2284 (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) != 0) )
2285 return CLASS_E_NOAGGREGATION;
2286
2287 /*
2288 * Try to construct a new instance of the class.
2289 */
2290 newCache = DataCache_Construct(rclsid,
2291 pUnkOuter);
2292
2293 if (newCache == 0)
2294 return E_OUTOFMEMORY;
2295
2296 /*
2297 * Make sure it supports the interface required by the caller.
2298 */
2299 hr = IUnknown_QueryInterface((IUnknown*)&(newCache->lpvtblNDIUnknown), riid, ppvObj);
2300
2301 /*
2302 * Release the reference obtained in the constructor. If
2303 * the QueryInterface was unsuccessful, it will free the class.
2304 */
2305 IUnknown_Release((IUnknown*)&(newCache->lpvtblNDIUnknown));
2306
2307 return hr;
2308 }
2309
2310 /*********************************************************
2311 * Method implementation for DataCache class.
2312 */
2313 static DataCache* DataCache_Construct(
2314 REFCLSID clsid,
2315 LPUNKNOWN pUnkOuter)
2316 {
2317 DataCache* newObject = 0;
2318
2319 /*
2320 * Allocate space for the object.
2321 */
2322 newObject = HeapAlloc(GetProcessHeap(), 0, sizeof(DataCache));
2323
2324 if (newObject==0)
2325 return newObject;
2326
2327 /*
2328 * Initialize the virtual function table.
2329 */
2330 newObject->lpVtbl = &DataCache_IDataObject_VTable;
2331 newObject->lpvtblNDIUnknown = &DataCache_NDIUnknown_VTable;
2332 newObject->lpvtblIPersistStorage = &DataCache_IPersistStorage_VTable;
2333 newObject->lpvtblIViewObject = &DataCache_IViewObject2_VTable;
2334 newObject->lpvtblIOleCache2 = &DataCache_IOleCache2_VTable;
2335 newObject->lpvtblIOleCacheControl = &DataCache_IOleCacheControl_VTable;
2336
2337 /*
2338 * Start with one reference count. The caller of this function
2339 * must release the interface pointer when it is done.
2340 */
2341 newObject->ref = 1;
2342
2343 /*
2344 * Initialize the outer unknown
2345 * We don't keep a reference on the outer unknown since, the way
2346 * aggregation works, our lifetime is at least as large as its
2347 * lifetime.
2348 */
2349 if (pUnkOuter==NULL)
2350 pUnkOuter = (IUnknown*)&(newObject->lpvtblNDIUnknown);
2351
2352 newObject->outerUnknown = pUnkOuter;
2353
2354 /*
2355 * Initialize the other members of the structure.
2356 */
2357 newObject->sinkAspects = 0;
2358 newObject->sinkAdviseFlag = 0;
2359 newObject->sinkInterface = 0;
2360 newObject->presentationStorage = NULL;
2361 list_init(&newObject->cache_list);
2362 newObject->last_cache_id = 1;
2363 newObject->dirty = FALSE;
2364
2365 return newObject;
2366 }
2367
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.