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 - emum tymed %x req tymed %x\n", entry->fmtetc.tymed, 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 FIXME("(%p, %p {%s}, %p): stub\n", iface, fmt, dump_fmtetc(fmt), med);
1218 return E_NOTIMPL;
1219 }
1220
1221 /************************************************************************
1222 * snapshot_QueryGetData
1223 *
1224 * The OLE Clipboard's implementation of this method delegates to
1225 * a data source if there is one or wraps around the windows clipboard
1226 * function IsClipboardFormatAvailable() otherwise.
1227 *
1228 */
1229 static HRESULT WINAPI snapshot_QueryGetData(IDataObject *iface, FORMATETC *fmt)
1230 {
1231 FIXME("(%p, %p {%s})\n", iface, fmt, dump_fmtetc(fmt));
1232
1233 if (!fmt) return E_INVALIDARG;
1234
1235 if ( fmt->dwAspect != DVASPECT_CONTENT ) return DV_E_FORMATETC;
1236
1237 if ( fmt->lindex != -1 ) return DV_E_FORMATETC;
1238
1239 return (IsClipboardFormatAvailable(fmt->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
1240 }
1241
1242 /************************************************************************
1243 * snapshot_GetCanonicalFormatEtc
1244 */
1245 static HRESULT WINAPI snapshot_GetCanonicalFormatEtc(IDataObject *iface, FORMATETC *fmt_in,
1246 FORMATETC *fmt_out)
1247 {
1248 TRACE("(%p, %p, %p)\n", iface, fmt_in, fmt_out);
1249
1250 if ( !fmt_in || !fmt_out ) return E_INVALIDARG;
1251
1252 *fmt_out = *fmt_in;
1253 return DATA_S_SAMEFORMATETC;
1254 }
1255
1256 /************************************************************************
1257 * snapshot_SetData
1258 *
1259 * The OLE Clipboard does not implement this method
1260 */
1261 static HRESULT WINAPI snapshot_SetData(IDataObject *iface, FORMATETC *fmt,
1262 STGMEDIUM *med, BOOL release)
1263 {
1264 TRACE("(%p, %p, %p, %d): not implemented\n", iface, fmt, med, release);
1265 return E_NOTIMPL;
1266 }
1267
1268 /************************************************************************
1269 * snapshot_EnumFormatEtc
1270 *
1271 */
1272 static HRESULT WINAPI snapshot_EnumFormatEtc(IDataObject *iface, DWORD dir,
1273 IEnumFORMATETC **enum_fmt)
1274 {
1275 HRESULT hr;
1276 ole_priv_data *data = NULL;
1277
1278 TRACE("(%p, %x, %p)\n", iface, dir, enum_fmt);
1279
1280 *enum_fmt = NULL;
1281
1282 if ( dir != DATADIR_GET ) return E_NOTIMPL;
1283 if ( !OpenClipboard(NULL) ) return CLIPBRD_E_CANT_OPEN;
1284
1285 hr = get_priv_data(&data);
1286
1287 if(FAILED(hr)) goto end;
1288
1289 hr = enum_fmtetc_construct( data, 0, enum_fmt );
1290
1291 end:
1292 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1293 return hr;
1294 }
1295
1296 /************************************************************************
1297 * snapshot_DAdvise
1298 *
1299 * The OLE Clipboard does not implement this method
1300 */
1301 static HRESULT WINAPI snapshot_DAdvise(IDataObject *iface, FORMATETC *fmt,
1302 DWORD flags, IAdviseSink *sink,
1303 DWORD *conn)
1304 {
1305 TRACE("(%p, %p, %x, %p, %p): not implemented\n", iface, fmt, flags, sink, conn);
1306 return E_NOTIMPL;
1307 }
1308
1309 /************************************************************************
1310 * snapshot_DUnadvise
1311 *
1312 * The OLE Clipboard does not implement this method
1313 */
1314 static HRESULT WINAPI snapshot_DUnadvise(IDataObject* iface, DWORD conn)
1315 {
1316 TRACE("(%p, %d): not implemented\n", iface, conn);
1317 return E_NOTIMPL;
1318 }
1319
1320 /************************************************************************
1321 * snapshot_EnumDAdvise
1322 *
1323 * The OLE Clipboard does not implement this method
1324 */
1325 static HRESULT WINAPI snapshot_EnumDAdvise(IDataObject* iface,
1326 IEnumSTATDATA** enum_advise)
1327 {
1328 TRACE("(%p, %p): not implemented\n", iface, enum_advise);
1329 return E_NOTIMPL;
1330 }
1331
1332 static const IDataObjectVtbl snapshot_vtable =
1333 {
1334 snapshot_QueryInterface,
1335 snapshot_AddRef,
1336 snapshot_Release,
1337 snapshot_GetData,
1338 snapshot_GetDataHere,
1339 snapshot_QueryGetData,
1340 snapshot_GetCanonicalFormatEtc,
1341 snapshot_SetData,
1342 snapshot_EnumFormatEtc,
1343 snapshot_DAdvise,
1344 snapshot_DUnadvise,
1345 snapshot_EnumDAdvise
1346 };
1347
1348 /*---------------------------------------------------------------------*
1349 * Internal implementation methods for the OLE clipboard
1350 *---------------------------------------------------------------------*/
1351
1352 static snapshot *snapshot_construct(DWORD seq_no)
1353 {
1354 snapshot *This;
1355
1356 This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
1357 if (!This) return NULL;
1358
1359 This->lpVtbl = &snapshot_vtable;
1360 This->ref = 0;
1361 This->seq_no = seq_no;
1362 This->data = NULL;
1363
1364 return This;
1365 }
1366
1367 /*********************************************************
1368 * register_clipboard_formats
1369 */
1370 static void register_clipboard_formats(void)
1371 {
1372 static const WCHAR OwnerLink[] = {'O','w','n','e','r','L','i','n','k',0};
1373 static const WCHAR FileName[] = {'F','i','l','e','N','a','m','e',0};
1374 static const WCHAR FileNameW[] = {'F','i','l','e','N','a','m','e','W',0};
1375 static const WCHAR DataObject[] = {'D','a','t','a','O','b','j','e','c','t',0};
1376 static const WCHAR EmbeddedObject[] = {'E','m','b','e','d','d','e','d',' ','O','b','j','e','c','t',0};
1377 static const WCHAR EmbedSource[] = {'E','m','b','e','d',' ','S','o','u','r','c','e',0};
1378 static const WCHAR CustomLinkSource[] = {'C','u','s','t','o','m',' ','L','i','n','k',' ','S','o','u','r','c','e',0};
1379 static const WCHAR LinkSource[] = {'L','i','n','k',' ','S','o','u','r','c','e',0};
1380 static const WCHAR ObjectDescriptor[] = {'O','b','j','e','c','t',' ','D','e','s','c','r','i','p','t','o','r',0};
1381 static const WCHAR LinkSourceDescriptor[] = {'L','i','n','k',' ','S','o','u','r','c','e',' ',
1382 'D','e','s','c','r','i','p','t','o','r',0};
1383 static const WCHAR OlePrivateData[] = {'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0};
1384
1385 static const WCHAR WineMarshalledDataObject[] = {'W','i','n','e',' ','M','a','r','s','h','a','l','l','e','d',' ',
1386 'D','a','t','a','O','b','j','e','c','t',0};
1387
1388 ownerlink_clipboard_format = RegisterClipboardFormatW(OwnerLink);
1389 filename_clipboard_format = RegisterClipboardFormatW(FileName);
1390 filenameW_clipboard_format = RegisterClipboardFormatW(FileNameW);
1391 dataobject_clipboard_format = RegisterClipboardFormatW(DataObject);
1392 embedded_object_clipboard_format = RegisterClipboardFormatW(EmbeddedObject);
1393 embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSource);
1394 custom_link_source_clipboard_format = RegisterClipboardFormatW(CustomLinkSource);
1395 link_source_clipboard_format = RegisterClipboardFormatW(LinkSource);
1396 object_descriptor_clipboard_format = RegisterClipboardFormatW(ObjectDescriptor);
1397 link_source_descriptor_clipboard_format = RegisterClipboardFormatW(LinkSourceDescriptor);
1398 ole_private_data_clipboard_format = RegisterClipboardFormatW(OlePrivateData);
1399
1400 wine_marshal_clipboard_format = RegisterClipboardFormatW(WineMarshalledDataObject);
1401 }
1402
1403 /***********************************************************************
1404 * OLEClipbrd_Initialize()
1405 * Initializes the OLE clipboard.
1406 */
1407 void OLEClipbrd_Initialize(void)
1408 {
1409 register_clipboard_formats();
1410
1411 if ( !theOleClipboard )
1412 {
1413 ole_clipbrd* clipbrd;
1414 HGLOBAL h;
1415
1416 TRACE("()\n");
1417
1418 clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
1419 if (!clipbrd) return;
1420
1421 clipbrd->latest_snapshot = NULL;
1422 clipbrd->window = NULL;
1423 clipbrd->src_data = NULL;
1424 clipbrd->cached_enum = NULL;
1425
1426 h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
1427 if(!h)
1428 {
1429 HeapFree(GetProcessHeap(), 0, clipbrd);
1430 return;
1431 }
1432
1433 if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
1434 {
1435 GlobalFree(h);
1436 HeapFree(GetProcessHeap(), 0, clipbrd);
1437 return;
1438 }
1439
1440 theOleClipboard = clipbrd;
1441 }
1442 }
1443
1444 /***********************************************************************
1445 * OLEClipbrd_UnInitialize()
1446 * Un-Initializes the OLE clipboard
1447 */
1448 void OLEClipbrd_UnInitialize(void)
1449 {
1450 ole_clipbrd *clipbrd = theOleClipboard;
1451
1452 TRACE("()\n");
1453
1454 if ( clipbrd )
1455 {
1456 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1457 HINSTANCE hinst = GetModuleHandleW(ole32W);
1458
1459 if ( clipbrd->window )
1460 {
1461 DestroyWindow(clipbrd->window);
1462 UnregisterClassW( clipbrd_wndclass, hinst );
1463 }
1464
1465 IStream_Release(clipbrd->marshal_data);
1466 HeapFree(GetProcessHeap(), 0, clipbrd);
1467 theOleClipboard = NULL;
1468 }
1469 }
1470
1471 /*********************************************************************
1472 * set_clipboard_formats
1473 *
1474 * Enumerate all formats supported by the source and make
1475 * those formats available using delayed rendering using SetClipboardData.
1476 * Cache the enumeration list and make that list visibile as the
1477 * 'Ole Private Data' format on the clipboard.
1478 *
1479 */
1480 static HRESULT set_clipboard_formats(ole_clipbrd *clipbrd, IDataObject *data)
1481 {
1482 HRESULT hr;
1483 FORMATETC fmt;
1484 IEnumFORMATETC *enum_fmt;
1485 HGLOBAL priv_data_handle;
1486 DWORD_PTR target_offset;
1487 ole_priv_data *priv_data;
1488 DWORD count = 0, needed = sizeof(*priv_data), idx;
1489
1490 hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
1491 if(FAILED(hr)) return hr;
1492
1493 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1494 {
1495 count++;
1496 needed += sizeof(priv_data->entries[0]);
1497 if(fmt.ptd)
1498 {
1499 needed += fmt.ptd->tdSize;
1500 CoTaskMemFree(fmt.ptd);
1501 }
1502 }
1503
1504 /* Windows pads the list with two empty ole_priv_data_entries, one
1505 * after the entries array and one after the target device data.
1506 * Allocating with zero init to zero these pads. */
1507
1508 needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
1509 priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
1510 priv_data = GlobalLock(priv_data_handle);
1511
1512 priv_data->unk1 = 0;
1513 priv_data->size = needed;
1514 priv_data->unk2 = 1;
1515 priv_data->count = count;
1516 priv_data->unk3[0] = 0;
1517 priv_data->unk3[1] = 0;
1518
1519 IEnumFORMATETC_Reset(enum_fmt);
1520
1521 idx = 0;
1522 target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
1523
1524 while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1525 {
1526 TRACE("%s\n", dump_fmtetc(&fmt));
1527
1528 priv_data->entries[idx].fmtetc = fmt;
1529 if(fmt.ptd)
1530 {
1531 memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
1532 priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
1533 target_offset += fmt.ptd->tdSize;
1534 CoTaskMemFree(fmt.ptd);
1535 }
1536
1537 priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
1538 priv_data->entries[idx].unk[0] = 0;
1539 priv_data->entries[idx].unk[1] = 0;
1540
1541 if (priv_data->entries[idx].first_use)
1542 SetClipboardData(fmt.cfFormat, NULL);
1543
1544 idx++;
1545 }
1546
1547 IEnumFORMATETC_Release(enum_fmt);
1548
1549 /* Cache the list and fixup any target device offsets to ptrs */
1550 clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
1551 memcpy(clipbrd->cached_enum, priv_data, needed);
1552 for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
1553 clipbrd->cached_enum->entries[idx].fmtetc.ptd =
1554 td_offs_to_ptr(clipbrd->cached_enum, (DWORD_PTR)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
1555
1556 GlobalUnlock(priv_data_handle);
1557 SetClipboardData(ole_private_data_clipboard_format, priv_data_handle);
1558
1559 return S_OK;
1560 }
1561
1562 static HWND create_clipbrd_window(void);
1563
1564 /***********************************************************************
1565 * get_clipbrd_window
1566 */
1567 static inline HRESULT get_clipbrd_window(ole_clipbrd *clipbrd, HWND *wnd)
1568 {
1569 if ( !clipbrd->window )
1570 clipbrd->window = create_clipbrd_window();
1571
1572 *wnd = clipbrd->window;
1573 return *wnd ? S_OK : E_FAIL;
1574 }
1575
1576
1577 /**********************************************************************
1578 * release_marshal_data
1579 *
1580 * Releases the data and sets the stream back to zero size.
1581 */
1582 static inline void release_marshal_data(IStream *stm)
1583 {
1584 LARGE_INTEGER pos;
1585 ULARGE_INTEGER size;
1586 pos.QuadPart = size.QuadPart = 0;
1587
1588 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1589 CoReleaseMarshalData(stm);
1590 IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1591 IStream_SetSize(stm, size);
1592 }
1593
1594 /***********************************************************************
1595 * expose_marshalled_dataobject
1596 *
1597 * Sets the marshalled dataobject to the clipboard. In the flushed case
1598 * we set a zero sized HGLOBAL to clear the old marshalled data.
1599 */
1600 static HRESULT expose_marshalled_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1601 {
1602 HGLOBAL h;
1603
1604 if(data)
1605 {
1606 HGLOBAL h_stm;
1607 GetHGlobalFromStream(clipbrd->marshal_data, &h_stm);
1608 dup_global_mem(h_stm, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
1609 }
1610 else /* flushed */
1611 h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 0);
1612
1613 if(!h) return E_OUTOFMEMORY;
1614
1615 SetClipboardData(wine_marshal_clipboard_format, h);
1616 return S_OK;
1617 }
1618
1619 /***********************************************************************
1620 * set_src_dataobject
1621 *
1622 * Clears and sets the clipboard's src IDataObject.
1623 *
1624 * To marshal the source dataobject we do something rather different from Windows.
1625 * We set a clipboard format which contains the marshalled data.
1626 * Windows sets two window props one of which is an IID, the other is an endpoint number.
1627 */
1628 static HRESULT set_src_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1629 {
1630 HRESULT hr;
1631 HWND wnd;
1632
1633 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1634
1635 if(clipbrd->src_data)
1636 {
1637 release_marshal_data(clipbrd->marshal_data);
1638
1639 IDataObject_Release(clipbrd->src_data);
1640 clipbrd->src_data = NULL;
1641 HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1642 clipbrd->cached_enum = NULL;
1643 }
1644
1645 if(data)
1646 {
1647 IUnknown *unk;
1648
1649 IDataObject_AddRef(data);
1650 clipbrd->src_data = data;
1651
1652 IDataObject_QueryInterface(data, &IID_IUnknown, (void**)&unk);
1653 hr = CoMarshalInterface(clipbrd->marshal_data, &IID_IDataObject, unk,
1654 MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
1655 IUnknown_Release(unk); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
1656 if(FAILED(hr)) return hr;
1657 hr = set_clipboard_formats(clipbrd, data);
1658 }
1659 return hr;
1660 }
1661
1662 /***********************************************************************
1663 * clipbrd_wndproc
1664 */
1665 static LRESULT CALLBACK clipbrd_wndproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1666 {
1667 ole_clipbrd *clipbrd;
1668
1669 get_ole_clipbrd(&clipbrd);
1670
1671 switch (message)
1672 {
1673 case WM_RENDERFORMAT:
1674 {
1675 UINT cf = wparam;
1676 ole_priv_data_entry *entry;
1677
1678 TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
1679 entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
1680
1681 if(entry)
1682 render_format(clipbrd->src_data, &entry->fmtetc);
1683
1684 break;
1685 }
1686
1687 case WM_RENDERALLFORMATS:
1688 {
1689 DWORD i;
1690 ole_priv_data_entry *entries = clipbrd->cached_enum->entries;
1691
1692 TRACE("(): WM_RENDERALLFORMATS\n");
1693
1694 for(i = 0; i < clipbrd->cached_enum->count; i++)
1695 {
1696 if(entries[i].first_use)
1697 render_format(clipbrd->src_data, &entries[i].fmtetc);
1698 }
1699 break;
1700 }
1701
1702 case WM_DESTROYCLIPBOARD:
1703 {
1704 TRACE("(): WM_DESTROYCLIPBOARD\n");
1705
1706 set_src_dataobject(clipbrd, NULL);
1707 break;
1708 }
1709
1710 default:
1711 return DefWindowProcW(hwnd, message, wparam, lparam);
1712 }
1713
1714 return 0;
1715 }
1716
1717
1718 /***********************************************************************
1719 * create_clipbrd_window
1720 */
1721 static HWND create_clipbrd_window(void)
1722 {
1723 WNDCLASSEXW class;
1724 static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1725 static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
1726 HINSTANCE hinst = GetModuleHandleW(ole32W);
1727
1728 class.cbSize = sizeof(class);
1729 class.style = 0;
1730 class.lpfnWndProc = clipbrd_wndproc;
1731 class.cbClsExtra = 0;
1732 class.cbWndExtra = 0;
1733 class.hInstance = hinst;
1734 class.hIcon = 0;
1735 class.hCursor = 0;
1736 class.hbrBackground = 0;
1737 class.lpszMenuName = NULL;
1738 class.lpszClassName = clipbrd_wndclass;
1739 class.hIconSm = NULL;
1740
1741 RegisterClassExW(&class);
1742
1743 return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
1744 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1745 NULL, NULL, hinst, 0);
1746 }
1747
1748 /*********************************************************************
1749 * set_dataobject_format
1750 *
1751 * Windows creates a 'DataObject' clipboard format that contains the
1752 * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
1753 */
1754 static HRESULT set_dataobject_format(HWND hwnd)
1755 {
1756 HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
1757 HWND *data;
1758
1759 if(!h) return E_OUTOFMEMORY;
1760
1761 data = GlobalLock(h);
1762 *data = hwnd;
1763 GlobalUnlock(h);
1764
1765 if(!SetClipboardData(dataobject_clipboard_format, h))
1766 {
1767 GlobalFree(h);
1768 return CLIPBRD_E_CANT_SET;
1769 }
1770
1771 return S_OK;
1772 }
1773
1774 /*---------------------------------------------------------------------*
1775 * Win32 OLE clipboard API
1776 *---------------------------------------------------------------------*/
1777
1778 /***********************************************************************
1779 * OleSetClipboard [OLE32.@]
1780 * Places a pointer to the specified data object onto the clipboard,
1781 * making the data object accessible to the OleGetClipboard function.
1782 *
1783 * RETURNS
1784 *
1785 * S_OK IDataObject pointer placed on the clipboard
1786 * CLIPBRD_E_CANT_OPEN OpenClipboard failed
1787 * CLIPBRD_E_CANT_EMPTY EmptyClipboard failed
1788 * CLIPBRD_E_CANT_CLOSE CloseClipboard failed
1789 * CLIPBRD_E_CANT_SET SetClipboard failed
1790 */
1791
1792 HRESULT WINAPI OleSetClipboard(IDataObject* data)
1793 {
1794 HRESULT hr;
1795 ole_clipbrd *clipbrd;
1796 HWND wnd;
1797
1798 TRACE("(%p)\n", data);
1799
1800 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1801
1802 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1803
1804 if ( !OpenClipboard(wnd) ) return CLIPBRD_E_CANT_OPEN;
1805
1806 if ( !EmptyClipboard() )
1807 {
1808 hr = CLIPBRD_E_CANT_EMPTY;
1809 goto end;
1810 }
1811
1812 hr = set_src_dataobject(clipbrd, data);
1813 if(FAILED(hr)) goto end;
1814
1815 if(data)
1816 {
1817 hr = expose_marshalled_dataobject(clipbrd, data);
1818 if(FAILED(hr)) goto end;
1819 hr = set_dataobject_format(wnd);
1820 }
1821
1822 end:
1823
1824 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1825
1826 if ( FAILED(hr) )
1827 {
1828 expose_marshalled_dataobject(clipbrd, NULL);
1829 set_src_dataobject(clipbrd, NULL);
1830 }
1831
1832 return hr;
1833 }
1834
1835
1836 /***********************************************************************
1837 * OleGetClipboard [OLE32.@]
1838 * Returns a pointer to our internal IDataObject which represents the conceptual
1839 * state of the Windows clipboard. If the current clipboard already contains
1840 * an IDataObject, our internal IDataObject will delegate to this object.
1841 */
1842 HRESULT WINAPI OleGetClipboard(IDataObject **obj)
1843 {
1844 HRESULT hr;
1845 ole_clipbrd *clipbrd;
1846 DWORD seq_no;
1847
1848 TRACE("(%p)\n", obj);
1849
1850 if(!obj) return E_INVALIDARG;
1851
1852 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1853
1854 seq_no = GetClipboardSequenceNumber();
1855 if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
1856 clipbrd->latest_snapshot = NULL;
1857
1858 if(!clipbrd->latest_snapshot)
1859 {
1860 clipbrd->latest_snapshot = snapshot_construct(seq_no);
1861 if(!clipbrd->latest_snapshot) return E_OUTOFMEMORY;
1862 }
1863
1864 *obj = (IDataObject*)&clipbrd->latest_snapshot->lpVtbl;
1865 IDataObject_AddRef(*obj);
1866
1867 return S_OK;
1868 }
1869
1870 /******************************************************************************
1871 * OleFlushClipboard [OLE32.@]
1872 * Renders the data from the source IDataObject into the windows clipboard
1873 *
1874 * TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
1875 * by copying the storage into global memory. Subsequently the default
1876 * data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
1877 * back to TYMED_IStorage.
1878 */
1879 HRESULT WINAPI OleFlushClipboard(void)
1880 {
1881 HRESULT hr;
1882 ole_clipbrd *clipbrd;
1883 HWND wnd;
1884
1885 TRACE("()\n");
1886
1887 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1888
1889 if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1890
1891 /*
1892 * Already flushed or no source DataObject? Nothing to do.
1893 */
1894 if (!clipbrd->src_data) return S_OK;
1895
1896 if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
1897
1898 SendMessageW(wnd, WM_RENDERALLFORMATS, 0, 0);
1899
1900 hr = set_dataobject_format(NULL);
1901
1902 expose_marshalled_dataobject(clipbrd, NULL);
1903 set_src_dataobject(clipbrd, NULL);
1904
1905 if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1906
1907 return hr;
1908 }
1909
1910
1911 /***********************************************************************
1912 * OleIsCurrentClipboard [OLE32.@]
1913 */
1914 HRESULT WINAPI OleIsCurrentClipboard(IDataObject *data)
1915 {
1916 HRESULT hr;
1917 ole_clipbrd *clipbrd;
1918 TRACE("()\n");
1919
1920 if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1921
1922 if (data == NULL) return S_FALSE;
1923
1924 return (data == clipbrd->src_data) ? S_OK : S_FALSE;
1925 }
1926
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.