projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[OLE32]
[reactos.git] / reactos / dll / win32 / ole32 / clipboard.c
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 IDataObject IDataObject_iface;
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 CONTAINING_RECORD(iface, snapshot, IDataObject_iface);
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 IEnumFORMATETC IEnumFORMATETC_iface;
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 CONTAINING_RECORD(iface, enum_fmtetc, IEnumFORMATETC_iface);
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->IEnumFORMATETC_iface.lpVtbl = &efvt;
444 ef->data = data;
445 ef->pos = pos;
446
447 TRACE("(%p)->()\n", ef);
448 *obj = &ef->IEnumFORMATETC_iface;
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 * dup_metafilepict
483 *
484 * Helper function to duplicate a handle to a METAFILEPICT, and the
485 * contained HMETAFILE.
486 */
487 static HRESULT dup_metafilepict(HGLOBAL src, HGLOBAL *pdest)
488 {
489 HRESULT hr;
490 HGLOBAL dest;
491 METAFILEPICT *dest_ptr;
492
493 *pdest = NULL;
494
495 /* Copy the METAFILEPICT structure. */
496 hr = dup_global_mem(src, GMEM_DDESHARE|GMEM_MOVEABLE, &dest);
497 if (FAILED(hr)) return hr;
498
499 dest_ptr = GlobalLock(dest);
500 if (!dest_ptr) return E_FAIL;
501
502 /* Give the new METAFILEPICT a separate HMETAFILE. */
503 dest_ptr->hMF = CopyMetaFileW(dest_ptr->hMF, NULL);
504 if (dest_ptr->hMF)
505 {
506 GlobalUnlock(dest);
507 *pdest = dest;
508 return S_OK;
509 }
510 else
511 {
512 GlobalUnlock(dest);
513 GlobalFree(dest);
514 return E_FAIL;
515 }
516 }
517
518 /***********************************************************************
519 * free_metafilepict
520 *
521 * Helper function to GlobalFree a handle to a METAFILEPICT, and also
522 * free the contained HMETAFILE.
523 */
524 static void free_metafilepict(HGLOBAL src)
525 {
526 METAFILEPICT *src_ptr;
527
528 src_ptr = GlobalLock(src);
529 if (src_ptr)
530 {
531 DeleteMetaFile(src_ptr->hMF);
532 GlobalUnlock(src);
533 }
534 GlobalFree(src);
535 }
536
537 /***********************************************************************
538 * dup_bitmap
539 *
540 * Helper function to duplicate an HBITMAP.
541 */
542 static HRESULT dup_bitmap(HBITMAP src, HBITMAP *pdest)
543 {
544 HDC src_dc;
545 HGDIOBJ orig_src_bitmap;
546 BITMAP bm;
547 HBITMAP dest;
548
549 src_dc = CreateCompatibleDC(NULL);
550 orig_src_bitmap = SelectObject(src_dc, src);
551 GetObjectW(src, sizeof bm, &bm);
552 dest = CreateCompatibleBitmap(src_dc, bm.bmWidth, bm.bmHeight);
553 if (dest)
554 {
555 HDC dest_dc = CreateCompatibleDC(NULL);
556 HGDIOBJ orig_dest_bitmap = SelectObject(dest_dc, dest);
557 BitBlt(dest_dc, 0, 0, bm.bmWidth, bm.bmHeight, src_dc, 0, 0, SRCCOPY);
558 SelectObject(dest_dc, orig_dest_bitmap);
559 DeleteDC(dest_dc);
560 }
561 SelectObject(src_dc, orig_src_bitmap);
562 DeleteDC(src_dc);
563 *pdest = dest;
564 return dest ? S_OK : E_FAIL;
565 }
566
567 /************************************************************
568 * render_embed_source_hack
569 *
570 * This is clearly a hack and has no place in the clipboard code.
571 *
572 */
573 static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
574 {
575 STGMEDIUM std;
576 HGLOBAL hStorage = 0;
577 HRESULT hr = S_OK;
578 ILockBytes *ptrILockBytes;
579
580 memset(&std, 0, sizeof(STGMEDIUM));
581 std.tymed = fmt->tymed = TYMED_ISTORAGE;
582
583 hStorage = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, 0);
584 if (hStorage == NULL) return E_OUTOFMEMORY;
585 hr = CreateILockBytesOnHGlobal(hStorage, FALSE, &ptrILockBytes);
586 hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
587 ILockBytes_Release(ptrILockBytes);
588
589 if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->src_data, fmt, &std)))
590 {
591 WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%x)\n", hr);
592 GlobalFree(hStorage);
593 return hr;
594 }
595
596 if (1) /* check whether the presentation data is already -not- present */
597 {
598 FORMATETC fmt2;
599 STGMEDIUM std2;
600 METAFILEPICT *mfp = 0;
601
602 fmt2.cfFormat = CF_METAFILEPICT;
603 fmt2.ptd = 0;
604 fmt2.dwAspect = DVASPECT_CONTENT;
605 fmt2.lindex = -1;
606 fmt2.tymed = TYMED_MFPICT;
607
608 memset(&std2, 0, sizeof(STGMEDIUM));
609 std2.tymed = TYMED_MFPICT;
610
611 /* Get the metafile picture out of it */
612
613 if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->src_data, &fmt2, &std2)))
614 {
615 mfp = GlobalLock(std2.u.hGlobal);
616 }
617
618 if (mfp)
619 {
620 OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
621 IStream *pStream = 0;
622 void *mfBits;
623 PresentationDataHeader pdh;
624 INT nSize;
625 CLSID clsID;
626 LPOLESTR strProgID;
627 CHAR strOleTypeName[51];
628 BYTE OlePresStreamHeader [] =
629 {
630 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
631 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
632 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
633 0x00, 0x00, 0x00, 0x00
634 };
635
636 nSize = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
637
638 memset(&pdh, 0, sizeof(PresentationDataHeader));
639 memcpy(&pdh, OlePresStreamHeader, sizeof(OlePresStreamHeader));
640
641 pdh.dwObjectExtentX = mfp->xExt;
642 pdh.dwObjectExtentY = mfp->yExt;
643 pdh.dwSize = nSize;
644
645 hr = IStorage_CreateStream(std.u.pstg, name, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
646
647 hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
648
649 mfBits = HeapAlloc(GetProcessHeap(), 0, nSize);
650 nSize = GetMetaFileBitsEx(mfp->hMF, nSize, mfBits);
651
652 hr = IStream_Write(pStream, mfBits, nSize, NULL);
653
654 IStream_Release(pStream);
655
656 HeapFree(GetProcessHeap(), 0, mfBits);
657
658 GlobalUnlock(std2.u.hGlobal);
659 ReleaseStgMedium(&std2);
660
661 ReadClassStg(std.u.pstg, &clsID);
662 ProgIDFromCLSID(&clsID, &strProgID);
663
664 WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
665 STORAGE_CreateOleStream(std.u.pstg, 0);
666 OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
667 CoTaskMemFree(strProgID);
668 }
669 }
670
671 if ( !SetClipboardData( fmt->cfFormat, hStorage ) )
672 {
673 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
674 GlobalFree(hStorage);
675 hr = CLIPBRD_E_CANT_SET;
676 }
677
678 ReleaseStgMedium(&std);
679 return hr;
680 }
681
682 /************************************************************************
683 * find_format_in_list
684 *
685 * Returns the first entry that matches the provided clipboard format.
686 */
687 static inline ole_priv_data_entry *find_format_in_list(ole_priv_data_entry *entries, DWORD num, UINT cf)
688 {
689 DWORD i;
690 for(i = 0; i < num; i++)
691 if(entries[i].fmtetc.cfFormat == cf)
692 return &entries[i];
693
694 return NULL;
695 }
696
697 /***************************************************************************
698 * get_data_from_storage
699 *
700 * Returns storage data in an HGLOBAL.
701 */
702 static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
703 {
704 HGLOBAL h;
705 IStorage *stg;
706 HRESULT hr;
707 FORMATETC stg_fmt;
708 STGMEDIUM med;
709 ILockBytes *lbs;
710
711 *mem = NULL;
712
713 h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
714 if(!h) return E_OUTOFMEMORY;
715
716 hr = CreateILockBytesOnHGlobal(h, FALSE, &lbs);
717 if(SUCCEEDED(hr))
718 {
719 hr = StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
720 ILockBytes_Release(lbs);
721 }
722 if(FAILED(hr))
723 {
724 GlobalFree(h);
725 return hr;
726 }
727
728 stg_fmt = *fmt;
729 med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
730 med.u.pstg = stg;
731 med.pUnkForRelease = NULL;
732
733 hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
734 if(FAILED(hr))
735 {
736 med.u.pstg = NULL;
737 hr = IDataObject_GetData(data, &stg_fmt, &med);
738 if(FAILED(hr)) goto end;
739
740 hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
741 ReleaseStgMedium(&med);
742 if(FAILED(hr)) goto end;
743 }
744 *mem = h;
745
746 end:
747 IStorage_Release(stg);
748 if(FAILED(hr)) GlobalFree(h);
749 return hr;
750 }
751
752 /***************************************************************************
753 * get_data_from_stream
754 *
755 * Returns stream data in an HGLOBAL.
756 */
757 static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
758 {
759 HGLOBAL h;
760 IStream *stm = NULL;
761 HRESULT hr;
762 FORMATETC stm_fmt;
763 STGMEDIUM med;
764
765 *mem = NULL;
766
767 h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
768 if(!h) return E_OUTOFMEMORY;
769
770 hr = CreateStreamOnHGlobal(h, FALSE, &stm);
771 if(FAILED(hr)) goto error;
772
773 stm_fmt = *fmt;
774 med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
775 med.u.pstm = stm;
776 med.pUnkForRelease = NULL;
777
778 hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
779 if(FAILED(hr))
780 {
781 LARGE_INTEGER offs;
782 ULARGE_INTEGER pos;
783
784 med.u.pstm = NULL;
785 hr = IDataObject_GetData(data, &stm_fmt, &med);
786 if(FAILED(hr)) goto error;
787
788 offs.QuadPart = 0;
789 IStream_Seek(med.u.pstm, offs, STREAM_SEEK_CUR, &pos);
790 IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
791 hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
792 ReleaseStgMedium(&med);
793 if(FAILED(hr)) goto error;
794 }
795 *mem = h;
796 IStream_Release(stm);
797 return S_OK;
798
799 error:
800 if(stm) IStream_Release(stm);
801 GlobalFree(h);
802 return hr;
803 }
804
805 /***************************************************************************
806 * get_data_from_global
807 *
808 * Returns global data in an HGLOBAL.
809 */
810 static HRESULT get_data_from_global(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
811 {
812 HGLOBAL h;
813 HRESULT hr;
814 FORMATETC mem_fmt;
815 STGMEDIUM med;
816
817 *mem = NULL;
818
819 mem_fmt = *fmt;
820 mem_fmt.tymed = TYMED_HGLOBAL;
821
822 hr = IDataObject_GetData(data, &mem_fmt, &med);
823 if(FAILED(hr)) return hr;
824
825 hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
826
827 if(SUCCEEDED(hr)) *mem = h;
828
829 ReleaseStgMedium(&med);
830
831 return hr;
832 }
833
834 /***************************************************************************
835 * get_data_from_enhmetafile
836 */
837 static HRESULT get_data_from_enhmetafile(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
838 {
839 HENHMETAFILE copy;
840 HRESULT hr;
841 FORMATETC mem_fmt;
842 STGMEDIUM med;
843
844 *mem = NULL;
845
846 mem_fmt = *fmt;
847 mem_fmt.tymed = TYMED_ENHMF;
848
849 hr = IDataObject_GetData(data, &mem_fmt, &med);
850 if(FAILED(hr)) return hr;
851
852 copy = CopyEnhMetaFileW(med.u.hEnhMetaFile, NULL);
853 if(copy) *mem = (HGLOBAL)copy;
854 else hr = E_FAIL;
855
856 ReleaseStgMedium(&med);
857
858 return hr;
859 }
860
861 /***************************************************************************
862 * get_data_from_metafilepict
863 */
864 static HRESULT get_data_from_metafilepict(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
865 {
866 HGLOBAL copy;
867 HRESULT hr;
868 FORMATETC mem_fmt;
869 STGMEDIUM med;
870
871 *mem = NULL;
872
873 mem_fmt = *fmt;
874 mem_fmt.tymed = TYMED_MFPICT;
875
876 hr = IDataObject_GetData(data, &mem_fmt, &med);
877 if(FAILED(hr)) return hr;
878
879 hr = dup_metafilepict(med.u.hMetaFilePict, &copy);
880
881 if(SUCCEEDED(hr)) *mem = copy;
882
883 ReleaseStgMedium(&med);
884
885 return hr;
886 }
887
888 /***************************************************************************
889 * get_data_from_bitmap
890 *
891 * Returns bitmap in an HBITMAP.
892 */
893 static HRESULT get_data_from_bitmap(IDataObject *data, FORMATETC *fmt, HBITMAP *hbm)
894 {
895 HBITMAP copy;
896 HRESULT hr;
897 FORMATETC mem_fmt;
898 STGMEDIUM med;
899
900 *hbm = NULL;
901
902 mem_fmt = *fmt;
903 mem_fmt.tymed = TYMED_GDI;
904
905 hr = IDataObject_GetData(data, &mem_fmt, &med);
906 if(FAILED(hr)) return hr;
907
908 hr = dup_bitmap(med.u.hBitmap, &copy);
909
910 if(SUCCEEDED(hr)) *hbm = copy;
911
912 ReleaseStgMedium(&med);
913
914 return hr;
915 }
916
917 /***********************************************************************
918 * render_format
919 *
920 * Render the clipboard data. Note that this call will delegate to the
921 * source data object.
922 */
923 static HRESULT render_format(IDataObject *data, LPFORMATETC fmt)
924 {
925 HANDLE clip_data = NULL; /* HGLOBAL unless otherwise specified */
926 HRESULT hr;
927
928 /* Embed source hack */
929 if(fmt->cfFormat == embed_source_clipboard_format)
930 {
931 return render_embed_source_hack(data, fmt);
932 }
933
934 if(fmt->tymed & TYMED_ISTORAGE)
935 {
936 hr = get_data_from_storage(data, fmt, &clip_data);
937 }
938 else if(fmt->tymed & TYMED_ISTREAM)
939 {
940 hr = get_data_from_stream(data, fmt, &clip_data);
941 }
942 else if(fmt->tymed & TYMED_HGLOBAL)
943 {
944 hr = get_data_from_global(data, fmt, &clip_data);
945 }
946 else if(fmt->tymed & TYMED_ENHMF)
947 {
948 hr = get_data_from_enhmetafile(data, fmt, &clip_data);
949 }
950 else if(fmt->tymed & TYMED_MFPICT)
951 {
952 /* Returns global handle to METAFILEPICT, containing a copied HMETAFILE */
953 hr = get_data_from_metafilepict(data, fmt, &clip_data);
954 }
955 else if(fmt->tymed & TYMED_GDI)
956 {
957 /* Returns HBITMAP not HGLOBAL */
958 hr = get_data_from_bitmap(data, fmt, (HBITMAP *)&clip_data);
959 }
960 else
961 {
962 FIXME("Unhandled tymed %x\n", fmt->tymed);
963 hr = DV_E_FORMATETC;
964 }
965
966 if(SUCCEEDED(hr))
967 {
968 if ( !SetClipboardData(fmt->cfFormat, clip_data) )
969 {
970 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
971 if(fmt->tymed & TYMED_MFPICT)
972 free_metafilepict(clip_data);
973 else if(fmt->tymed & TYMED_GDI)
974 DeleteObject(clip_data);
975 else
976 GlobalFree(clip_data);
977 hr = CLIPBRD_E_CANT_SET;
978 }
979 }
980
981 return hr;
982 }
983
984 /*---------------------------------------------------------------------*
985 * Implementation of the internal IDataObject interface exposed by
986 * the OLE clipboard.
987 *---------------------------------------------------------------------*/
988
989
990 /************************************************************************
991 * snapshot_QueryInterface
992 */
993 static HRESULT WINAPI snapshot_QueryInterface(IDataObject *iface,
994 REFIID riid, void **ppvObject)
995 {
996 snapshot *This = impl_from_IDataObject(iface);
997 TRACE("(%p)->(IID:%s, %p)\n", This, debugstr_guid(riid), ppvObject);
998
999 if ( (This==0) || (ppvObject==0) )
1000 return E_INVALIDARG;
1001
1002 *ppvObject = 0;
1003
1004 if (IsEqualIID(&IID_IUnknown, riid) ||
1005 IsEqualIID(&IID_IDataObject, riid))
1006 {
1007 *ppvObject = iface;
1008 }
1009 else
1010 {
1011 WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
1012 return E_NOINTERFACE;
1013 }
1014
1015 IUnknown_AddRef((IUnknown*)*ppvObject);
1016
1017 return S_OK;
1018 }
1019
1020 /************************************************************************
1021 * snapshot_AddRef
1022 */
1023 static ULONG WINAPI snapshot_AddRef(IDataObject *iface)
1024 {
1025 snapshot *This = impl_from_IDataObject(iface);
1026
1027 TRACE("(%p)->(count=%u)\n", This, This->ref);
1028
1029 return InterlockedIncrement(&This->ref);
1030 }
1031
1032 /************************************************************************
1033 * snapshot_Release
1034 */
1035 static ULONG WINAPI snapshot_Release(IDataObject *iface)
1036 {
1037 snapshot *This = impl_from_IDataObject(iface);
1038 ULONG ref;
1039
1040 TRACE("(%p)->(count=%u)\n", This, This->ref);
1041
1042 ref = InterlockedDecrement(&This->ref);
1043
1044 if (ref == 0)
1045 {
1046 ole_clipbrd *clipbrd;
1047 HRESULT hr = get_ole_clipbrd(&clipbrd);
1048
1049 if(This->data) IDataObject_Release(This->data);
1050
1051 if(SUCCEEDED(hr) && clipbrd->latest_snapshot == This)
1052 clipbrd->latest_snapshot = NULL;
1053 HeapFree(GetProcessHeap(), 0, This);
1054 }
1055
1056 return ref;
1057 }
1058
1059 /************************************************************
1060 * get_current_ole_clip_window
1061 *
1062 * Return the window that owns the ole clipboard.
1063 *
1064 * If the clipboard is flushed or not owned by ole this will
1065 * return NULL.
1066 */
1067 static HWND get_current_ole_clip_window(void)
1068 {
1069 HGLOBAL h;
1070 HWND *ptr, wnd;
1071
1072 h = GetClipboardData(dataobject_clipboard_format);
1073 if(!h) return NULL;
1074 ptr = GlobalLock(h);
1075 if(!ptr) return NULL;
1076 wnd = *ptr;
1077 GlobalUnlock(h);
1078 return wnd;
1079 }
1080
1081 /************************************************************
1082 * get_current_dataobject
1083 *
1084 * Return an unmarshalled IDataObject if there is a current
1085 * (ie non-flushed) object on the ole clipboard.
1086 */
1087 static HRESULT get_current_dataobject(IDataObject **data)
1088 {
1089 HRESULT hr = S_FALSE;
1090 HWND wnd = get_current_ole_clip_window();
1091 HGLOBAL h;
1092 void *ptr;
1093 IStream *stm;
1094 LARGE_INTEGER pos;
1095
1096 *data = NULL;
1097 if(!wnd) return S_FALSE;
1098
1099 h = GetClipboardData(wine_marshal_clipboard_format);
1100 if(!h) return S_FALSE;
1101 if(GlobalSize(h) == 0) return S_FALSE;
1102 ptr = GlobalLock(h);
1103 if(!ptr) return S_FALSE;
1104
1105 hr = CreateStreamOnHGlobal(NULL, TRUE, &stm);
1106 if(FAILED(hr)) goto end;
1107
1108 hr = IStream_Write(stm, ptr, GlobalSize(h), NULL);
1109 if(SUCCEEDED(hr))
1110 {
1111 pos.QuadPart = 0;
1112 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1113 hr = CoUnmarshalInterface(stm, &IID_IDataObject, (void**)data);
1114 }
1115 IStream_Release(stm);
1116
1117 end:
1118 GlobalUnlock(h);
1119 return hr;
1120 }
1121
1122 static DWORD get_tymed_from_nonole_cf(UINT cf)
1123 {
1124 if(cf >= 0xc000) return TYMED_ISTREAM | TYMED_HGLOBAL;
1125
1126 switch(cf)
1127 {
1128 case CF_TEXT:
1129 case CF_OEMTEXT:
1130 case CF_UNICODETEXT:
1131 return TYMED_ISTREAM | TYMED_HGLOBAL;
1132 case CF_ENHMETAFILE:
1133 return TYMED_ENHMF;
1134 case CF_METAFILEPICT:
1135 return TYMED_MFPICT;
1136 default:
1137 FIXME("returning TYMED_NULL for cf %04x\n", cf);
1138 return TYMED_NULL;
1139 }
1140 }
1141
1142 /***********************************************************
1143 * get_priv_data
1144 *
1145 * Returns a copy of the Ole Private Data
1146 */
1147 static HRESULT get_priv_data(ole_priv_data **data)
1148 {
1149 HGLOBAL handle;
1150 HRESULT hr = S_OK;
1151 ole_priv_data *ret = NULL;
1152
1153 *data = NULL;
1154
1155 handle = GetClipboardData( ole_private_data_clipboard_format );
1156 if(handle)
1157 {
1158 ole_priv_data *src = GlobalLock(handle);
1159 if(src)
1160 {
1161 DWORD i;
1162
1163 /* FIXME: sanity check on size */
1164 ret = HeapAlloc(GetProcessHeap(), 0, src->size);
1165 if(!ret)
1166 {
1167 GlobalUnlock(handle);
1168 return E_OUTOFMEMORY;
1169 }
1170 memcpy(ret, src, src->size);
1171 GlobalUnlock(handle);
1172
1173 /* Fixup any target device offsets to ptrs */
1174 for(i = 0; i < ret->count; i++)
1175 ret->entries[i].fmtetc.ptd =
1176 td_offs_to_ptr(ret, (DWORD_PTR) ret->entries[i].fmtetc.ptd);
1177 }
1178 }
1179
1180 if(!ret) /* Non-ole data */
1181 {
1182 UINT cf;
1183 DWORD count = 0, idx, size = FIELD_OFFSET(ole_priv_data, entries);
1184
1185 for(cf = 0; (cf = EnumClipboardFormats(cf)) != 0; count++)
1186 {
1187 char buf[100];
1188 GetClipboardFormatNameA(cf, buf, sizeof(buf));
1189 TRACE("cf %04x %s\n", cf, buf);
1190 }
1191 TRACE("count %d\n", count);
1192 size += count * sizeof(ret->entries[0]);
1193
1194 /* There are holes in fmtetc so zero init */
1195 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1196 if(!ret) return E_OUTOFMEMORY;
1197 ret->size = size;
1198 ret->count = count;
1199
1200 for(cf = 0, idx = 0; (cf = EnumClipboardFormats(cf)) != 0; idx++)
1201 {
1202 ret->entries[idx].fmtetc.cfFormat = cf;
1203 ret->entries[idx].fmtetc.ptd = NULL;
1204 ret->entries[idx].fmtetc.dwAspect = DVASPECT_CONTENT;
1205 ret->entries[idx].fmtetc.lindex = -1;
1206 ret->entries[idx].fmtetc.tymed = get_tymed_from_nonole_cf(cf);
1207 ret->entries[idx].first_use = 1;
1208 }
1209 }
1210
1211 *data = ret;
1212 return hr;
1213 }
1214
1215 /************************************************************************
1216 * get_stgmed_for_global
1217 *
1218 * Returns a stg medium with a copy of the global handle
1219 */
1220 static HRESULT get_stgmed_for_global(HGLOBAL h, STGMEDIUM *med)
1221 {
1222 HRESULT hr;
1223
1224 med->pUnkForRelease = NULL;
1225 med->tymed = TYMED_NULL;
1226
1227 hr = dup_global_mem(h, GMEM_MOVEABLE, &med->u.hGlobal);
1228
1229 if(SUCCEEDED(hr)) med->tymed = TYMED_HGLOBAL;
1230
1231 return hr;
1232 }
1233
1234 /************************************************************************
1235 * get_stgmed_for_stream
1236 *
1237 * Returns a stg medium with a stream based on the handle
1238 */
1239 static HRESULT get_stgmed_for_stream(HGLOBAL h, STGMEDIUM *med)
1240 {
1241 HRESULT hr;
1242 HGLOBAL dst;
1243
1244 med->pUnkForRelease = NULL;
1245 med->tymed = TYMED_NULL;
1246
1247 hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
1248 if(FAILED(hr)) return hr;
1249
1250 hr = CreateStreamOnHGlobal(dst, TRUE, &med->u.pstm);
1251 if(FAILED(hr))
1252 {
1253 GlobalFree(dst);
1254 return hr;
1255 }
1256
1257 med->tymed = TYMED_ISTREAM;
1258 return hr;
1259 }
1260
1261 /************************************************************************
1262 * get_stgmed_for_storage
1263 *
1264 * Returns a stg medium with a storage based on the handle
1265 */
1266 static HRESULT get_stgmed_for_storage(HGLOBAL h, STGMEDIUM *med)
1267 {
1268 HRESULT hr;
1269 HGLOBAL dst;
1270 ILockBytes *lbs;
1271
1272 med->pUnkForRelease = NULL;
1273 med->tymed = TYMED_NULL;
1274
1275 hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
1276 if(FAILED(hr)) return hr;
1277
1278 hr = CreateILockBytesOnHGlobal(dst, TRUE, &lbs);
1279 if(FAILED(hr))
1280 {
1281 GlobalFree(dst);
1282 return hr;
1283 }
1284
1285 hr = StgOpenStorageOnILockBytes(lbs, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &med->u.pstg);
1286 ILockBytes_Release(lbs);
1287 if(FAILED(hr))
1288 {
1289 GlobalFree(dst);
1290 return hr;
1291 }
1292
1293 med->tymed = TYMED_ISTORAGE;
1294 return hr;
1295 }
1296
1297 /************************************************************************
1298 * get_stgmed_for_emf
1299 *
1300 * Returns a stg medium with an enhanced metafile based on the handle
1301 */
1302 static HRESULT get_stgmed_for_emf(HENHMETAFILE hemf, STGMEDIUM *med)
1303 {
1304 med->pUnkForRelease = NULL;
1305 med->tymed = TYMED_NULL;
1306
1307 med->u.hEnhMetaFile = CopyEnhMetaFileW(hemf, NULL);
1308 if(!med->u.hEnhMetaFile) return E_OUTOFMEMORY;
1309 med->tymed = TYMED_ENHMF;
1310 return S_OK;
1311 }
1312
1313 static inline BOOL string_off_equal(const DVTARGETDEVICE *t1, WORD off1, const DVTARGETDEVICE *t2, WORD off2)
1314 {
1315 const WCHAR *str1, *str2;
1316
1317 if(off1 == 0 && off2 == 0) return TRUE;
1318 if(off1 == 0 || off2 == 0) return FALSE;
1319
1320 str1 = (const WCHAR*)((const char*)t1 + off1);
1321 str2 = (const WCHAR*)((const char*)t2 + off2);
1322
1323 return !lstrcmpW(str1, str2);
1324 }
1325
1326 static inline BOOL td_equal(const DVTARGETDEVICE *t1, const DVTARGETDEVICE *t2)
1327 {
1328 if(t1 == NULL && t2 == NULL) return TRUE;
1329 if(t1 == NULL || t2 == NULL) return FALSE;
1330
1331 if(!string_off_equal(t1, t1->tdDriverNameOffset, t2, t2->tdDriverNameOffset))
1332 return FALSE;
1333 if(!string_off_equal(t1, t1->tdDeviceNameOffset, t2, t2->tdDeviceNameOffset))
1334 return FALSE;
1335 if(!string_off_equal(t1, t1->tdPortNameOffset, t2, t2->tdPortNameOffset))
1336 return FALSE;
1337
1338 /* FIXME check devmode? */
1339
1340 return TRUE;
1341 }
1342
1343 /************************************************************************
1344 * snapshot_GetData
1345 */
1346 static HRESULT WINAPI snapshot_GetData(IDataObject *iface, FORMATETC *fmt,
1347 STGMEDIUM *med)
1348 {
1349 snapshot *This = impl_from_IDataObject(iface);
1350 HANDLE h;
1351 HRESULT hr;
1352 ole_priv_data *enum_data = NULL;
1353 ole_priv_data_entry *entry;
1354 DWORD mask;
1355
1356 TRACE("(%p, %p {%s}, %p)\n", iface, fmt, dump_fmtetc(fmt), med);
1357
1358 if ( !fmt || !med ) return E_INVALIDARG;
1359
1360 if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
1361
1362 if(!This->data)
1363 hr = get_current_dataobject(&This->data);
1364
1365 if(This->data)
1366 {
1367 hr = IDataObject_GetData(This->data, fmt, med);
1368 CloseClipboard();
1369 return hr;
1370 }
1371
1372 h = GetClipboardData(fmt->cfFormat);
1373 if(!h)
1374 {
1375 hr = DV_E_FORMATETC;
1376 goto end;
1377 }
1378
1379 hr = get_priv_data(&enum_data);
1380 if(FAILED(hr)) goto end;
1381
1382 entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
1383 if(entry)
1384 {
1385 if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
1386 {
1387 hr = DV_E_FORMATETC;
1388 goto end;
1389 }
1390 mask = fmt->tymed & entry->fmtetc.tymed;
1391 if(!mask) mask = fmt->tymed & (TYMED_ISTREAM | TYMED_HGLOBAL);
1392 }
1393 else /* non-Ole format */
1394 mask = fmt->tymed & TYMED_HGLOBAL;
1395
1396 if(mask & TYMED_ISTORAGE)
1397 hr = get_stgmed_for_storage(h, med);
1398 else if(mask & TYMED_HGLOBAL)
1399 hr = get_stgmed_for_global(h, med);
1400 else if(mask & TYMED_ISTREAM)
1401 hr = get_stgmed_for_stream(h, med);
1402 else if(mask & TYMED_ENHMF)
1403 hr = get_stgmed_for_emf((HENHMETAFILE)h, med);
1404 else
1405 {
1406 FIXME("Unhandled tymed - mask %x req tymed %x\n", mask, fmt->tymed);
1407 hr = E_FAIL;
1408 goto end;
1409 }
1410
1411 end:
1412 HeapFree(GetProcessHeap(), 0, enum_data);
1413 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1414 return hr;
1415 }
1416
1417 /************************************************************************
1418 * snapshot_GetDataHere
1419 */
1420 static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
1421 STGMEDIUM *med)
1422 {
1423 snapshot *This = impl_from_IDataObject(iface);
1424 HANDLE h;
1425 HRESULT hr;
1426 ole_priv_data *enum_data = NULL;
1427 ole_priv_data_entry *entry;
1428 TYMED supported;
1429
1430 if ( !fmt || !med ) return E_INVALIDARG;
1431
1432 TRACE("(%p, %p {%s}, %p (tymed %x)\n", iface, fmt, dump_fmtetc(fmt), med, med->tymed);
1433
1434 if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
1435
1436 if(!This->data)
1437 hr = get_current_dataobject(&This->data);
1438
1439 if(This->data)
1440 {
1441 hr = IDataObject_GetDataHere(This->data, fmt, med);
1442 if(SUCCEEDED(hr))
1443 {
1444 CloseClipboard();
1445 return hr;
1446 }
1447 }
1448
1449 h = GetClipboardData(fmt->cfFormat);
1450 if(!h)
1451 {
1452 hr = DV_E_FORMATETC;
1453 goto end;
1454 }
1455
1456 hr = get_priv_data(&enum_data);
1457 if(FAILED(hr)) goto end;
1458
1459 entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
1460 if(entry)
1461 {
1462 if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
1463 {
1464 hr = DV_E_FORMATETC;
1465 goto end;
1466 }
1467 supported = entry->fmtetc.tymed;
1468 }
1469 else /* non-Ole format */
1470 supported = TYMED_HGLOBAL;
1471
1472 switch(med->tymed)
1473 {
1474 case TYMED_HGLOBAL:
1475 {
1476 DWORD src_size = GlobalSize(h);
1477 DWORD dst_size = GlobalSize(med->u.hGlobal);
1478 hr = E_FAIL;
1479 if(dst_size >= src_size)
1480 {
1481 void *src = GlobalLock(h);
1482 void *dst = GlobalLock(med->u.hGlobal);
1483
1484 memcpy(dst, src, src_size);
1485 GlobalUnlock(med->u.hGlobal);
1486 GlobalUnlock(h);
1487 hr = S_OK;
1488 }
1489 break;
1490 }
1491 case TYMED_ISTREAM:
1492 {
1493 DWORD src_size = GlobalSize(h);
1494 void *src = GlobalLock(h);
1495 hr = IStream_Write(med->u.pstm, src, src_size, NULL);
1496 GlobalUnlock(h);
1497 break;
1498 }
1499 case TYMED_ISTORAGE:
1500 {
1501 STGMEDIUM copy;
1502 if(!(supported & TYMED_ISTORAGE))
1503 {
1504 hr = E_FAIL;
1505 goto end;
1506 }
1507 hr = get_stgmed_for_storage(h, &copy);
1508 if(SUCCEEDED(hr))
1509 {
1510 hr = IStorage_CopyTo(copy.u.pstg, 0, NULL, NULL, med->u.pstg);
1511 ReleaseStgMedium(&copy);
1512 }
1513 break;
1514 }
1515 default:
1516 FIXME("Unhandled tymed - supported %x req tymed %x\n", supported, med->tymed);
1517 hr = E_FAIL;
1518 goto end;
1519 }
1520
1521 end:
1522 HeapFree(GetProcessHeap(), 0, enum_data);
1523 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1524 return hr;
1525 }
1526
1527 /************************************************************************
1528 * snapshot_QueryGetData
1529 *
1530 * The OLE Clipboard's implementation of this method delegates to
1531 * a data source if there is one or wraps around the windows clipboard
1532 * function IsClipboardFormatAvailable() otherwise.
1533 *
1534 */
1535 static HRESULT WINAPI snapshot_QueryGetData(IDataObject *iface, FORMATETC *fmt)
1536 {
1537 FIXME("(%p, %p {%s})\n", iface, fmt, dump_fmtetc(fmt));
1538
1539 if (!fmt) return E_INVALIDARG;
1540
1541 if ( fmt->dwAspect != DVASPECT_CONTENT ) return DV_E_FORMATETC;
1542
1543 if ( fmt->lindex != -1 ) return DV_E_FORMATETC;
1544
1545 return (IsClipboardFormatAvailable(fmt->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
1546 }
1547
1548 /************************************************************************
1549 * snapshot_GetCanonicalFormatEtc
1550 */
1551 static HRESULT WINAPI snapshot_GetCanonicalFormatEtc(IDataObject *iface, FORMATETC *fmt_in,
1552 FORMATETC *fmt_out)
1553 {
1554 TRACE("(%p, %p, %p)\n", iface, fmt_in, fmt_out);
1555
1556 if ( !fmt_in || !fmt_out ) return E_INVALIDARG;
1557
1558 *fmt_out = *fmt_in;
1559 return DATA_S_SAMEFORMATETC;
1560 }
1561
1562 /************************************************************************
1563 * snapshot_SetData
1564 *
1565 * The OLE Clipboard does not implement this method
1566 */
1567 static HRESULT WINAPI snapshot_SetData(IDataObject *iface, FORMATETC *fmt,
1568 STGMEDIUM *med, BOOL release)
1569 {
1570 TRACE("(%p, %p, %p, %d): not implemented\n", iface, fmt, med, release);
1571 return E_NOTIMPL;
1572 }
1573
1574 /************************************************************************
1575 * snapshot_EnumFormatEtc
1576 *
1577 */
1578 static HRESULT WINAPI snapshot_EnumFormatEtc(IDataObject *iface, DWORD dir,
1579 IEnumFORMATETC **enum_fmt)
1580 {
1581 HRESULT hr;
1582 ole_priv_data *data = NULL;
1583
1584 TRACE("(%p, %x, %p)\n", iface, dir, enum_fmt);
1585
1586 *enum_fmt = NULL;
1587
1588 if ( dir != DATADIR_GET ) return E_NOTIMPL;
1589 if ( !OpenClipboard(NULL) ) return CLIPBRD_E_CANT_OPEN;
1590
1591 hr = get_priv_data(&data);
1592
1593 if(FAILED(hr)) goto end;
1594
1595 hr = enum_fmtetc_construct( data, 0, enum_fmt );
1596
1597 end:
1598 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1599 return hr;
1600 }
1601
1602 /************************************************************************
1603 * snapshot_DAdvise
1604 *
1605 * The OLE Clipboard does not implement this method
1606 */
1607 static HRESULT WINAPI snapshot_DAdvise(IDataObject *iface, FORMATETC *fmt,
1608 DWORD flags, IAdviseSink *sink,
1609 DWORD *conn)
1610 {
1611 TRACE("(%p, %p, %x, %p, %p): not implemented\n", iface, fmt, flags, sink, conn);
1612 return E_NOTIMPL;
1613 }
1614
1615 /************************************************************************
1616 * snapshot_DUnadvise
1617 *
1618 * The OLE Clipboard does not implement this method
1619 */
1620 static HRESULT WINAPI snapshot_DUnadvise(IDataObject* iface, DWORD conn)
1621 {
1622 TRACE("(%p, %d): not implemented\n", iface, conn);
1623 return E_NOTIMPL;
1624 }
1625
1626 /************************************************************************
1627 * snapshot_EnumDAdvise
1628 *
1629 * The OLE Clipboard does not implement this method
1630 */
1631 static HRESULT WINAPI snapshot_EnumDAdvise(IDataObject* iface,
1632 IEnumSTATDATA** enum_advise)
1633 {
1634 TRACE("(%p, %p): not implemented\n", iface, enum_advise);
1635 return E_NOTIMPL;
1636 }
1637
1638 static const IDataObjectVtbl snapshot_vtable =
1639 {
1640 snapshot_QueryInterface,
1641 snapshot_AddRef,
1642 snapshot_Release,
1643 snapshot_GetData,
1644 snapshot_GetDataHere,
1645 snapshot_QueryGetData,
1646 snapshot_GetCanonicalFormatEtc,
1647 snapshot_SetData,
1648 snapshot_EnumFormatEtc,
1649 snapshot_DAdvise,
1650 snapshot_DUnadvise,
1651 snapshot_EnumDAdvise
1652 };
1653
1654 /*---------------------------------------------------------------------*
1655 * Internal implementation methods for the OLE clipboard
1656 *---------------------------------------------------------------------*/
1657
1658 static snapshot *snapshot_construct(DWORD seq_no)
1659 {
1660 snapshot *This;
1661
1662 This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
1663 if (!This) return NULL;
1664
1665 This->IDataObject_iface.lpVtbl = &snapshot_vtable;
1666 This->ref = 0;
1667 This->seq_no = seq_no;
1668 This->data = NULL;
1669
1670 return This;
1671 }
1672
1673 /*********************************************************
1674 * register_clipboard_formats
1675 */
1676 static void register_clipboard_formats(void)
1677 {
1678 static const WCHAR OwnerLink[] = {'O','w','n','e','r','L','i','n','k',0};
1679 static const WCHAR FileName[] = {'F','i','l','e','N','a','m','e',0};
1680 static const WCHAR FileNameW[] = {'F','i','l','e','N','a','m','e','W',0};
1681 static const WCHAR DataObject[] = {'D','a','t','a','O','b','j','e','c','t',0};
1682 static const WCHAR EmbeddedObject[] = {'E','m','b','e','d','d','e','d',' ','O','b','j','e','c','t',0};
1683 static const WCHAR EmbedSource[] = {'E','m','b','e','d',' ','S','o','u','r','c','e',0};
1684 static const WCHAR CustomLinkSource[] = {'C','u','s','t','o','m',' ','L','i','n','k',' ','S','o','u','r','c','e',0};
1685 static const WCHAR LinkSource[] = {'L','i','n','k',' ','S','o','u','r','c','e',0};
1686 static const WCHAR ObjectDescriptor[] = {'O','b','j','e','c','t',' ','D','e','s','c','r','i','p','t','o','r',0};
1687 static const WCHAR LinkSourceDescriptor[] = {'L','i','n','k',' ','S','o','u','r','c','e',' ',
1688 'D','e','s','c','r','i','p','t','o','r',0};
1689 static const WCHAR OlePrivateData[] = {'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0};
1690
1691 static const WCHAR WineMarshalledDataObject[] = {'W','i','n','e',' ','M','a','r','s','h','a','l','l','e','d',' ',
1692 'D','a','t','a','O','b','j','e','c','t',0};
1693
1694 ownerlink_clipboard_format = RegisterClipboardFormatW(OwnerLink);
1695 filename_clipboard_format = RegisterClipboardFormatW(FileName);
1696 filenameW_clipboard_format = RegisterClipboardFormatW(FileNameW);
1697 dataobject_clipboard_format = RegisterClipboardFormatW(DataObject);
1698 embedded_object_clipboard_format = RegisterClipboardFormatW(EmbeddedObject);
1699 embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSource);
1700 custom_link_source_clipboard_format = RegisterClipboardFormatW(CustomLinkSource);
1701 link_source_clipboard_format = RegisterClipboardFormatW(LinkSource);
1702 object_descriptor_clipboard_format = RegisterClipboardFormatW(ObjectDescriptor);
1703 link_source_descriptor_clipboard_format = RegisterClipboardFormatW(LinkSourceDescriptor);
1704 ole_private_data_clipboard_format = RegisterClipboardFormatW(OlePrivateData);
1705
1706 wine_marshal_clipboard_format = RegisterClipboardFormatW(WineMarshalledDataObject);
1707 }
1708
1709 /***********************************************************************
1710 * OLEClipbrd_Initialize()
1711 * Initializes the OLE clipboard.
1712 */
1713 void OLEClipbrd_Initialize(void)
1714 {
1715 register_clipboard_formats();
1716
1717 if ( !theOleClipboard )
1718 {
1719 ole_clipbrd* clipbrd;
1720 HGLOBAL h;
1721
1722 TRACE("()\n");
1723
1724 clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
1725 if (!clipbrd) return;
1726
1727 clipbrd->latest_snapshot = NULL;
1728 clipbrd->window = NULL;
1729 clipbrd->src_data = NULL;
1730 clipbrd->cached_enum = NULL;
1731
1732 h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
1733 if(!h)
1734 {
1735 HeapFree(GetProcessHeap(), 0, clipbrd);
1736 return;
1737 }
1738
1739 if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
1740 {
1741 GlobalFree(h);
1742 HeapFree(GetProcessHeap(), 0, clipbrd);
1743 return;
1744 }
1745
1746 theOleClipboard = clipbrd;
1747 }
1748 }
1749
1750 /***********************************************************************
1751 * OLEClipbrd_UnInitialize()
1752 * Un-Initializes the OLE clipboard
1753 */
1754 void OLEClipbrd_UnInitialize(void)
1755 {
1756 ole_clipbrd *clipbrd = theOleClipboard;
1757
1758 TRACE("()\n");
1759
1760 if ( clipbrd )
1761 {
1762 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1763 HINSTANCE hinst = GetModuleHandleW(ole32W);
1764
1765 if ( clipbrd->window )
1766 {
1767 DestroyWindow(clipbrd->window);
1768 UnregisterClassW( clipbrd_wndclass, hinst );
1769 }
1770
1771 IStream_Release(clipbrd->marshal_data);
1772 if (clipbrd->src_data) IDataObject_Release(clipbrd->src_data);
1773 HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1774 HeapFree(GetProcessHeap(), 0, clipbrd);
1775 theOleClipboard = NULL;
1776 }
1777 }
1778
1779 /*********************************************************************
1780 * set_clipboard_formats
1781 *
1782 * Enumerate all formats supported by the source and make
1783 * those formats available using delayed rendering using SetClipboardData.
1784 * Cache the enumeration list and make that list visibile as the
1785 * 'Ole Private Data' format on the clipboard.
1786 *
1787 */
1788 static HRESULT set_clipboard_formats(ole_clipbrd *clipbrd, IDataObject *data)
1789 {
1790 HRESULT hr;
1791 FORMATETC fmt;
1792 IEnumFORMATETC *enum_fmt;
1793 HGLOBAL priv_data_handle;
1794 DWORD_PTR target_offset;
1795 ole_priv_data *priv_data;
1796 DWORD count = 0, needed = sizeof(*priv_data), idx;
1797
1798 hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
1799 if(FAILED(hr)) return hr;
1800
1801 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1802 {
1803 count++;
1804 needed += sizeof(priv_data->entries[0]);
1805 if(fmt.ptd)
1806 {
1807 needed += fmt.ptd->tdSize;
1808 CoTaskMemFree(fmt.ptd);
1809 }
1810 }
1811
1812 /* Windows pads the list with two empty ole_priv_data_entries, one
1813 * after the entries array and one after the target device data.
1814 * Allocating with zero init to zero these pads. */
1815
1816 needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
1817 priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
1818 priv_data = GlobalLock(priv_data_handle);
1819
1820 priv_data->unk1 = 0;
1821 priv_data->size = needed;
1822 priv_data->unk2 = 1;
1823 priv_data->count = count;
1824 priv_data->unk3[0] = 0;
1825 priv_data->unk3[1] = 0;
1826
1827 IEnumFORMATETC_Reset(enum_fmt);
1828
1829 idx = 0;
1830 target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
1831
1832 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1833 {
1834 TRACE("%s\n", dump_fmtetc(&fmt));
1835
1836 priv_data->entries[idx].fmtetc = fmt;
1837 if(fmt.ptd)
1838 {
1839 memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
1840 priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
1841 target_offset += fmt.ptd->tdSize;
1842 CoTaskMemFree(fmt.ptd);
1843 }
1844
1845 priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
1846 priv_data->entries[idx].unk[0] = 0;
1847 priv_data->entries[idx].unk[1] = 0;
1848
1849 if (priv_data->entries[idx].first_use)
1850 SetClipboardData(fmt.cfFormat, NULL);
1851
1852 idx++;
1853 }
1854
1855 IEnumFORMATETC_Release(enum_fmt);
1856
1857 /* Cache the list and fixup any target device offsets to ptrs */
1858 clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
1859 memcpy(clipbrd->cached_enum, priv_data, needed);
1860 for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
1861 clipbrd->cached_enum->entries[idx].fmtetc.ptd =
1862 td_offs_to_ptr(clipbrd->cached_enum, (DWORD_PTR)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
1863
1864 GlobalUnlock(priv_data_handle);
1865 if(!SetClipboardData(ole_private_data_clipboard_format, priv_data_handle))
1866 {
1867 GlobalFree(priv_data_handle);
1868 return CLIPBRD_E_CANT_SET;
1869 }
1870
1871 return S_OK;
1872 }
1873
1874 static HWND create_clipbrd_window(void);
1875
1876 /***********************************************************************
1877 * get_clipbrd_window
1878 */
1879 static inline HRESULT get_clipbrd_window(ole_clipbrd *clipbrd, HWND *wnd)
1880 {
1881 if ( !clipbrd->window )
1882 clipbrd->window = create_clipbrd_window();
1883
1884 *wnd = clipbrd->window;
1885 return *wnd ? S_OK : E_FAIL;
1886 }
1887
1888
1889 /**********************************************************************
1890 * release_marshal_data
1891 *
1892 * Releases the data and sets the stream back to zero size.
1893 */
1894 static inline void release_marshal_data(IStream *stm)
1895 {
1896 LARGE_INTEGER pos;
1897 ULARGE_INTEGER size;
1898 pos.QuadPart = size.QuadPart = 0;
1899
1900 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1901 CoReleaseMarshalData(stm);
1902 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1903 IStream_SetSize(stm, size);
1904 }
1905
1906 /***********************************************************************
1907 * expose_marshalled_dataobject
1908 *
1909 * Sets the marshalled dataobject to the clipboard. In the flushed case
1910 * we set a zero sized HGLOBAL to clear the old marshalled data.
1911 */
1912 static HRESULT expose_marshalled_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1913 {
1914 HGLOBAL h;
1915
1916 if(data)
1917 {
1918 HGLOBAL h_stm;
1919 GetHGlobalFromStream(clipbrd->marshal_data, &h_stm);
1920 dup_global_mem(h_stm, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
1921 }
1922 else /* flushed */
1923 h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 0);
1924
1925 if(!h) return E_OUTOFMEMORY;
1926
1927 if(!SetClipboardData(wine_marshal_clipboard_format, h))
1928 {
1929 GlobalFree(h);
1930 return CLIPBRD_E_CANT_SET;
1931 }
1932 return S_OK;
1933 }
1934
1935 /***********************************************************************
1936 * set_src_dataobject
1937 *
1938 * Clears and sets the clipboard's src IDataObject.
1939 *
1940 * To marshal the source dataobject we do something rather different from Windows.
1941 * We set a clipboard format which contains the marshalled data.
1942 * Windows sets two window props one of which is an IID, the other is an endpoint number.
1943 */
1944 static HRESULT set_src_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1945 {
1946 HRESULT hr;
1947 HWND wnd;
1948
1949 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1950
1951 if(clipbrd->src_data)
1952 {
1953 release_marshal_data(clipbrd->marshal_data);
1954
1955 IDataObject_Release(clipbrd->src_data);
1956 clipbrd->src_data = NULL;
1957 HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1958 clipbrd->cached_enum = NULL;
1959 }
1960
1961 if(data)
1962 {
1963 IUnknown *unk;
1964
1965 IDataObject_AddRef(data);
1966 clipbrd->src_data = data;
1967
1968 IDataObject_QueryInterface(data, &IID_IUnknown, (void**)&unk);
1969 hr = CoMarshalInterface(clipbrd->marshal_data, &IID_IDataObject, unk,
1970 MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
1971 IUnknown_Release(unk); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
1972 if(FAILED(hr)) return hr;
1973 hr = set_clipboard_formats(clipbrd, data);
1974 }
1975 return hr;
1976 }
1977
1978 /***********************************************************************
1979 * clipbrd_wndproc
1980 */
1981 static LRESULT CALLBACK clipbrd_wndproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1982 {
1983 ole_clipbrd *clipbrd;
1984
1985 get_ole_clipbrd(&clipbrd);
1986
1987 switch (message)
1988 {
1989 case WM_RENDERFORMAT:
1990 {
1991 UINT cf = wparam;
1992 ole_priv_data_entry *entry;
1993
1994 TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
1995 entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
1996
1997 if(entry)
1998 render_format(clipbrd->src_data, &entry->fmtetc);
1999
2000 break;
2001 }
2002
2003 case WM_RENDERALLFORMATS:
2004 {
2005 DWORD i;
2006 ole_priv_data_entry *entries = clipbrd->cached_enum->entries;
2007
2008 TRACE("(): WM_RENDERALLFORMATS\n");
2009
2010 for(i = 0; i < clipbrd->cached_enum->count; i++)
2011 {
2012 if(entries[i].first_use)
2013 render_format(clipbrd->src_data, &entries[i].fmtetc);
2014 }
2015 break;
2016 }
2017
2018 case WM_DESTROYCLIPBOARD:
2019 {
2020 TRACE("(): WM_DESTROYCLIPBOARD\n");
2021
2022 set_src_dataobject(clipbrd, NULL);
2023 break;
2024 }
2025
2026 default:
2027 return DefWindowProcW(hwnd, message, wparam, lparam);
2028 }
2029
2030 return 0;
2031 }
2032
2033
2034 /***********************************************************************
2035 * create_clipbrd_window
2036 */
2037 static HWND create_clipbrd_window(void)
2038 {
2039 WNDCLASSEXW class;
2040 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
2041 static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
2042 HINSTANCE hinst = GetModuleHandleW(ole32W);
2043
2044 class.cbSize = sizeof(class);
2045 class.style = 0;
2046 class.lpfnWndProc = clipbrd_wndproc;
2047 class.cbClsExtra = 0;
2048 class.cbWndExtra = 0;
2049 class.hInstance = hinst;
2050 class.hIcon = 0;
2051 class.hCursor = 0;
2052 class.hbrBackground = 0;
2053 class.lpszMenuName = NULL;
2054 class.lpszClassName = clipbrd_wndclass;
2055 class.hIconSm = NULL;
2056
2057 RegisterClassExW(&class);
2058
2059 return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
2060 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
2061 NULL, NULL, hinst, 0);
2062 }
2063
2064 /*********************************************************************
2065 * set_dataobject_format
2066 *
2067 * Windows creates a 'DataObject' clipboard format that contains the
2068 * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
2069 */
2070 static HRESULT set_dataobject_format(HWND hwnd)
2071 {
2072 HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
2073 HWND *data;
2074
2075 if(!h) return E_OUTOFMEMORY;
2076
2077 data = GlobalLock(h);
2078 *data = hwnd;
2079 GlobalUnlock(h);
2080
2081 if(!SetClipboardData(dataobject_clipboard_format, h))
2082 {
2083 GlobalFree(h);
2084 return CLIPBRD_E_CANT_SET;
2085 }
2086
2087 return S_OK;
2088 }
2089
2090 /*---------------------------------------------------------------------*
2091 * Win32 OLE clipboard API
2092 *---------------------------------------------------------------------*/
2093
2094 /***********************************************************************
2095 * OleSetClipboard [OLE32.@]
2096 * Places a pointer to the specified data object onto the clipboard,
2097 * making the data object accessible to the OleGetClipboard function.
2098 *
2099 * RETURNS
2100 *
2101 * S_OK IDataObject pointer placed on the clipboard
2102 * CLIPBRD_E_CANT_OPEN OpenClipboard failed
2103 * CLIPBRD_E_CANT_EMPTY EmptyClipboard failed
2104 * CLIPBRD_E_CANT_CLOSE CloseClipboard failed
2105 * CLIPBRD_E_CANT_SET SetClipboard failed
2106 */
2107
2108 HRESULT WINAPI OleSetClipboard(IDataObject* data)
2109 {
2110 HRESULT hr;
2111 ole_clipbrd *clipbrd;
2112 HWND wnd;
2113
2114 TRACE("(%p)\n", data);
2115
2116 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
2117
2118 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
2119
2120 if ( !OpenClipboard(wnd) ) return CLIPBRD_E_CANT_OPEN;
2121
2122 if ( !EmptyClipboard() )
2123 {
2124 hr = CLIPBRD_E_CANT_EMPTY;
2125 goto end;
2126 }
2127
2128 hr = set_src_dataobject(clipbrd, data);
2129 if(FAILED(hr)) goto end;
2130
2131 if(data)
2132 {
2133 hr = expose_marshalled_dataobject(clipbrd, data);
2134 if(FAILED(hr)) goto end;
2135 hr = set_dataobject_format(wnd);
2136 }
2137
2138 end:
2139
2140 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
2141
2142 if ( FAILED(hr) )
2143 {
2144 expose_marshalled_dataobject(clipbrd, NULL);
2145 set_src_dataobject(clipbrd, NULL);
2146 }
2147
2148 return hr;
2149 }
2150
2151
2152 /***********************************************************************
2153 * OleGetClipboard [OLE32.@]
2154 * Returns a pointer to our internal IDataObject which represents the conceptual
2155 * state of the Windows clipboard. If the current clipboard already contains
2156 * an IDataObject, our internal IDataObject will delegate to this object.
2157 */
2158 HRESULT WINAPI OleGetClipboard(IDataObject **obj)
2159 {
2160 HRESULT hr;
2161 ole_clipbrd *clipbrd;
2162 DWORD seq_no;
2163
2164 TRACE("(%p)\n", obj);
2165
2166 if(!obj) return E_INVALIDARG;
2167
2168 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
2169
2170 seq_no = GetClipboardSequenceNumber();
2171 if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
2172 clipbrd->latest_snapshot = NULL;
2173
2174 if(!clipbrd->latest_snapshot)
2175 {
2176 clipbrd->latest_snapshot = snapshot_construct(seq_no);
2177 if(!clipbrd->latest_snapshot) return E_OUTOFMEMORY;
2178 }
2179
2180 *obj = &clipbrd->latest_snapshot->IDataObject_iface;
2181 IDataObject_AddRef(*obj);
2182
2183 return S_OK;
2184 }
2185
2186 /******************************************************************************
2187 * OleFlushClipboard [OLE32.@]
2188 * Renders the data from the source IDataObject into the windows clipboard
2189 *
2190 * TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
2191 * by copying the storage into global memory. Subsequently the default
2192 * data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
2193 * back to TYMED_IStorage.
2194 */
2195 HRESULT WINAPI OleFlushClipboard(void)
2196 {
2197 HRESULT hr;
2198 ole_clipbrd *clipbrd;
2199 HWND wnd;
2200
2201 TRACE("()\n");
2202
2203 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
2204
2205 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
2206
2207 /*
2208 * Already flushed or no source DataObject? Nothing to do.
2209 */
2210 if (!clipbrd->src_data) return S_OK;
2211
2212 if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
2213
2214 SendMessageW(wnd, WM_RENDERALLFORMATS, 0, 0);
2215
2216 hr = set_dataobject_format(NULL);
2217
2218 expose_marshalled_dataobject(clipbrd, NULL);
2219 set_src_dataobject(clipbrd, NULL);
2220
2221 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
2222
2223 return hr;
2224 }
2225
2226
2227 /***********************************************************************
2228 * OleIsCurrentClipboard [OLE32.@]
2229 */
2230 HRESULT WINAPI OleIsCurrentClipboard(IDataObject *data)
2231 {
2232 HRESULT hr;
2233 ole_clipbrd *clipbrd;
2234 TRACE("()\n");
2235
2236 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
2237
2238 if (data == NULL) return S_FALSE;
2239
2240 return (data == clipbrd->src_data) ? S_OK : S_FALSE;
2241 }
A free Windows-compatible Operating System