1 /*
2 * OLE 2 clipboard support
3 *
4 * Copyright 1999 Noel Borthwick <noel@macadamian.com>
5 * Copyright 2000 Abey George <abey@macadamian.com>
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 * This file contains the implementation for the OLE Clipboard and its
23 * internal interfaces. The OLE clipboard interacts with an IDataObject
24 * interface via the OleSetClipboard, OleGetClipboard and
25 * OleIsCurrentClipboard API's. An internal IDataObject delegates
26 * to a client supplied IDataObject or the WIN32 clipboard API depending
27 * on whether OleSetClipboard has been invoked.
28 * Here are some operating scenarios:
29 *
30 * 1. OleSetClipboard called: In this case the internal IDataObject
31 * delegates to the client supplied IDataObject. Additionally OLE takes
32 * ownership of the Windows clipboard and any HGLOCBAL IDataObject
33 * items are placed on the Windows clipboard. This allows non OLE aware
34 * applications to access these. A local WinProc fields WM_RENDERFORMAT
35 * and WM_RENDERALLFORMATS messages in this case.
36 *
37 * 2. OleGetClipboard called without previous OleSetClipboard. Here the internal
38 * IDataObject functionality wraps around the WIN32 clipboard API.
39 *
40 * 3. OleGetClipboard called after previous OleSetClipboard. Here the internal
41 * IDataObject delegates to the source IDataObjects functionality directly,
42 * thereby bypassing the Windows clipboard.
43 *
44 * Implementation references : Inside OLE 2'nd edition by Kraig Brockschmidt
45 *
46 * TODO:
47 * - Support for pasting between different processes. OLE clipboard support
48 * currently works only for in process copy and paste. Since we internally
49 * store a pointer to the source's IDataObject and delegate to that, this
50 * will fail if the IDataObject client belongs to a different process.
51 * - IDataObject::GetDataHere is not implemented
52 * - OleFlushClipboard needs to additionally handle TYMED_IStorage media
53 * by copying the storage into global memory. Subsequently the default
54 * data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
55 * back to TYMED_IStorage.
56 * - OLE1 compatibility formats to be synthesized from OLE2 formats and put on
57 * clipboard in OleSetClipboard.
58 *
59 */
60
61 #include <assert.h>
62 #include <stdarg.h>
63 #include <string.h>
64 #include <stdio.h>
65
66 #define COBJMACROS
67 #define NONAMELESSUNION
68 #define NONAMELESSSTRUCT
69
70 #include "windef.h"
71 #include "winbase.h"
72 #include "wingdi.h"
73 #include "winuser.h"
74 #include "winerror.h"
75 #include "winnls.h"
76 #include "ole2.h"
77 #include "wine/debug.h"
78 #include "olestd.h"
79
80 #include "storage32.h"
81
82 #include "compobj_private.h"
83
84 WINE_DEFAULT_DEBUG_CHANNEL(ole);
85
86 #define HANDLE_ERROR(err) do { hr = err; TRACE("(HRESULT=%x)\n", (HRESULT)err); goto CLEANUP; } while (0)
87
88 /* Structure of 'Ole Private Data' clipboard format */
89 typedef struct
90 {
91 FORMATETC fmtetc;
92 DWORD first_use; /* Has this cf been added to the list already */
93 DWORD unk[2];
94 } ole_priv_data_entry;
95
96 typedef struct
97 {
98 DWORD unk1;
99 DWORD size; /* in bytes of the entire structure */
100 DWORD unk2;
101 DWORD count; /* no. of format entries */
102 DWORD unk3[2];
103 ole_priv_data_entry entries[1]; /* array of size count */
104 /* then follows any DVTARGETDEVICE structures referenced in the FORMATETCs */
105 } ole_priv_data;
106
107 /*****************************************************************************
108 * td_offs_to_ptr
109 *
110 * Returns a ptr to a target device at a given offset from the
111 * start of the ole_priv_data.
112 *
113 * Used when unpacking ole private data from the clipboard.
114 */
115 static inline DVTARGETDEVICE *td_offs_to_ptr(ole_priv_data *data, DWORD_PTR off)
116 {
117 if(off == 0) return NULL;
118 return (DVTARGETDEVICE*)((char*)data + off);
119 }
120
121 /*****************************************************************************
122 * td_get_offs
123 *
124 * Get the offset from the start of the ole_priv_data of the idx'th
125 * target device.
126 *
127 * Used when packing ole private data to the clipboard.
128 */
129 static inline DWORD_PTR td_get_offs(ole_priv_data *data, DWORD idx)
130 {
131 if(data->entries[idx].fmtetc.ptd == NULL) return 0;
132 return (char*)data->entries[idx].fmtetc.ptd - (char*)data;
133 }
134
135 /****************************************************************************
136 * Consumer snapshot. Represents the state of the ole clipboard
137 * returned by OleGetClipboard().
138 */
139 typedef struct snapshot
140 {
141 const IDataObjectVtbl* lpVtbl;
142 LONG ref;
143
144 DWORD seq_no; /* Clipboard sequence number corresponding to this snapshot */
145
146 IDataObject *data; /* If we unmarshal a remote data object we hold a ref here */
147 } snapshot;
148
149 /****************************************************************************
150 * ole_clipbrd
151 */
152 typedef struct ole_clipbrd
153 {
154 snapshot *latest_snapshot; /* Latest consumer snapshot */
155
156 HWND window; /* Hidden clipboard window */
157 IDataObject *src_data; /* Source object passed to OleSetClipboard */
158 ole_priv_data *cached_enum; /* Cached result from the enumeration of src data object */
159 IStream *marshal_data; /* Stream onto which to marshal src_data */
160 } ole_clipbrd;
161
162 static inline snapshot *impl_from_IDataObject(IDataObject *iface)
163 {
164 return (snapshot*)((char*)iface - FIELD_OFFSET(snapshot, lpVtbl));
165 }
166
167 typedef struct PresentationDataHeader
168 {
169 BYTE unknown1[28];
170 DWORD dwObjectExtentX;
171 DWORD dwObjectExtentY;
172 DWORD dwSize;
173 } PresentationDataHeader;
174
175 /*
176 * The one and only ole_clipbrd object which is created by OLEClipbrd_Initialize()
177 */
178 static ole_clipbrd* theOleClipboard;
179
180 static inline HRESULT get_ole_clipbrd(ole_clipbrd **clipbrd)
181 {
182 struct oletls *info = COM_CurrentInfo();
183 *clipbrd = NULL;
184
185 if(!info->ole_inits)
186 return CO_E_NOTINITIALIZED;
187 *clipbrd = theOleClipboard;
188
189 return S_OK;
190 }
191
192 /*
193 * Name of our registered OLE clipboard window class
194 */
195 static const WCHAR clipbrd_wndclass[] = {'C','L','I','P','B','R','D','W','N','D','C','L','A','S','S',0};
196
197 static const WCHAR wine_marshal_dataobject[] = {'W','i','n','e',' ','m','a','r','s','h','a','l',' ','d','a','t','a','o','b','j','e','c','t',0};
198
199 UINT ownerlink_clipboard_format = 0;
200 UINT filename_clipboard_format = 0;
201 UINT filenameW_clipboard_format = 0;
202 UINT dataobject_clipboard_format = 0;
203 UINT embedded_object_clipboard_format = 0;
204 UINT embed_source_clipboard_format = 0;
205 UINT custom_link_source_clipboard_format = 0;
206 UINT link_source_clipboard_format = 0;
207 UINT object_descriptor_clipboard_format = 0;
208 UINT link_source_descriptor_clipboard_format = 0;
209 UINT ole_private_data_clipboard_format = 0;
210
211 static UINT wine_marshal_clipboard_format;
212
213 static inline char *dump_fmtetc(FORMATETC *fmt)
214 {
215 static char buf[100];
216
217 snprintf(buf, sizeof(buf), "cf %04x ptd %p aspect %x lindex %d tymed %x",
218 fmt->cfFormat, fmt->ptd, fmt->dwAspect, fmt->lindex, fmt->tymed);
219 return buf;
220 }
221
222 /*---------------------------------------------------------------------*
223 * Implementation of the internal IEnumFORMATETC interface returned by
224 * the OLE clipboard's IDataObject.
225 *---------------------------------------------------------------------*/
226
227 typedef struct enum_fmtetc
228 {
229 const IEnumFORMATETCVtbl *lpVtbl;
230 LONG ref;
231
232 UINT pos; /* current enumerator position */
233 ole_priv_data *data;
234 } enum_fmtetc;
235
236 static inline enum_fmtetc *impl_from_IEnumFORMATETC(IEnumFORMATETC *iface)
237 {
238 return (enum_fmtetc*)((char*)iface - FIELD_OFFSET(enum_fmtetc, lpVtbl));
239 }
240
241 /************************************************************************
242 * OLEClipbrd_IEnumFORMATETC_QueryInterface (IUnknown)
243 *
244 * See Windows documentation for more details on IUnknown methods.
245 */
246 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface
247 (LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
248 {
249 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
250
251 TRACE("(%p)->(IID: %s, %p)\n", This, debugstr_guid(riid), ppvObj);
252
253 *ppvObj = NULL;
254
255 if(IsEqualIID(riid, &IID_IUnknown) ||
256 IsEqualIID(riid, &IID_IEnumFORMATETC))
257 {
258 *ppvObj = iface;
259 }
260
261 if(*ppvObj)
262 {
263 IEnumFORMATETC_AddRef((IEnumFORMATETC*)*ppvObj);
264 TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
265 return S_OK;
266 }
267
268 TRACE("-- Interface: E_NOINTERFACE\n");
269 return E_NOINTERFACE;
270 }
271
272 /************************************************************************
273 * OLEClipbrd_IEnumFORMATETC_AddRef (IUnknown)
274 *
275 */
276 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface)
277 {
278 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
279 TRACE("(%p)->(count=%u)\n",This, This->ref);
280
281 return InterlockedIncrement(&This->ref);
282 }
283
284 /************************************************************************
285 * OLEClipbrd_IEnumFORMATETC_Release (IUnknown)
286 *
287 * See Windows documentation for more details on IUnknown methods.
288 */
289 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface)
290 {
291 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
292 ULONG ref;
293
294 TRACE("(%p)->(count=%u)\n",This, This->ref);
295
296 ref = InterlockedDecrement(&This->ref);
297 if (!ref)
298 {
299 TRACE("() - destroying IEnumFORMATETC(%p)\n",This);
300 HeapFree(GetProcessHeap(), 0, This->data);
301 HeapFree(GetProcessHeap(), 0, This);
302 }
303 return ref;
304 }
305
306 /************************************************************************
307 * OLEClipbrd_IEnumFORMATETC_Next (IEnumFORMATETC)
308 *
309 * Standard enumerator members for IEnumFORMATETC
310 */
311 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next
312 (LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
313 {
314 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
315 UINT cfetch, i;
316 HRESULT hres = S_FALSE;
317
318 TRACE("(%p)->(pos=%u)\n", This, This->pos);
319
320 if (This->pos < This->data->count)
321 {
322 cfetch = This->data->count - This->pos;
323 if (cfetch >= celt)
324 {
325 cfetch = celt;
326 hres = S_OK;
327 }
328
329 for(i = 0; i < cfetch; i++)
330 {
331 rgelt[i] = This->data->entries[This->pos++].fmtetc;
332 if(rgelt[i].ptd)
333 {
334 DVTARGETDEVICE *target = rgelt[i].ptd;
335 rgelt[i].ptd = CoTaskMemAlloc(target->tdSize);
336 if(!rgelt[i].ptd) return E_OUTOFMEMORY;
337 memcpy(rgelt[i].ptd, target, target->tdSize);
338 }
339 }
340 }
341 else
342 {
343 cfetch = 0;
344 }
345
346 if (pceltFethed)
347 {
348 *pceltFethed = cfetch;
349 }
350
351 return hres;
352 }
353
354 /************************************************************************
355 * OLEClipbrd_IEnumFORMATETC_Skip (IEnumFORMATETC)
356 *
357 * Standard enumerator members for IEnumFORMATETC
358 */
359 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface, ULONG celt)
360 {
361 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
362 TRACE("(%p)->(num=%u)\n", This, celt);
363
364 This->pos += celt;
365 if (This->pos > This->data->count)
366 {
367 This->pos = This->data->count;
368 return S_FALSE;
369 }
370 return S_OK;
371 }
372
373 /************************************************************************
374 * OLEClipbrd_IEnumFORMATETC_Reset (IEnumFORMATETC)
375 *
376 * Standard enumerator members for IEnumFORMATETC
377 */
378 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface)
379 {
380 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
381 TRACE("(%p)->()\n", This);
382
383 This->pos = 0;
384 return S_OK;
385 }
386
387 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj);
388
389 /************************************************************************
390 * OLEClipbrd_IEnumFORMATETC_Clone (IEnumFORMATETC)
391 *
392 * Standard enumerator members for IEnumFORMATETC
393 */
394 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone
395 (LPENUMFORMATETC iface, LPENUMFORMATETC* obj)
396 {
397 enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
398 ole_priv_data *new_data;
399 DWORD i;
400
401 TRACE("(%p)->(%p)\n", This, obj);
402
403 if ( !obj ) return E_INVALIDARG;
404 *obj = NULL;
405
406 new_data = HeapAlloc(GetProcessHeap(), 0, This->data->size);
407 if(!new_data) return E_OUTOFMEMORY;
408 memcpy(new_data, This->data, This->data->size);
409
410 /* Fixup any target device ptrs */
411 for(i = 0; i < This->data->count; i++)
412 new_data->entries[i].fmtetc.ptd =
413 td_offs_to_ptr(new_data, td_get_offs(This->data, i));
414
415 return enum_fmtetc_construct(new_data, This->pos, obj);
416 }
417
418 static const IEnumFORMATETCVtbl efvt =
419 {
420 OLEClipbrd_IEnumFORMATETC_QueryInterface,
421 OLEClipbrd_IEnumFORMATETC_AddRef,
422 OLEClipbrd_IEnumFORMATETC_Release,
423 OLEClipbrd_IEnumFORMATETC_Next,
424 OLEClipbrd_IEnumFORMATETC_Skip,
425 OLEClipbrd_IEnumFORMATETC_Reset,
426 OLEClipbrd_IEnumFORMATETC_Clone
427 };
428
429 /************************************************************************
430 * enum_fmtetc_construct
431 *
432 * Creates an IEnumFORMATETC enumerator from ole_priv_data which it then owns.
433 */
434 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj)
435 {
436 enum_fmtetc* ef;
437
438 *obj = NULL;
439 ef = HeapAlloc(GetProcessHeap(), 0, sizeof(*ef));
440 if (!ef) return E_OUTOFMEMORY;
441
442 ef->ref = 1;
443 ef->lpVtbl = &efvt;
444 ef->data = data;
445 ef->pos = pos;
446
447 TRACE("(%p)->()\n", ef);
448 *obj = (IEnumFORMATETC *)ef;
449 return S_OK;
450 }
451
452 /***********************************************************************
453 * dup_global_mem
454 *
455 * Helper method to duplicate an HGLOBAL chunk of memory
456 */
457 static HRESULT dup_global_mem( HGLOBAL src, DWORD flags, HGLOBAL *dst )
458 {
459 void *src_ptr, *dst_ptr;
460 DWORD size;
461
462 *dst = NULL;
463 if ( !src ) return S_FALSE;
464
465 size = GlobalSize(src);
466
467 *dst = GlobalAlloc( flags, size );
468 if ( !*dst ) return E_OUTOFMEMORY;
469
470 src_ptr = GlobalLock(src);
471 dst_ptr = GlobalLock(*dst);
472
473 memcpy(dst_ptr, src_ptr, size);
474
475 GlobalUnlock(*dst);
476 GlobalUnlock(src);
477
478 return S_OK;
479 }
480
481 /************************************************************
482 * render_embed_source_hack
483 *
484 * This is clearly a hack and has no place in the clipboard code.
485 *
486 */
487 static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
488 {
489 STGMEDIUM std;
490 HGLOBAL hStorage = 0;
491 HRESULT hr = S_OK;
492 ILockBytes *ptrILockBytes;
493
494 memset(&std, 0, sizeof(STGMEDIUM));
495 std.tymed = fmt->tymed = TYMED_ISTORAGE;
496
497 hStorage = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, 0);
498 if (hStorage == NULL) return E_OUTOFMEMORY;
499 hr = CreateILockBytesOnHGlobal(hStorage, FALSE, &ptrILockBytes);
500 hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
501 ILockBytes_Release(ptrILockBytes);
502
503 if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->src_data, fmt, &std)))
504 {
505 WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%x)\n", hr);
506 GlobalFree(hStorage);
507 return hr;
508 }
509
510 if (1) /* check whether the presentation data is already -not- present */
511 {
512 FORMATETC fmt2;
513 STGMEDIUM std2;
514 METAFILEPICT *mfp = 0;
515
516 fmt2.cfFormat = CF_METAFILEPICT;
517 fmt2.ptd = 0;
518 fmt2.dwAspect = DVASPECT_CONTENT;
519 fmt2.lindex = -1;
520 fmt2.tymed = TYMED_MFPICT;
521
522 memset(&std2, 0, sizeof(STGMEDIUM));
523 std2.tymed = TYMED_MFPICT;
524
525 /* Get the metafile picture out of it */
526
527 if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->src_data, &fmt2, &std2)))
528 {
529 mfp = GlobalLock(std2.u.hGlobal);
530 }
531
532 if (mfp)
533 {
534 OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '', '', '', 0};
535 IStream *pStream = 0;
536 void *mfBits;
537 PresentationDataHeader pdh;
538 INT nSize;
539 CLSID clsID;
540 LPOLESTR strProgID;
541 CHAR strOleTypeName[51];
542 BYTE OlePresStreamHeader [] =
543 {
544 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
545 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
546 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
547 0x00, 0x00, 0x00, 0x00
548 };
549
550 nSize = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
551
552 memset(&pdh, 0, sizeof(PresentationDataHeader));
553 memcpy(&pdh, OlePresStreamHeader, sizeof(OlePresStreamHeader));
554
555 pdh.dwObjectExtentX = mfp->xExt;
556 pdh.dwObjectExtentY = mfp->yExt;
557 pdh.dwSize = nSize;
558
559 hr = IStorage_CreateStream(std.u.pstg, name, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
560
561 hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
562
563 mfBits = HeapAlloc(GetProcessHeap(), 0, nSize);
564 nSize = GetMetaFileBitsEx(mfp->hMF, nSize, mfBits);
565
566 hr = IStream_Write(pStream, mfBits, nSize, NULL);
567
568 IStream_Release(pStream);
569
570 HeapFree(GetProcessHeap(), 0, mfBits);
571
572 GlobalUnlock(std2.u.hGlobal);
573 ReleaseStgMedium(&std2);
574
575 ReadClassStg(std.u.pstg, &clsID);
576 ProgIDFromCLSID(&clsID, &strProgID);
577
578 WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
579 OLECONVERT_CreateOleStream(std.u.pstg);
580 OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
581 }
582 }
583
584 if ( !SetClipboardData( fmt->cfFormat, hStorage ) )
585 {
586 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
587 GlobalFree(hStorage);
588 hr = CLIPBRD_E_CANT_SET;
589 }
590
591 ReleaseStgMedium(&std);
592 return hr;
593 }
594
595 /************************************************************************
596 * find_format_in_list
597 *
598 * Returns the first entry that matches the provided clipboard format.
599 */
600 static inline ole_priv_data_entry *find_format_in_list(ole_priv_data_entry *entries, DWORD num, UINT cf)
601 {
602 DWORD i;
603 for(i = 0; i < num; i++)
604 if(entries[i].fmtetc.cfFormat == cf)
605 return &entries[i];
606
607 return NULL;
608 }
609
610 /***************************************************************************
611 * get_data_from_storage
612 *
613 * Returns storage data in an HGLOBAL.
614 */
615 static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
616 {
617 HGLOBAL h;
618 IStorage *stg;
619 HRESULT hr;
620 FORMATETC stg_fmt;
621 STGMEDIUM med;
622 ILockBytes *lbs;
623
624 *mem = NULL;
625
626 h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
627 if(!h) return E_OUTOFMEMORY;
628
629 hr = CreateILockBytesOnHGlobal(h, FALSE, &lbs);
630 if(SUCCEEDED(hr))
631 {
632 hr = StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
633 ILockBytes_Release(lbs);
634 }
635 if(FAILED(hr))
636 {
637 GlobalFree(h);
638 return hr;
639 }
640
641 stg_fmt = *fmt;
642 med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
643 med.u.pstg = stg;
644 med.pUnkForRelease = NULL;
645
646 hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
647 if(FAILED(hr))
648 {
649 med.u.pstg = NULL;
650 hr = IDataObject_GetData(data, &stg_fmt, &med);
651 if(FAILED(hr)) goto end;
652
653 hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
654 ReleaseStgMedium(&med);
655 if(FAILED(hr)) goto end;
656 }
657 *mem = h;
658
659 end:
660 IStorage_Release(stg);
661 if(FAILED(hr)) GlobalFree(h);
662 return hr;
663 }
664
665 /***************************************************************************
666 * get_data_from_stream
667 *
668 * Returns stream data in an HGLOBAL.
669 */
670 static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
671 {
672 HGLOBAL h;
673 IStream *stm = NULL;
674 HRESULT hr;
675 FORMATETC stm_fmt;
676 STGMEDIUM med;
677
678 *mem = NULL;
679
680 h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
681 if(!h) return E_OUTOFMEMORY;
682
683 hr = CreateStreamOnHGlobal(h, FALSE, &stm);
684 if(FAILED(hr)) goto error;
685
686 stm_fmt = *fmt;
687 med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
688 med.u.pstm = stm;
689 med.pUnkForRelease = NULL;
690
691 hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
692 if(FAILED(hr))
693 {
694 LARGE_INTEGER offs;
695 ULARGE_INTEGER pos;
696
697 med.u.pstm = NULL;
698 hr = IDataObject_GetData(data, &stm_fmt, &med);
699 if(FAILED(hr)) goto error;
700
701 offs.QuadPart = 0;
702 IStream_Seek(med.u.pstm, offs, STREAM_SEEK_CUR, &pos);
703 IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
704 hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
705 ReleaseStgMedium(&med);
706 if(FAILED(hr)) goto error;
707 }
708 *mem = h;
709 IStream_Release(stm);
710 return S_OK;
711
712 error:
713 if(stm) IStream_Release(stm);
714 GlobalFree(h);
715 return hr;
716 }
717
718 /***************************************************************************
719 * get_data_from_global
720 *
721 * Returns global data in an HGLOBAL.
722 */
723 static HRESULT get_data_from_global(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
724 {
725 HGLOBAL h;
726 HRESULT hr;
727 FORMATETC mem_fmt;
728 STGMEDIUM med;
729
730 *mem = NULL;
731
732 mem_fmt = *fmt;
733 mem_fmt.tymed = TYMED_HGLOBAL;
734
735 hr = IDataObject_GetData(data, &mem_fmt, &med);
736 if(FAILED(hr)) return hr;
737
738 hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
739
740 if(SUCCEEDED(hr)) *mem = h;
741
742 ReleaseStgMedium(&med);
743
744 return hr;
745 }
746
747 /***********************************************************************
748 * render_format
749 *
750 * Render the clipboard data. Note that this call will delegate to the
751 * source data object.
752 */
753 static HRESULT render_format(IDataObject *data, LPFORMATETC fmt)
754 {
755 HGLOBAL clip_data = NULL;
756 HRESULT hr;
757
758 /* Embed source hack */
759 if(fmt->cfFormat == embed_source_clipboard_format)
760 {
761 return render_embed_source_hack(data, fmt);
762 }
763
764 if(fmt->tymed & TYMED_ISTORAGE)
765 {
766 hr = get_data_from_storage(data, fmt, &clip_data);
767 }
768 else if(fmt->tymed & TYMED_ISTREAM)
769 {
770 hr = get_data_from_stream(data, fmt, &clip_data);
771 }
772 else if(fmt->tymed & TYMED_HGLOBAL)
773 {
774 hr = get_data_from_global(data, fmt, &clip_data);
775 }
776 else
777 {
778 FIXME("Unhandled tymed %x\n", fmt->tymed);
779 hr = DV_E_FORMATETC;
780 }
781
782 if(SUCCEEDED(hr))
783 {
784 if ( !SetClipboardData(fmt->cfFormat, clip_data) )
785 {
786 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
787 GlobalFree(clip_data);
788 hr = CLIPBRD_E_CANT_SET;
789 }
790 }
791
792 return hr;
793 }
794
795 /*---------------------------------------------------------------------*
796 * Implementation of the internal IDataObject interface exposed by
797 * the OLE clipboard.
798 *---------------------------------------------------------------------*/
799
800
801 /************************************************************************
802 * snapshot_QueryInterface
803 */
804 static HRESULT WINAPI snapshot_QueryInterface(IDataObject *iface,
805 REFIID riid, void **ppvObject)
806 {
807 snapshot *This = impl_from_IDataObject(iface);
808 TRACE("(%p)->(IID:%s, %p)\n", This, debugstr_guid(riid), ppvObject);
809
810 if ( (This==0) || (ppvObject==0) )
811 return E_INVALIDARG;
812
813 *ppvObject = 0;
814
815 if (IsEqualIID(&IID_IUnknown, riid) ||
816 IsEqualIID(&IID_IDataObject, riid))
817 {
818 *ppvObject = iface;
819 }
820 else
821 {
822 WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
823 return E_NOINTERFACE;
824 }
825
826 IUnknown_AddRef((IUnknown*)*ppvObject);
827
828 return S_OK;
829 }
830
831 /************************************************************************
832 * snapshot_AddRef
833 */
834 static ULONG WINAPI snapshot_AddRef(IDataObject *iface)
835 {
836 snapshot *This = impl_from_IDataObject(iface);
837
838 TRACE("(%p)->(count=%u)\n", This, This->ref);
839
840 return InterlockedIncrement(&This->ref);
841 }
842
843 /************************************************************************
844 * snapshot_Release
845 */
846 static ULONG WINAPI snapshot_Release(IDataObject *iface)
847 {
848 snapshot *This = impl_from_IDataObject(iface);
849 ULONG ref;
850
851 TRACE("(%p)->(count=%u)\n", This, This->ref);
852
853 ref = InterlockedDecrement(&This->ref);
854
855 if (ref == 0)
856 {
857 ole_clipbrd *clipbrd;
858 HRESULT hr = get_ole_clipbrd(&clipbrd);
859
860 if(This->data) IDataObject_Release(This->data);
861
862 if(SUCCEEDED(hr) && clipbrd->latest_snapshot == This)
863 clipbrd->latest_snapshot = NULL;
864 HeapFree(GetProcessHeap(), 0, This);
865 }
866
867 return ref;
868 }
869
870 /************************************************************
871 * get_current_ole_clip_window
872 *
873 * Return the window that owns the ole clipboard.
874 *
875 * If the clipboard is flushed or not owned by ole this will
876 * return NULL.
877 */
878 static HWND get_current_ole_clip_window(void)
879 {
880 HGLOBAL h;
881 HWND *ptr, wnd;
882
883 h = GetClipboardData(dataobject_clipboard_format);
884 if(!h) return NULL;
885 ptr = GlobalLock(h);
886 if(!ptr) return NULL;
887 wnd = *ptr;
888 GlobalUnlock(h);
889 return wnd;
890 }
891
892 /************************************************************
893 * get_current_dataobject
894 *
895 * Return an unmarshalled IDataObject if there is a current
896 * (ie non-flushed) object on the ole clipboard.
897 */
898 static HRESULT get_current_dataobject(IDataObject **data)
899 {
900 HRESULT hr = S_FALSE;
901 HWND wnd = get_current_ole_clip_window();
902 HGLOBAL h;
903 void *ptr;
904 IStream *stm;
905 LARGE_INTEGER pos;
906
907 *data = NULL;
908 if(!wnd) return S_FALSE;
909
910 h = GetClipboardData(wine_marshal_clipboard_format);
911 if(!h) return S_FALSE;
912 if(GlobalSize(h) == 0) return S_FALSE;
913 ptr = GlobalLock(h);
914 if(!ptr) return S_FALSE;
915
916 hr = CreateStreamOnHGlobal(NULL, TRUE, &stm);
917 if(FAILED(hr)) goto end;
918
919 hr = IStream_Write(stm, ptr, GlobalSize(h), NULL);
920 if(SUCCEEDED(hr))
921 {
922 pos.QuadPart = 0;
923 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
924 hr = CoUnmarshalInterface(stm, &IID_IDataObject, (void**)data);
925 }
926 IStream_Release(stm);
927
928 end:
929 GlobalUnlock(h);
930 return hr;
931 }
932
933 static DWORD get_tymed_from_nonole_cf(UINT cf)
934 {
935 if(cf >= 0xc000) return TYMED_ISTREAM | TYMED_HGLOBAL;
936
937 switch(cf)
938 {
939 case CF_TEXT:
940 case CF_OEMTEXT:
941 case CF_UNICODETEXT:
942 return TYMED_ISTREAM | TYMED_HGLOBAL;
943 case CF_ENHMETAFILE:
944 return TYMED_ENHMF;
945 case CF_METAFILEPICT:
946 return TYMED_MFPICT;
947 default:
948 FIXME("returning TYMED_NULL for cf %04x\n", cf);
949 return TYMED_NULL;
950 }
951 }
952
953 /***********************************************************
954 * get_priv_data
955 *
956 * Returns a copy of the Ole Private Data
957 */
958 static HRESULT get_priv_data(ole_priv_data **data)
959 {
960 HGLOBAL handle;
961 HRESULT hr = S_OK;
962 ole_priv_data *ret = NULL;
963
964 *data = NULL;
965
966 handle = GetClipboardData( ole_private_data_clipboard_format );
967 if(handle)
968 {
969 ole_priv_data *src = GlobalLock(handle);
970 if(src)
971 {
972 DWORD i;
973
974 /* FIXME: sanity check on size */
975 ret = HeapAlloc(GetProcessHeap(), 0, src->size);
976 if(!ret)
977 {
978 GlobalUnlock(handle);
979 return E_OUTOFMEMORY;
980 }
981 memcpy(ret, src, src->size);
982 GlobalUnlock(handle);
983
984 /* Fixup any target device offsets to ptrs */
985 for(i = 0; i < ret->count; i++)
986 ret->entries[i].fmtetc.ptd =
987 td_offs_to_ptr(ret, (DWORD_PTR) ret->entries[i].fmtetc.ptd);
988 }
989 }
990
991 if(!ret) /* Non-ole data */
992 {
993 UINT cf;
994 DWORD count = 0, idx, size = FIELD_OFFSET(ole_priv_data, entries);
995
996 for(cf = 0; (cf = EnumClipboardFormats(cf)) != 0; count++)
997 {
998 char buf[100];
999 GetClipboardFormatNameA(cf, buf, sizeof(buf));
1000 TRACE("\tcf %04x %s\n", cf, buf);
1001 ;
1002 }
1003 TRACE("count %d\n", count);
1004 size += count * sizeof(ret->entries[0]);
1005
1006 /* There are holes in fmtetc so zero init */
1007 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1008 if(!ret) return E_OUTOFMEMORY;
1009 ret->size = size;
1010 ret->count = count;
1011
1012 for(cf = 0, idx = 0; (cf = EnumClipboardFormats(cf)) != 0; idx++)
1013 {
1014 ret->entries[idx].fmtetc.cfFormat = cf;
1015 ret->entries[idx].fmtetc.ptd = NULL;
1016 ret->entries[idx].fmtetc.dwAspect = DVASPECT_CONTENT;
1017 ret->entries[idx].fmtetc.lindex = -1;
1018 ret->entries[idx].fmtetc.tymed = get_tymed_from_nonole_cf(cf);
1019 ret->entries[idx].first_use = 1;
1020 }
1021 }
1022
1023 *data = ret;
1024 return hr;
1025 }
1026
1027 /************************************************************************
1028 * get_stgmed_for_global
1029 *
1030 * Returns a stg medium with a copy of the global handle
1031 */
1032 static HRESULT get_stgmed_for_global(HGLOBAL h, STGMEDIUM *med)
1033 {
1034 HRESULT hr;
1035
1036 med->pUnkForRelease = NULL;
1037 med->tymed = TYMED_NULL;
1038
1039 hr = dup_global_mem(h, GMEM_MOVEABLE, &med->u.hGlobal);
1040
1041 if(SUCCEEDED(hr)) med->tymed = TYMED_HGLOBAL;
1042
1043 return hr;
1044 }
1045
1046 /************************************************************************
1047 * get_stgmed_for_stream
1048 *
1049 * Returns a stg medium with a stream based on the handle
1050 */
1051 static HRESULT get_stgmed_for_stream(HGLOBAL h, STGMEDIUM *med)
1052 {
1053 HRESULT hr;
1054 HGLOBAL dst;
1055
1056 med->pUnkForRelease = NULL;
1057 med->tymed = TYMED_NULL;
1058
1059 hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
1060 if(FAILED(hr)) return hr;
1061
1062 hr = CreateStreamOnHGlobal(dst, TRUE, &med->u.pstm);
1063 if(FAILED(hr))
1064 {
1065 GlobalFree(dst);
1066 return hr;
1067 }
1068
1069 med->tymed = TYMED_ISTREAM;
1070 return hr;
1071 }
1072
1073 /************************************************************************
1074 * get_stgmed_for_storage
1075 *
1076 * Returns a stg medium with a storage based on the handle
1077 */
1078 static HRESULT get_stgmed_for_storage(HGLOBAL h, STGMEDIUM *med)
1079 {
1080 HRESULT hr;
1081 HGLOBAL dst;
1082 ILockBytes *lbs;
1083
1084 med->pUnkForRelease = NULL;
1085 med->tymed = TYMED_NULL;
1086
1087 hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
1088 if(FAILED(hr)) return hr;
1089
1090 hr = CreateILockBytesOnHGlobal(dst, TRUE, &lbs);
1091 if(FAILED(hr))
1092 {
1093 GlobalFree(dst);
1094 return hr;
1095 }
1096
1097 hr = StgOpenStorageOnILockBytes(lbs, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &med->u.pstg);
1098 ILockBytes_Release(lbs);
1099 if(FAILED(hr))
1100 {
1101 GlobalFree(dst);
1102 return hr;
1103 }
1104
1105 med->tymed = TYMED_ISTORAGE;
1106 return hr;
1107 }
1108
1109 static inline BOOL string_off_equal(const DVTARGETDEVICE *t1, WORD off1, const DVTARGETDEVICE *t2, WORD off2)
1110 {
1111 const WCHAR *str1, *str2;
1112
1113 if(off1 == 0 && off2 == 0) return TRUE;
1114 if(off1 == 0 || off2 == 0) return FALSE;
1115
1116 str1 = (const WCHAR*)((const char*)t1 + off1);
1117 str2 = (const WCHAR*)((const char*)t2 + off2);
1118
1119 return !lstrcmpW(str1, str2);
1120 }
1121
1122 static inline BOOL td_equal(const DVTARGETDEVICE *t1, const DVTARGETDEVICE *t2)
1123 {
1124 if(t1 == NULL && t2 == NULL) return TRUE;
1125 if(t1 == NULL || t2 == NULL) return FALSE;
1126
1127 if(!string_off_equal(t1, t1->tdDriverNameOffset, t2, t2->tdDriverNameOffset))
1128 return FALSE;
1129 if(!string_off_equal(t1, t1->tdDeviceNameOffset, t2, t2->tdDeviceNameOffset))
1130 return FALSE;
1131 if(!string_off_equal(t1, t1->tdPortNameOffset, t2, t2->tdPortNameOffset))
1132 return FALSE;
1133
1134 /* FIXME check devmode? */
1135
1136 return TRUE;
1137 }
1138
1139 /************************************************************************
1140 * snapshot_GetData
1141 */
1142 static HRESULT WINAPI snapshot_GetData(IDataObject *iface, FORMATETC *fmt,
1143 STGMEDIUM *med)
1144 {
1145 snapshot *This = impl_from_IDataObject(iface);
1146 HANDLE h;
1147 HRESULT hr;
1148 ole_priv_data *enum_data = NULL;
1149 ole_priv_data_entry *entry;
1150 DWORD mask;
1151
1152 TRACE("(%p, %p {%s}, %p)\n", iface, fmt, dump_fmtetc(fmt), med);
1153
1154 if ( !fmt || !med ) return E_INVALIDARG;
1155
1156 if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
1157
1158 if(!This->data)
1159 hr = get_current_dataobject(&This->data);
1160
1161 if(This->data)
1162 {
1163 hr = IDataObject_GetData(This->data, fmt, med);
1164 CloseClipboard();
1165 return hr;
1166 }
1167
1168 h = GetClipboardData(fmt->cfFormat);
1169 if(!h)
1170 {
1171 hr = DV_E_FORMATETC;
1172 goto end;
1173 }
1174
1175 hr = get_priv_data(&enum_data);
1176 if(FAILED(hr)) goto end;
1177
1178 entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
1179 if(entry)
1180 {
1181 if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
1182 {
1183 hr = DV_E_FORMATETC;
1184 goto end;
1185 }
1186 mask = fmt->tymed & entry->fmtetc.tymed;
1187 if(!mask) mask = fmt->tymed & (TYMED_ISTREAM | TYMED_HGLOBAL);
1188 }
1189 else /* non-Ole format */
1190 mask = fmt->tymed & TYMED_HGLOBAL;
1191
1192 if(mask & TYMED_ISTORAGE)
1193 hr = get_stgmed_for_storage(h, med);
1194 else if(mask & TYMED_HGLOBAL)
1195 hr = get_stgmed_for_global(h, med);
1196 else if(mask & TYMED_ISTREAM)
1197 hr = get_stgmed_for_stream(h, med);
1198 else
1199 {
1200 FIXME("Unhandled tymed - mask %x req tymed %x\n", mask, fmt->tymed);
1201 hr = E_FAIL;
1202 goto end;
1203 }
1204
1205 end:
1206 HeapFree(GetProcessHeap(), 0, enum_data);
1207 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1208 return hr;
1209 }
1210
1211 /************************************************************************
1212 * snapshot_GetDataHere
1213 */
1214 static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
1215 STGMEDIUM *med)
1216 {
1217 snapshot *This = impl_from_IDataObject(iface);
1218 HANDLE h;
1219 HRESULT hr;
1220 ole_priv_data *enum_data = NULL;
1221 ole_priv_data_entry *entry;
1222 TYMED supported;
1223
1224 TRACE("(%p, %p {%s}, %p (tymed %x)\n", iface, fmt, dump_fmtetc(fmt), med, med->tymed);
1225
1226 if ( !fmt || !med ) return E_INVALIDARG;
1227
1228 if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
1229
1230 if(!This->data)
1231 hr = get_current_dataobject(&This->data);
1232
1233 if(This->data)
1234 {
1235 hr = IDataObject_GetDataHere(This->data, fmt, med);
1236 if(SUCCEEDED(hr))
1237 {
1238 CloseClipboard();
1239 return hr;
1240 }
1241 }
1242
1243 h = GetClipboardData(fmt->cfFormat);
1244 if(!h)
1245 {
1246 hr = DV_E_FORMATETC;
1247 goto end;
1248 }
1249
1250 hr = get_priv_data(&enum_data);
1251 if(FAILED(hr)) goto end;
1252
1253 entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
1254 if(entry)
1255 {
1256 if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
1257 {
1258 hr = DV_E_FORMATETC;
1259 goto end;
1260 }
1261 supported = entry->fmtetc.tymed;
1262 }
1263 else /* non-Ole format */
1264 supported = TYMED_HGLOBAL;
1265
1266 switch(med->tymed)
1267 {
1268 case TYMED_HGLOBAL:
1269 {
1270 DWORD src_size = GlobalSize(h);
1271 DWORD dst_size = GlobalSize(med->u.hGlobal);
1272 hr = E_FAIL;
1273 if(dst_size >= src_size)
1274 {
1275 void *src = GlobalLock(h);
1276 void *dst = GlobalLock(med->u.hGlobal);
1277
1278 memcpy(dst, src, src_size);
1279 GlobalUnlock(med->u.hGlobal);
1280 GlobalUnlock(h);
1281 hr = S_OK;
1282 }
1283 break;
1284 }
1285 case TYMED_ISTREAM:
1286 {
1287 DWORD src_size = GlobalSize(h);
1288 void *src = GlobalLock(h);
1289 hr = IStream_Write(med->u.pstm, src, src_size, NULL);
1290 GlobalUnlock(h);
1291 break;
1292 }
1293 case TYMED_ISTORAGE:
1294 {
1295 STGMEDIUM copy;
1296 if(!(supported & TYMED_ISTORAGE))
1297 {
1298 hr = E_FAIL;
1299 goto end;
1300 }
1301 hr = get_stgmed_for_storage(h, ©);
1302 if(SUCCEEDED(hr))
1303 {
1304 hr = IStorage_CopyTo(copy.u.pstg, 0, NULL, NULL, med->u.pstg);
1305 ReleaseStgMedium(©);
1306 }
1307 break;
1308 }
1309 default:
1310 FIXME("Unhandled tymed - supported %x req tymed %x\n", supported, med->tymed);
1311 hr = E_FAIL;
1312 goto end;
1313 }
1314
1315 end:
1316 HeapFree(GetProcessHeap(), 0, enum_data);
1317 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1318 return hr;
1319 }
1320
1321 /************************************************************************
1322 * snapshot_QueryGetData
1323 *
1324 * The OLE Clipboard's implementation of this method delegates to
1325 * a data source if there is one or wraps around the windows clipboard
1326 * function IsClipboardFormatAvailable() otherwise.
1327 *
1328 */
1329 static HRESULT WINAPI snapshot_QueryGetData(IDataObject *iface, FORMATETC *fmt)
1330 {
1331 FIXME("(%p, %p {%s})\n", iface, fmt, dump_fmtetc(fmt));
1332
1333 if (!fmt) return E_INVALIDARG;
1334
1335 if ( fmt->dwAspect != DVASPECT_CONTENT ) return DV_E_FORMATETC;
1336
1337 if ( fmt->lindex != -1 ) return DV_E_FORMATETC;
1338
1339 return (IsClipboardFormatAvailable(fmt->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
1340 }
1341
1342 /************************************************************************
1343 * snapshot_GetCanonicalFormatEtc
1344 */
1345 static HRESULT WINAPI snapshot_GetCanonicalFormatEtc(IDataObject *iface, FORMATETC *fmt_in,
1346 FORMATETC *fmt_out)
1347 {
1348 TRACE("(%p, %p, %p)\n", iface, fmt_in, fmt_out);
1349
1350 if ( !fmt_in || !fmt_out ) return E_INVALIDARG;
1351
1352 *fmt_out = *fmt_in;
1353 return DATA_S_SAMEFORMATETC;
1354 }
1355
1356 /************************************************************************
1357 * snapshot_SetData
1358 *
1359 * The OLE Clipboard does not implement this method
1360 */
1361 static HRESULT WINAPI snapshot_SetData(IDataObject *iface, FORMATETC *fmt,
1362 STGMEDIUM *med, BOOL release)
1363 {
1364 TRACE("(%p, %p, %p, %d): not implemented\n", iface, fmt, med, release);
1365 return E_NOTIMPL;
1366 }
1367
1368 /************************************************************************
1369 * snapshot_EnumFormatEtc
1370 *
1371 */
1372 static HRESULT WINAPI snapshot_EnumFormatEtc(IDataObject *iface, DWORD dir,
1373 IEnumFORMATETC **enum_fmt)
1374 {
1375 HRESULT hr;
1376 ole_priv_data *data = NULL;
1377
1378 TRACE("(%p, %x, %p)\n", iface, dir, enum_fmt);
1379
1380 *enum_fmt = NULL;
1381
1382 if ( dir != DATADIR_GET ) return E_NOTIMPL;
1383 if ( !OpenClipboard(NULL) ) return CLIPBRD_E_CANT_OPEN;
1384
1385 hr = get_priv_data(&data);
1386
1387 if(FAILED(hr)) goto end;
1388
1389 hr = enum_fmtetc_construct( data, 0, enum_fmt );
1390
1391 end:
1392 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1393 return hr;
1394 }
1395
1396 /************************************************************************
1397 * snapshot_DAdvise
1398 *
1399 * The OLE Clipboard does not implement this method
1400 */
1401 static HRESULT WINAPI snapshot_DAdvise(IDataObject *iface, FORMATETC *fmt,
1402 DWORD flags, IAdviseSink *sink,
1403 DWORD *conn)
1404 {
1405 TRACE("(%p, %p, %x, %p, %p): not implemented\n", iface, fmt, flags, sink, conn);
1406 return E_NOTIMPL;
1407 }
1408
1409 /************************************************************************
1410 * snapshot_DUnadvise
1411 *
1412 * The OLE Clipboard does not implement this method
1413 */
1414 static HRESULT WINAPI snapshot_DUnadvise(IDataObject* iface, DWORD conn)
1415 {
1416 TRACE("(%p, %d): not implemented\n", iface, conn);
1417 return E_NOTIMPL;
1418 }
1419
1420 /************************************************************************
1421 * snapshot_EnumDAdvise
1422 *
1423 * The OLE Clipboard does not implement this method
1424 */
1425 static HRESULT WINAPI snapshot_EnumDAdvise(IDataObject* iface,
1426 IEnumSTATDATA** enum_advise)
1427 {
1428 TRACE("(%p, %p): not implemented\n", iface, enum_advise);
1429 return E_NOTIMPL;
1430 }
1431
1432 static const IDataObjectVtbl snapshot_vtable =
1433 {
1434 snapshot_QueryInterface,
1435 snapshot_AddRef,
1436 snapshot_Release,
1437 snapshot_GetData,
1438 snapshot_GetDataHere,
1439 snapshot_QueryGetData,
1440 snapshot_GetCanonicalFormatEtc,
1441 snapshot_SetData,
1442 snapshot_EnumFormatEtc,
1443 snapshot_DAdvise,
1444 snapshot_DUnadvise,
1445 snapshot_EnumDAdvise
1446 };
1447
1448 /*---------------------------------------------------------------------*
1449 * Internal implementation methods for the OLE clipboard
1450 *---------------------------------------------------------------------*/
1451
1452 static snapshot *snapshot_construct(DWORD seq_no)
1453 {
1454 snapshot *This;
1455
1456 This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
1457 if (!This) return NULL;
1458
1459 This->lpVtbl = &snapshot_vtable;
1460 This->ref = 0;
1461 This->seq_no = seq_no;
1462 This->data = NULL;
1463
1464 return This;
1465 }
1466
1467 /*********************************************************
1468 * register_clipboard_formats
1469 */
1470 static void register_clipboard_formats(void)
1471 {
1472 static const WCHAR OwnerLink[] = {'O','w','n','e','r','L','i','n','k',0};
1473 static const WCHAR FileName[] = {'F','i','l','e','N','a','m','e',0};
1474 static const WCHAR FileNameW[] = {'F','i','l','e','N','a','m','e','W',0};
1475 static const WCHAR DataObject[] = {'D','a','t','a','O','b','j','e','c','t',0};
1476 static const WCHAR EmbeddedObject[] = {'E','m','b','e','d','d','e','d',' ','O','b','j','e','c','t',0};
1477 static const WCHAR EmbedSource[] = {'E','m','b','e','d',' ','S','o','u','r','c','e',0};
1478 static const WCHAR CustomLinkSource[] = {'C','u','s','t','o','m',' ','L','i','n','k',' ','S','o','u','r','c','e',0};
1479 static const WCHAR LinkSource[] = {'L','i','n','k',' ','S','o','u','r','c','e',0};
1480 static const WCHAR ObjectDescriptor[] = {'O','b','j','e','c','t',' ','D','e','s','c','r','i','p','t','o','r',0};
1481 static const WCHAR LinkSourceDescriptor[] = {'L','i','n','k',' ','S','o','u','r','c','e',' ',
1482 'D','e','s','c','r','i','p','t','o','r',0};
1483 static const WCHAR OlePrivateData[] = {'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0};
1484
1485 static const WCHAR WineMarshalledDataObject[] = {'W','i','n','e',' ','M','a','r','s','h','a','l','l','e','d',' ',
1486 'D','a','t','a','O','b','j','e','c','t',0};
1487
1488 ownerlink_clipboard_format = RegisterClipboardFormatW(OwnerLink);
1489 filename_clipboard_format = RegisterClipboardFormatW(FileName);
1490 filenameW_clipboard_format = RegisterClipboardFormatW(FileNameW);
1491 dataobject_clipboard_format = RegisterClipboardFormatW(DataObject);
1492 embedded_object_clipboard_format = RegisterClipboardFormatW(EmbeddedObject);
1493 embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSource);
1494 custom_link_source_clipboard_format = RegisterClipboardFormatW(CustomLinkSource);
1495 link_source_clipboard_format = RegisterClipboardFormatW(LinkSource);
1496 object_descriptor_clipboard_format = RegisterClipboardFormatW(ObjectDescriptor);
1497 link_source_descriptor_clipboard_format = RegisterClipboardFormatW(LinkSourceDescriptor);
1498 ole_private_data_clipboard_format = RegisterClipboardFormatW(OlePrivateData);
1499
1500 wine_marshal_clipboard_format = RegisterClipboardFormatW(WineMarshalledDataObject);
1501 }
1502
1503 /***********************************************************************
1504 * OLEClipbrd_Initialize()
1505 * Initializes the OLE clipboard.
1506 */
1507 void OLEClipbrd_Initialize(void)
1508 {
1509 register_clipboard_formats();
1510
1511 if ( !theOleClipboard )
1512 {
1513 ole_clipbrd* clipbrd;
1514 HGLOBAL h;
1515
1516 TRACE("()\n");
1517
1518 clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
1519 if (!clipbrd) return;
1520
1521 clipbrd->latest_snapshot = NULL;
1522 clipbrd->window = NULL;
1523 clipbrd->src_data = NULL;
1524 clipbrd->cached_enum = NULL;
1525
1526 h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
1527 if(!h)
1528 {
1529 HeapFree(GetProcessHeap(), 0, clipbrd);
1530 return;
1531 }
1532
1533 if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
1534 {
1535 GlobalFree(h);
1536 HeapFree(GetProcessHeap(), 0, clipbrd);
1537 return;
1538 }
1539
1540 theOleClipboard = clipbrd;
1541 }
1542 }
1543
1544 /***********************************************************************
1545 * OLEClipbrd_UnInitialize()
1546 * Un-Initializes the OLE clipboard
1547 */
1548 void OLEClipbrd_UnInitialize(void)
1549 {
1550 ole_clipbrd *clipbrd = theOleClipboard;
1551
1552 TRACE("()\n");
1553
1554 if ( clipbrd )
1555 {
1556 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1557 HINSTANCE hinst = GetModuleHandleW(ole32W);
1558
1559 if ( clipbrd->window )
1560 {
1561 DestroyWindow(clipbrd->window);
1562 UnregisterClassW( clipbrd_wndclass, hinst );
1563 }
1564
1565 IStream_Release(clipbrd->marshal_data);
1566 HeapFree(GetProcessHeap(), 0, clipbrd);
1567 theOleClipboard = NULL;
1568 }
1569 }
1570
1571 /*********************************************************************
1572 * set_clipboard_formats
1573 *
1574 * Enumerate all formats supported by the source and make
1575 * those formats available using delayed rendering using SetClipboardData.
1576 * Cache the enumeration list and make that list visibile as the
1577 * 'Ole Private Data' format on the clipboard.
1578 *
1579 */
1580 static HRESULT set_clipboard_formats(ole_clipbrd *clipbrd, IDataObject *data)
1581 {
1582 HRESULT hr;
1583 FORMATETC fmt;
1584 IEnumFORMATETC *enum_fmt;
1585 HGLOBAL priv_data_handle;
1586 DWORD_PTR target_offset;
1587 ole_priv_data *priv_data;
1588 DWORD count = 0, needed = sizeof(*priv_data), idx;
1589
1590 hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
1591 if(FAILED(hr)) return hr;
1592
1593 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1594 {
1595 count++;
1596 needed += sizeof(priv_data->entries[0]);
1597 if(fmt.ptd)
1598 {
1599 needed += fmt.ptd->tdSize;
1600 CoTaskMemFree(fmt.ptd);
1601 }
1602 }
1603
1604 /* Windows pads the list with two empty ole_priv_data_entries, one
1605 * after the entries array and one after the target device data.
1606 * Allocating with zero init to zero these pads. */
1607
1608 needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
1609 priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
1610 priv_data = GlobalLock(priv_data_handle);
1611
1612 priv_data->unk1 = 0;
1613 priv_data->size = needed;
1614 priv_data->unk2 = 1;
1615 priv_data->count = count;
1616 priv_data->unk3[0] = 0;
1617 priv_data->unk3[1] = 0;
1618
1619 IEnumFORMATETC_Reset(enum_fmt);
1620
1621 idx = 0;
1622 target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
1623
1624 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1625 {
1626 TRACE("%s\n", dump_fmtetc(&fmt));
1627
1628 priv_data->entries[idx].fmtetc = fmt;
1629 if(fmt.ptd)
1630 {
1631 memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
1632 priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
1633 target_offset += fmt.ptd->tdSize;
1634 CoTaskMemFree(fmt.ptd);
1635 }
1636
1637 priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
1638 priv_data->entries[idx].unk[0] = 0;
1639 priv_data->entries[idx].unk[1] = 0;
1640
1641 if (priv_data->entries[idx].first_use)
1642 SetClipboardData(fmt.cfFormat, NULL);
1643
1644 idx++;
1645 }
1646
1647 IEnumFORMATETC_Release(enum_fmt);
1648
1649 /* Cache the list and fixup any target device offsets to ptrs */
1650 clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
1651 memcpy(clipbrd->cached_enum, priv_data, needed);
1652 for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
1653 clipbrd->cached_enum->entries[idx].fmtetc.ptd =
1654 td_offs_to_ptr(clipbrd->cached_enum, (DWORD_PTR)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
1655
1656 GlobalUnlock(priv_data_handle);
1657 SetClipboardData(ole_private_data_clipboard_format, priv_data_handle);
1658
1659 return S_OK;
1660 }
1661
1662 static HWND create_clipbrd_window(void);
1663
1664 /***********************************************************************
1665 * get_clipbrd_window
1666 */
1667 static inline HRESULT get_clipbrd_window(ole_clipbrd *clipbrd, HWND *wnd)
1668 {
1669 if ( !clipbrd->window )
1670 clipbrd->window = create_clipbrd_window();
1671
1672 *wnd = clipbrd->window;
1673 return *wnd ? S_OK : E_FAIL;
1674 }
1675
1676
1677 /**********************************************************************
1678 * release_marshal_data
1679 *
1680 * Releases the data and sets the stream back to zero size.
1681 */
1682 static inline void release_marshal_data(IStream *stm)
1683 {
1684 LARGE_INTEGER pos;
1685 ULARGE_INTEGER size;
1686 pos.QuadPart = size.QuadPart = 0;
1687
1688 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1689 CoReleaseMarshalData(stm);
1690 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1691 IStream_SetSize(stm, size);
1692 }
1693
1694 /***********************************************************************
1695 * expose_marshalled_dataobject
1696 *
1697 * Sets the marshalled dataobject to the clipboard. In the flushed case
1698 * we set a zero sized HGLOBAL to clear the old marshalled data.
1699 */
1700 static HRESULT expose_marshalled_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1701 {
1702 HGLOBAL h;
1703
1704 if(data)
1705 {
1706 HGLOBAL h_stm;
1707 GetHGlobalFromStream(clipbrd->marshal_data, &h_stm);
1708 dup_global_mem(h_stm, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
1709 }
1710 else /* flushed */
1711 h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 0);
1712
1713 if(!h) return E_OUTOFMEMORY;
1714
1715 SetClipboardData(wine_marshal_clipboard_format, h);
1716 return S_OK;
1717 }
1718
1719 /***********************************************************************
1720 * set_src_dataobject
1721 *
1722 * Clears and sets the clipboard's src IDataObject.
1723 *
1724 * To marshal the source dataobject we do something rather different from Windows.
1725 * We set a clipboard format which contains the marshalled data.
1726 * Windows sets two window props one of which is an IID, the other is an endpoint number.
1727 */
1728 static HRESULT set_src_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1729 {
1730 HRESULT hr;
1731 HWND wnd;
1732
1733 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1734
1735 if(clipbrd->src_data)
1736 {
1737 release_marshal_data(clipbrd->marshal_data);
1738
1739 IDataObject_Release(clipbrd->src_data);
1740 clipbrd->src_data = NULL;
1741 HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1742 clipbrd->cached_enum = NULL;
1743 }
1744
1745 if(data)
1746 {
1747 IUnknown *unk;
1748
1749 IDataObject_AddRef(data);
1750 clipbrd->src_data = data;
1751
1752 IDataObject_QueryInterface(data, &IID_IUnknown, (void**)&unk);
1753 hr = CoMarshalInterface(clipbrd->marshal_data, &IID_IDataObject, unk,
1754 MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
1755 IUnknown_Release(unk); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
1756 if(FAILED(hr)) return hr;
1757 hr = set_clipboard_formats(clipbrd, data);
1758 }
1759 return hr;
1760 }
1761
1762 /***********************************************************************
1763 * clipbrd_wndproc
1764 */
1765 static LRESULT CALLBACK clipbrd_wndproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1766 {
1767 ole_clipbrd *clipbrd;
1768
1769 get_ole_clipbrd(&clipbrd);
1770
1771 switch (message)
1772 {
1773 case WM_RENDERFORMAT:
1774 {
1775 UINT cf = wparam;
1776 ole_priv_data_entry *entry;
1777
1778 TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
1779 entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
1780
1781 if(entry)
1782 render_format(clipbrd->src_data, &entry->fmtetc);
1783
1784 break;
1785 }
1786
1787 case WM_RENDERALLFORMATS:
1788 {
1789 DWORD i;
1790 ole_priv_data_entry *entries = clipbrd->cached_enum->entries;
1791
1792 TRACE("(): WM_RENDERALLFORMATS\n");
1793
1794 for(i = 0; i < clipbrd->cached_enum->count; i++)
1795 {
1796 if(entries[i].first_use)
1797 render_format(clipbrd->src_data, &entries[i].fmtetc);
1798 }
1799 break;
1800 }
1801
1802 case WM_DESTROYCLIPBOARD:
1803 {
1804 TRACE("(): WM_DESTROYCLIPBOARD\n");
1805
1806 set_src_dataobject(clipbrd, NULL);
1807 break;
1808 }
1809
1810 default:
1811 return DefWindowProcW(hwnd, message, wparam, lparam);
1812 }
1813
1814 return 0;
1815 }
1816
1817
1818 /***********************************************************************
1819 * create_clipbrd_window
1820 */
1821 static HWND create_clipbrd_window(void)
1822 {
1823 WNDCLASSEXW class;
1824 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1825 static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
1826 HINSTANCE hinst = GetModuleHandleW(ole32W);
1827
1828 class.cbSize = sizeof(class);
1829 class.style = 0;
1830 class.lpfnWndProc = clipbrd_wndproc;
1831 class.cbClsExtra = 0;
1832 class.cbWndExtra = 0;
1833 class.hInstance = hinst;
1834 class.hIcon = 0;
1835 class.hCursor = 0;
1836 class.hbrBackground = 0;
1837 class.lpszMenuName = NULL;
1838 class.lpszClassName = clipbrd_wndclass;
1839 class.hIconSm = NULL;
1840
1841 RegisterClassExW(&class);
1842
1843 return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
1844 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1845 NULL, NULL, hinst, 0);
1846 }
1847
1848 /*********************************************************************
1849 * set_dataobject_format
1850 *
1851 * Windows creates a 'DataObject' clipboard format that contains the
1852 * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
1853 */
1854 static HRESULT set_dataobject_format(HWND hwnd)
1855 {
1856 HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
1857 HWND *data;
1858
1859 if(!h) return E_OUTOFMEMORY;
1860
1861 data = GlobalLock(h);
1862 *data = hwnd;
1863 GlobalUnlock(h);
1864
1865 if(!SetClipboardData(dataobject_clipboard_format, h))
1866 {
1867 GlobalFree(h);
1868 return CLIPBRD_E_CANT_SET;
1869 }
1870
1871 return S_OK;
1872 }
1873
1874 /*---------------------------------------------------------------------*
1875 * Win32 OLE clipboard API
1876 *---------------------------------------------------------------------*/
1877
1878 /***********************************************************************
1879 * OleSetClipboard [OLE32.@]
1880 * Places a pointer to the specified data object onto the clipboard,
1881 * making the data object accessible to the OleGetClipboard function.
1882 *
1883 * RETURNS
1884 *
1885 * S_OK IDataObject pointer placed on the clipboard
1886 * CLIPBRD_E_CANT_OPEN OpenClipboard failed
1887 * CLIPBRD_E_CANT_EMPTY EmptyClipboard failed
1888 * CLIPBRD_E_CANT_CLOSE CloseClipboard failed
1889 * CLIPBRD_E_CANT_SET SetClipboard failed
1890 */
1891
1892 HRESULT WINAPI OleSetClipboard(IDataObject* data)
1893 {
1894 HRESULT hr;
1895 ole_clipbrd *clipbrd;
1896 HWND wnd;
1897
1898 TRACE("(%p)\n", data);
1899
1900 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1901
1902 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1903
1904 if ( !OpenClipboard(wnd) ) return CLIPBRD_E_CANT_OPEN;
1905
1906 if ( !EmptyClipboard() )
1907 {
1908 hr = CLIPBRD_E_CANT_EMPTY;
1909 goto end;
1910 }
1911
1912 hr = set_src_dataobject(clipbrd, data);
1913 if(FAILED(hr)) goto end;
1914
1915 if(data)
1916 {
1917 hr = expose_marshalled_dataobject(clipbrd, data);
1918 if(FAILED(hr)) goto end;
1919 hr = set_dataobject_format(wnd);
1920 }
1921
1922 end:
1923
1924 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1925
1926 if ( FAILED(hr) )
1927 {
1928 expose_marshalled_dataobject(clipbrd, NULL);
1929 set_src_dataobject(clipbrd, NULL);
1930 }
1931
1932 return hr;
1933 }
1934
1935
1936 /***********************************************************************
1937 * OleGetClipboard [OLE32.@]
1938 * Returns a pointer to our internal IDataObject which represents the conceptual
1939 * state of the Windows clipboard. If the current clipboard already contains
1940 * an IDataObject, our internal IDataObject will delegate to this object.
1941 */
1942 HRESULT WINAPI OleGetClipboard(IDataObject **obj)
1943 {
1944 HRESULT hr;
1945 ole_clipbrd *clipbrd;
1946 DWORD seq_no;
1947
1948 TRACE("(%p)\n", obj);
1949
1950 if(!obj) return E_INVALIDARG;
1951
1952 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1953
1954 seq_no = GetClipboardSequenceNumber();
1955 if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
1956 clipbrd->latest_snapshot = NULL;
1957
1958 if(!clipbrd->latest_snapshot)
1959 {
1960 clipbrd->latest_snapshot = snapshot_construct(seq_no);
1961 if(!clipbrd->latest_snapshot) return E_OUTOFMEMORY;
1962 }
1963
1964 *obj = (IDataObject*)&clipbrd->latest_snapshot->lpVtbl;
1965 IDataObject_AddRef(*obj);
1966
1967 return S_OK;
1968 }
1969
1970 /******************************************************************************
1971 * OleFlushClipboard [OLE32.@]
1972 * Renders the data from the source IDataObject into the windows clipboard
1973 *
1974 * TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
1975 * by copying the storage into global memory. Subsequently the default
1976 * data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
1977 * back to TYMED_IStorage.
1978 */
1979 HRESULT WINAPI OleFlushClipboard(void)
1980 {
1981 HRESULT hr;
1982 ole_clipbrd *clipbrd;
1983 HWND wnd;
1984
1985 TRACE("()\n");
1986
1987 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1988
1989 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1990
1991 /*
1992 * Already flushed or no source DataObject? Nothing to do.
1993 */
1994 if (!clipbrd->src_data) return S_OK;
1995
1996 if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
1997
1998 SendMessageW(wnd, WM_RENDERALLFORMATS, 0, 0);
1999
2000 hr = set_dataobject_format(NULL);
2001
2002 expose_marshalled_dataobject(clipbrd, NULL);
2003 set_src_dataobject(clipbrd, NULL);
2004
2005 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
2006
2007 return hr;
2008 }
2009
2010
2011 /***********************************************************************
2012 * OleIsCurrentClipboard [OLE32.@]
2013 */
2014 HRESULT WINAPI OleIsCurrentClipboard(IDataObject *data)
2015 {
2016 HRESULT hr;
2017 ole_clipbrd *clipbrd;
2018 TRACE("()\n");
2019
2020 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
2021
2022 if (data == NULL) return S_FALSE;
2023
2024 return (data == clipbrd->src_data) ? S_OK : S_FALSE;
2025 }
2026
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.