2 * OLE 2 clipboard support
4 * Copyright 1999 Noel Borthwick <noel@macadamian.com>
5 * Copyright 2000 Abey George <abey@macadamian.com>
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.
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.
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
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 APIs. 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:
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.
37 * 2. OleGetClipboard called without previous OleSetClipboard. Here the internal
38 * IDataObject functionality wraps around the WIN32 clipboard API.
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.
44 * Implementation references : Inside OLE 2'nd edition by Kraig Brockschmidt
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.
67 #define NONAMELESSUNION
76 #include "wine/debug.h"
79 #include "storage32.h"
81 #include "compobj_private.h"
83 WINE_DEFAULT_DEBUG_CHANNEL(ole
);
85 /* Structure of 'Ole Private Data' clipboard format */
89 DWORD first_use
; /* Has this cf been added to the list already */
91 } ole_priv_data_entry
;
96 DWORD size
; /* in bytes of the entire structure */
98 DWORD count
; /* no. of format entries */
100 ole_priv_data_entry entries
[1]; /* array of size count */
101 /* then follows any DVTARGETDEVICE structures referenced in the FORMATETCs */
104 /*****************************************************************************
107 * Returns a ptr to a target device at a given offset from the
108 * start of the ole_priv_data.
110 * Used when unpacking ole private data from the clipboard.
112 static inline DVTARGETDEVICE
*td_offs_to_ptr(ole_priv_data
*data
, DWORD_PTR off
)
114 if(off
== 0) return NULL
;
115 return (DVTARGETDEVICE
*)((char*)data
+ off
);
118 /*****************************************************************************
121 * Get the offset from the start of the ole_priv_data of the idx'th
124 * Used when packing ole private data to the clipboard.
126 static inline DWORD_PTR
td_get_offs(ole_priv_data
*data
, DWORD idx
)
128 if(data
->entries
[idx
].fmtetc
.ptd
== NULL
) return 0;
129 return (char*)data
->entries
[idx
].fmtetc
.ptd
- (char*)data
;
132 /****************************************************************************
133 * Consumer snapshot. Represents the state of the ole clipboard
134 * returned by OleGetClipboard().
136 typedef struct snapshot
138 IDataObject IDataObject_iface
;
141 DWORD seq_no
; /* Clipboard sequence number corresponding to this snapshot */
143 IDataObject
*data
; /* If we unmarshal a remote data object we hold a ref here */
146 /****************************************************************************
149 typedef struct ole_clipbrd
151 snapshot
*latest_snapshot
; /* Latest consumer snapshot */
153 HWND window
; /* Hidden clipboard window */
154 IDataObject
*src_data
; /* Source object passed to OleSetClipboard */
155 ole_priv_data
*cached_enum
; /* Cached result from the enumeration of src data object */
156 IStream
*marshal_data
; /* Stream onto which to marshal src_data */
159 static inline snapshot
*impl_from_IDataObject(IDataObject
*iface
)
161 return CONTAINING_RECORD(iface
, snapshot
, IDataObject_iface
);
164 typedef struct PresentationDataHeader
167 DWORD dwObjectExtentX
;
168 DWORD dwObjectExtentY
;
170 } PresentationDataHeader
;
173 * The one and only ole_clipbrd object which is created by clipbrd_create()
175 static ole_clipbrd
* theOleClipboard
;
177 static CRITICAL_SECTION latest_snapshot_cs
;
178 static CRITICAL_SECTION_DEBUG latest_snapshot_cs_debug
=
180 0, 0, &latest_snapshot_cs
,
181 { &latest_snapshot_cs_debug
.ProcessLocksList
, &latest_snapshot_cs_debug
.ProcessLocksList
},
182 0, 0, { (DWORD_PTR
)(__FILE__
": clipboard last snapshot") }
184 static CRITICAL_SECTION latest_snapshot_cs
= { &latest_snapshot_cs_debug
, -1, 0, 0, 0, 0 };
187 * Name of our registered OLE clipboard window class
189 static const WCHAR clipbrd_wndclass
[] = L
"CLIPBRDWNDCLASS";
191 UINT ownerlink_clipboard_format
= 0;
192 UINT filename_clipboard_format
= 0;
193 UINT filenameW_clipboard_format
= 0;
194 UINT dataobject_clipboard_format
= 0;
195 UINT embedded_object_clipboard_format
= 0;
196 UINT embed_source_clipboard_format
= 0;
197 UINT custom_link_source_clipboard_format
= 0;
198 UINT link_source_clipboard_format
= 0;
199 UINT object_descriptor_clipboard_format
= 0;
200 UINT link_source_descriptor_clipboard_format
= 0;
201 UINT ole_private_data_clipboard_format
= 0;
203 static UINT wine_marshal_clipboard_format
;
205 static void register_clipboard_formats(void)
207 ownerlink_clipboard_format
= RegisterClipboardFormatW(L
"OwnerLink");
208 filename_clipboard_format
= RegisterClipboardFormatW(L
"FileName");
209 filenameW_clipboard_format
= RegisterClipboardFormatW(L
"FileNameW");
210 dataobject_clipboard_format
= RegisterClipboardFormatW(L
"DataObject");
211 embedded_object_clipboard_format
= RegisterClipboardFormatW(L
"Embedded Object");
212 embed_source_clipboard_format
= RegisterClipboardFormatW(L
"Embed Source");
213 custom_link_source_clipboard_format
= RegisterClipboardFormatW(L
"Custom Link Source");
214 link_source_clipboard_format
= RegisterClipboardFormatW(L
"Link Source");
215 object_descriptor_clipboard_format
= RegisterClipboardFormatW(L
"Object Descriptor");
216 link_source_descriptor_clipboard_format
= RegisterClipboardFormatW(L
"Link Source Descriptor");
217 ole_private_data_clipboard_format
= RegisterClipboardFormatW(L
"Ole Private Data");
219 wine_marshal_clipboard_format
= RegisterClipboardFormatW(L
"Wine Marshalled DataObject");
222 static BOOL WINAPI
clipbrd_create(INIT_ONCE
*init_once
, void *parameter
, void **context
)
224 ole_clipbrd
* clipbrd
;
229 register_clipboard_formats();
231 clipbrd
= HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd
) );
238 clipbrd
->latest_snapshot
= NULL
;
239 clipbrd
->window
= NULL
;
240 clipbrd
->src_data
= NULL
;
241 clipbrd
->cached_enum
= NULL
;
243 h
= GlobalAlloc(GMEM_DDESHARE
| GMEM_MOVEABLE
, 0);
247 HeapFree(GetProcessHeap(), 0, clipbrd
);
251 if(FAILED(CreateStreamOnHGlobal(h
, TRUE
, &clipbrd
->marshal_data
)))
253 ERR("CreateStreamOnHGlobal failed.\n");
255 HeapFree(GetProcessHeap(), 0, clipbrd
);
259 theOleClipboard
= clipbrd
;
263 static inline HRESULT
get_ole_clipbrd(ole_clipbrd
**clipbrd
)
265 static INIT_ONCE init_once
= INIT_ONCE_STATIC_INIT
;
267 if (!InitOnceExecuteOnce(&init_once
, clipbrd_create
, NULL
, NULL
))
270 return CO_E_NOTINITIALIZED
;
273 *clipbrd
= theOleClipboard
;
277 static inline const char *dump_fmtetc(FORMATETC
*fmt
)
279 if (!fmt
) return "(null)";
280 return wine_dbg_sprintf("cf %04x ptd %p aspect %lx lindex %ld tymed %lx",
281 fmt
->cfFormat
, fmt
->ptd
, fmt
->dwAspect
, fmt
->lindex
, fmt
->tymed
);
284 /*---------------------------------------------------------------------*
285 * Implementation of the internal IEnumFORMATETC interface returned by
286 * the OLE clipboard's IDataObject.
287 *---------------------------------------------------------------------*/
289 typedef struct enum_fmtetc
291 IEnumFORMATETC IEnumFORMATETC_iface
;
294 UINT pos
; /* current enumerator position */
298 static inline enum_fmtetc
*impl_from_IEnumFORMATETC(IEnumFORMATETC
*iface
)
300 return CONTAINING_RECORD(iface
, enum_fmtetc
, IEnumFORMATETC_iface
);
303 /************************************************************************
304 * OLEClipbrd_IEnumFORMATETC_QueryInterface (IUnknown)
306 * See Windows documentation for more details on IUnknown methods.
308 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface
309 (LPENUMFORMATETC iface
, REFIID riid
, LPVOID
* ppvObj
)
311 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
313 TRACE("(%p)->(IID: %s, %p)\n", This
, debugstr_guid(riid
), ppvObj
);
317 if(IsEqualIID(riid
, &IID_IUnknown
) ||
318 IsEqualIID(riid
, &IID_IEnumFORMATETC
))
325 IEnumFORMATETC_AddRef((IEnumFORMATETC
*)*ppvObj
);
326 TRACE("-- Interface: (%p)->(%p)\n",ppvObj
,*ppvObj
);
330 TRACE("-- Interface: E_NOINTERFACE\n");
331 return E_NOINTERFACE
;
334 /************************************************************************
335 * OLEClipbrd_IEnumFORMATETC_AddRef (IUnknown)
338 static ULONG WINAPI
OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface
)
340 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
341 ULONG ref
= InterlockedIncrement(&This
->ref
);
343 TRACE("%p, refcount %lu.\n", iface
, ref
);
348 /************************************************************************
349 * OLEClipbrd_IEnumFORMATETC_Release (IUnknown)
351 * See Windows documentation for more details on IUnknown methods.
353 static ULONG WINAPI
OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface
)
355 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
356 ULONG ref
= InterlockedDecrement(&This
->ref
);
358 TRACE("%p, refcount %lu.\n", iface
, ref
);
362 TRACE("() - destroying IEnumFORMATETC(%p)\n",This
);
363 HeapFree(GetProcessHeap(), 0, This
->data
);
364 HeapFree(GetProcessHeap(), 0, This
);
369 /************************************************************************
370 * OLEClipbrd_IEnumFORMATETC_Next (IEnumFORMATETC)
372 * Standard enumerator members for IEnumFORMATETC
374 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next
375 (LPENUMFORMATETC iface
, ULONG celt
, FORMATETC
*rgelt
, ULONG
*pceltFethed
)
377 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
379 HRESULT hres
= S_FALSE
;
381 TRACE("(%p)->(pos=%u)\n", This
, This
->pos
);
383 if (This
->pos
< This
->data
->count
)
385 cfetch
= This
->data
->count
- This
->pos
;
392 for(i
= 0; i
< cfetch
; i
++)
394 hres
= copy_formatetc(rgelt
+ i
, &This
->data
->entries
[This
->pos
++].fmtetc
);
395 if(FAILED(hres
)) return hres
;
405 *pceltFethed
= cfetch
;
411 /************************************************************************
412 * OLEClipbrd_IEnumFORMATETC_Skip (IEnumFORMATETC)
414 * Standard enumerator members for IEnumFORMATETC
416 static HRESULT WINAPI
OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface
, ULONG celt
)
418 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
419 TRACE("%p, %lu.\n", iface
, celt
);
422 if (This
->pos
> This
->data
->count
)
424 This
->pos
= This
->data
->count
;
430 /************************************************************************
431 * OLEClipbrd_IEnumFORMATETC_Reset (IEnumFORMATETC)
433 * Standard enumerator members for IEnumFORMATETC
435 static HRESULT WINAPI
OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface
)
437 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
438 TRACE("(%p)->()\n", This
);
444 static HRESULT
enum_fmtetc_construct(ole_priv_data
*data
, UINT pos
, IEnumFORMATETC
**obj
);
446 /************************************************************************
447 * OLEClipbrd_IEnumFORMATETC_Clone (IEnumFORMATETC)
449 * Standard enumerator members for IEnumFORMATETC
451 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone
452 (LPENUMFORMATETC iface
, LPENUMFORMATETC
* obj
)
454 enum_fmtetc
*This
= impl_from_IEnumFORMATETC(iface
);
455 ole_priv_data
*new_data
;
458 TRACE("(%p)->(%p)\n", This
, obj
);
460 if ( !obj
) return E_INVALIDARG
;
463 new_data
= HeapAlloc(GetProcessHeap(), 0, This
->data
->size
);
464 if(!new_data
) return E_OUTOFMEMORY
;
465 memcpy(new_data
, This
->data
, This
->data
->size
);
467 /* Fixup any target device ptrs */
468 for(i
= 0; i
< This
->data
->count
; i
++)
469 new_data
->entries
[i
].fmtetc
.ptd
=
470 td_offs_to_ptr(new_data
, td_get_offs(This
->data
, i
));
472 return enum_fmtetc_construct(new_data
, This
->pos
, obj
);
475 static const IEnumFORMATETCVtbl efvt
=
477 OLEClipbrd_IEnumFORMATETC_QueryInterface
,
478 OLEClipbrd_IEnumFORMATETC_AddRef
,
479 OLEClipbrd_IEnumFORMATETC_Release
,
480 OLEClipbrd_IEnumFORMATETC_Next
,
481 OLEClipbrd_IEnumFORMATETC_Skip
,
482 OLEClipbrd_IEnumFORMATETC_Reset
,
483 OLEClipbrd_IEnumFORMATETC_Clone
486 /************************************************************************
487 * enum_fmtetc_construct
489 * Creates an IEnumFORMATETC enumerator from ole_priv_data which it then owns.
491 static HRESULT
enum_fmtetc_construct(ole_priv_data
*data
, UINT pos
, IEnumFORMATETC
**obj
)
496 ef
= HeapAlloc(GetProcessHeap(), 0, sizeof(*ef
));
497 if (!ef
) return E_OUTOFMEMORY
;
500 ef
->IEnumFORMATETC_iface
.lpVtbl
= &efvt
;
504 TRACE("(%p)->()\n", ef
);
505 *obj
= &ef
->IEnumFORMATETC_iface
;
509 /***********************************************************************
512 * Helper method to duplicate an HGLOBAL chunk of memory
514 static HRESULT
dup_global_mem( HGLOBAL src
, DWORD flags
, HGLOBAL
*dst
)
516 void *src_ptr
, *dst_ptr
;
520 if ( !src
) return S_FALSE
;
522 size
= GlobalSize(src
);
524 *dst
= GlobalAlloc( flags
, size
);
525 if ( !*dst
) return E_OUTOFMEMORY
;
527 src_ptr
= GlobalLock(src
);
528 dst_ptr
= GlobalLock(*dst
);
530 memcpy(dst_ptr
, src_ptr
, size
);
538 /***********************************************************************
541 * Helper function to duplicate a handle to a METAFILEPICT, and the
542 * contained HMETAFILE.
544 static HRESULT
dup_metafilepict(HGLOBAL src
, HGLOBAL
*pdest
)
548 METAFILEPICT
*dest_ptr
;
552 /* Copy the METAFILEPICT structure. */
553 hr
= dup_global_mem(src
, GMEM_DDESHARE
|GMEM_MOVEABLE
, &dest
);
554 if (FAILED(hr
)) return hr
;
556 dest_ptr
= GlobalLock(dest
);
557 if (!dest_ptr
) return E_FAIL
;
559 /* Give the new METAFILEPICT a separate HMETAFILE. */
560 dest_ptr
->hMF
= CopyMetaFileW(dest_ptr
->hMF
, NULL
);
575 /***********************************************************************
578 * Helper function to GlobalFree a handle to a METAFILEPICT, and also
579 * free the contained HMETAFILE.
581 static void free_metafilepict(HGLOBAL src
)
583 METAFILEPICT
*src_ptr
;
585 src_ptr
= GlobalLock(src
);
588 DeleteMetaFile(src_ptr
->hMF
);
594 /***********************************************************************
597 * Helper function to duplicate an HBITMAP.
599 static HRESULT
dup_bitmap(HBITMAP src
, HBITMAP
*pdest
)
602 HGDIOBJ orig_src_bitmap
;
606 src_dc
= CreateCompatibleDC(NULL
);
607 orig_src_bitmap
= SelectObject(src_dc
, src
);
608 GetObjectW(src
, sizeof bm
, &bm
);
609 dest
= CreateCompatibleBitmap(src_dc
, bm
.bmWidth
, bm
.bmHeight
);
612 HDC dest_dc
= CreateCompatibleDC(NULL
);
613 HGDIOBJ orig_dest_bitmap
= SelectObject(dest_dc
, dest
);
614 BitBlt(dest_dc
, 0, 0, bm
.bmWidth
, bm
.bmHeight
, src_dc
, 0, 0, SRCCOPY
);
615 SelectObject(dest_dc
, orig_dest_bitmap
);
618 SelectObject(src_dc
, orig_src_bitmap
);
621 return dest
? S_OK
: E_FAIL
;
624 /************************************************************
625 * render_embed_source_hack
627 * This is clearly a hack and has no place in the clipboard code.
630 static HRESULT
render_embed_source_hack(IDataObject
*data
, LPFORMATETC fmt
)
633 HGLOBAL hStorage
= 0;
635 ILockBytes
*ptrILockBytes
;
637 memset(&std
, 0, sizeof(STGMEDIUM
));
638 std
.tymed
= fmt
->tymed
= TYMED_ISTORAGE
;
640 hStorage
= GlobalAlloc(GMEM_SHARE
|GMEM_MOVEABLE
, 0);
641 if (hStorage
== NULL
) return E_OUTOFMEMORY
;
642 hr
= CreateILockBytesOnHGlobal(hStorage
, FALSE
, &ptrILockBytes
);
645 GlobalFree(hStorage
);
649 hr
= StgCreateDocfileOnILockBytes(ptrILockBytes
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &std
.u
.pstg
);
650 ILockBytes_Release(ptrILockBytes
);
652 if (FAILED(hr
= IDataObject_GetDataHere(theOleClipboard
->src_data
, fmt
, &std
)))
654 WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%lx)\n", hr
);
655 GlobalFree(hStorage
);
659 if (1) /* check whether the presentation data is already -not- present */
663 METAFILEPICT
*mfp
= 0;
665 fmt2
.cfFormat
= CF_METAFILEPICT
;
667 fmt2
.dwAspect
= DVASPECT_CONTENT
;
669 fmt2
.tymed
= TYMED_MFPICT
;
671 memset(&std2
, 0, sizeof(STGMEDIUM
));
672 std2
.tymed
= TYMED_MFPICT
;
674 /* Get the metafile picture out of it */
676 if (SUCCEEDED(hr
= IDataObject_GetData(theOleClipboard
->src_data
, &fmt2
, &std2
)))
678 mfp
= GlobalLock(std2
.u
.hGlobal
);
683 IStream
*pStream
= 0;
685 PresentationDataHeader pdh
;
689 CHAR strOleTypeName
[51];
690 BYTE OlePresStreamHeader
[] =
692 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
693 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
694 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
695 0x00, 0x00, 0x00, 0x00
698 nSize
= GetMetaFileBitsEx(mfp
->hMF
, 0, NULL
);
700 memset(&pdh
, 0, sizeof(PresentationDataHeader
));
701 memcpy(&pdh
, OlePresStreamHeader
, sizeof(OlePresStreamHeader
));
703 pdh
.dwObjectExtentX
= mfp
->xExt
;
704 pdh
.dwObjectExtentY
= mfp
->yExt
;
707 hr
= IStorage_CreateStream(std
.u
.pstg
, L
"\2OlePres000",
708 STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, 0, &pStream
);
710 hr
= IStream_Write(pStream
, &pdh
, sizeof(PresentationDataHeader
), NULL
);
712 mfBits
= HeapAlloc(GetProcessHeap(), 0, nSize
);
713 nSize
= GetMetaFileBitsEx(mfp
->hMF
, nSize
, mfBits
);
715 hr
= IStream_Write(pStream
, mfBits
, nSize
, NULL
);
717 IStream_Release(pStream
);
719 HeapFree(GetProcessHeap(), 0, mfBits
);
721 GlobalUnlock(std2
.u
.hGlobal
);
722 ReleaseStgMedium(&std2
);
724 ReadClassStg(std
.u
.pstg
, &clsID
);
725 ProgIDFromCLSID(&clsID
, &strProgID
);
727 WideCharToMultiByte( CP_ACP
, 0, strProgID
, -1, strOleTypeName
, sizeof(strOleTypeName
), NULL
, NULL
);
728 STORAGE_CreateOleStream(std
.u
.pstg
, 0);
729 OLECONVERT_CreateCompObjStream(std
.u
.pstg
, strOleTypeName
);
730 CoTaskMemFree(strProgID
);
734 if ( !SetClipboardData( fmt
->cfFormat
, hStorage
) )
736 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
737 GlobalFree(hStorage
);
738 hr
= CLIPBRD_E_CANT_SET
;
741 ReleaseStgMedium(&std
);
745 /************************************************************************
746 * find_format_in_list
748 * Returns the first entry that matches the provided clipboard format.
750 static inline ole_priv_data_entry
*find_format_in_list(ole_priv_data_entry
*entries
, DWORD num
, UINT cf
)
753 for(i
= 0; i
< num
; i
++)
754 if(entries
[i
].fmtetc
.cfFormat
== cf
)
760 /***************************************************************************
761 * get_data_from_storage
763 * Returns storage data in an HGLOBAL.
765 static HRESULT
get_data_from_storage(IDataObject
*data
, FORMATETC
*fmt
, HGLOBAL
*mem
)
776 h
= GlobalAlloc( GMEM_DDESHARE
|GMEM_MOVEABLE
, 0 );
777 if(!h
) return E_OUTOFMEMORY
;
779 hr
= CreateILockBytesOnHGlobal(h
, FALSE
, &lbs
);
782 hr
= StgCreateDocfileOnILockBytes(lbs
, STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stg
);
783 ILockBytes_Release(lbs
);
792 med
.tymed
= stg_fmt
.tymed
= TYMED_ISTORAGE
;
794 med
.pUnkForRelease
= NULL
;
796 hr
= IDataObject_GetDataHere(data
, &stg_fmt
, &med
);
799 memset(&med
, 0, sizeof(med
));
800 hr
= IDataObject_GetData(data
, &stg_fmt
, &med
);
801 if(FAILED(hr
)) goto end
;
803 hr
= IStorage_CopyTo(med
.u
.pstg
, 0, NULL
, NULL
, stg
);
804 ReleaseStgMedium(&med
);
805 if(FAILED(hr
)) goto end
;
810 IStorage_Release(stg
);
811 if(FAILED(hr
)) GlobalFree(h
);
815 /***************************************************************************
816 * get_data_from_stream
818 * Returns stream data in an HGLOBAL.
820 static HRESULT
get_data_from_stream(IDataObject
*data
, FORMATETC
*fmt
, HGLOBAL
*mem
)
830 h
= GlobalAlloc( GMEM_DDESHARE
|GMEM_MOVEABLE
, 0 );
831 if(!h
) return E_OUTOFMEMORY
;
833 hr
= CreateStreamOnHGlobal(h
, FALSE
, &stm
);
834 if(FAILED(hr
)) goto error
;
837 med
.tymed
= stm_fmt
.tymed
= TYMED_ISTREAM
;
839 med
.pUnkForRelease
= NULL
;
841 hr
= IDataObject_GetDataHere(data
, &stm_fmt
, &med
);
847 memset(&med
, 0, sizeof(med
));
848 hr
= IDataObject_GetData(data
, &stm_fmt
, &med
);
849 if(FAILED(hr
)) goto error
;
852 IStream_Seek(med
.u
.pstm
, offs
, STREAM_SEEK_END
, &pos
);
853 IStream_Seek(med
.u
.pstm
, offs
, STREAM_SEEK_SET
, NULL
);
854 hr
= IStream_CopyTo(med
.u
.pstm
, stm
, pos
, NULL
, NULL
);
855 ReleaseStgMedium(&med
);
856 if(FAILED(hr
)) goto error
;
859 IStream_Release(stm
);
863 if(stm
) IStream_Release(stm
);
868 /***************************************************************************
869 * get_data_from_global
871 * Returns global data in an HGLOBAL.
873 static HRESULT
get_data_from_global(IDataObject
*data
, FORMATETC
*fmt
, HGLOBAL
*mem
)
883 mem_fmt
.tymed
= TYMED_HGLOBAL
;
884 memset(&med
, 0, sizeof(med
));
886 hr
= IDataObject_GetData(data
, &mem_fmt
, &med
);
887 if(FAILED(hr
)) return hr
;
889 hr
= dup_global_mem(med
.u
.hGlobal
, GMEM_DDESHARE
|GMEM_MOVEABLE
, &h
);
891 if(SUCCEEDED(hr
)) *mem
= h
;
893 ReleaseStgMedium(&med
);
898 /***************************************************************************
899 * get_data_from_enhmetafile
901 static HRESULT
get_data_from_enhmetafile(IDataObject
*data
, FORMATETC
*fmt
, HGLOBAL
*mem
)
911 mem_fmt
.tymed
= TYMED_ENHMF
;
912 memset(&med
, 0, sizeof(med
));
914 hr
= IDataObject_GetData(data
, &mem_fmt
, &med
);
915 if(FAILED(hr
)) return hr
;
917 copy
= CopyEnhMetaFileW(med
.u
.hEnhMetaFile
, NULL
);
918 if(copy
) *mem
= (HGLOBAL
)copy
;
921 ReleaseStgMedium(&med
);
926 /***************************************************************************
927 * get_data_from_metafilepict
929 static HRESULT
get_data_from_metafilepict(IDataObject
*data
, FORMATETC
*fmt
, HGLOBAL
*mem
)
939 mem_fmt
.tymed
= TYMED_MFPICT
;
940 memset(&med
, 0, sizeof(med
));
942 hr
= IDataObject_GetData(data
, &mem_fmt
, &med
);
943 if(FAILED(hr
)) return hr
;
945 hr
= dup_metafilepict(med
.u
.hMetaFilePict
, ©
);
947 if(SUCCEEDED(hr
)) *mem
= copy
;
949 ReleaseStgMedium(&med
);
954 /***************************************************************************
955 * get_data_from_bitmap
957 * Returns bitmap in an HBITMAP.
959 static HRESULT
get_data_from_bitmap(IDataObject
*data
, FORMATETC
*fmt
, HBITMAP
*hbm
)
969 mem_fmt
.tymed
= TYMED_GDI
;
970 memset(&med
, 0, sizeof(med
));
972 hr
= IDataObject_GetData(data
, &mem_fmt
, &med
);
973 if(FAILED(hr
)) return hr
;
975 hr
= dup_bitmap(med
.u
.hBitmap
, ©
);
977 if(SUCCEEDED(hr
)) *hbm
= copy
;
979 ReleaseStgMedium(&med
);
984 /***********************************************************************
987 * Render the clipboard data. Note that this call will delegate to the
988 * source data object.
990 static HRESULT
render_format(IDataObject
*data
, LPFORMATETC fmt
)
992 HANDLE clip_data
= NULL
; /* HGLOBAL unless otherwise specified */
995 /* Embed source hack */
996 if(fmt
->cfFormat
== embed_source_clipboard_format
)
998 return render_embed_source_hack(data
, fmt
);
1001 if(fmt
->tymed
& TYMED_ISTORAGE
)
1003 hr
= get_data_from_storage(data
, fmt
, &clip_data
);
1005 else if(fmt
->tymed
& TYMED_ISTREAM
)
1007 hr
= get_data_from_stream(data
, fmt
, &clip_data
);
1009 else if(fmt
->tymed
& TYMED_HGLOBAL
)
1011 hr
= get_data_from_global(data
, fmt
, &clip_data
);
1013 else if(fmt
->tymed
& TYMED_ENHMF
)
1015 hr
= get_data_from_enhmetafile(data
, fmt
, &clip_data
);
1017 else if(fmt
->tymed
& TYMED_MFPICT
)
1019 /* Returns global handle to METAFILEPICT, containing a copied HMETAFILE */
1020 hr
= get_data_from_metafilepict(data
, fmt
, &clip_data
);
1022 else if(fmt
->tymed
& TYMED_GDI
)
1024 /* Returns HBITMAP not HGLOBAL */
1025 hr
= get_data_from_bitmap(data
, fmt
, (HBITMAP
*)&clip_data
);
1029 FIXME("Unhandled tymed %lx\n", fmt
->tymed
);
1030 hr
= DV_E_FORMATETC
;
1035 if ( !SetClipboardData(fmt
->cfFormat
, clip_data
) )
1037 WARN("() : Failed to set rendered clipboard data into clipboard!\n");
1038 if(fmt
->tymed
& TYMED_MFPICT
)
1039 free_metafilepict(clip_data
);
1040 else if(fmt
->tymed
& TYMED_GDI
)
1041 DeleteObject(clip_data
);
1043 GlobalFree(clip_data
);
1044 hr
= CLIPBRD_E_CANT_SET
;
1051 /*---------------------------------------------------------------------*
1052 * Implementation of the internal IDataObject interface exposed by
1053 * the OLE clipboard.
1054 *---------------------------------------------------------------------*/
1057 /************************************************************************
1058 * snapshot_QueryInterface
1060 static HRESULT WINAPI
snapshot_QueryInterface(IDataObject
*iface
,
1061 REFIID riid
, void **ppvObject
)
1063 snapshot
*This
= impl_from_IDataObject(iface
);
1064 TRACE("(%p)->(IID:%s, %p)\n", This
, debugstr_guid(riid
), ppvObject
);
1066 if ( (This
==0) || (ppvObject
==0) )
1067 return E_INVALIDARG
;
1071 if (IsEqualIID(&IID_IUnknown
, riid
) ||
1072 IsEqualIID(&IID_IDataObject
, riid
))
1078 WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid
));
1079 return E_NOINTERFACE
;
1082 IUnknown_AddRef((IUnknown
*)*ppvObject
);
1087 /************************************************************************
1090 static ULONG WINAPI
snapshot_AddRef(IDataObject
*iface
)
1092 snapshot
*This
= impl_from_IDataObject(iface
);
1093 ULONG ref
= InterlockedIncrement(&This
->ref
);
1095 TRACE("%p, refcount %lu.\n", iface
, ref
);
1100 /************************************************************************
1103 static ULONG WINAPI
snapshot_Release(IDataObject
*iface
)
1105 snapshot
*This
= impl_from_IDataObject(iface
);
1106 ULONG ref
= InterlockedDecrement(&This
->ref
);
1108 TRACE("%p, refcount %lu.\n", iface
, ref
);
1112 EnterCriticalSection(&latest_snapshot_cs
);
1115 LeaveCriticalSection(&latest_snapshot_cs
);
1118 if (theOleClipboard
->latest_snapshot
== This
)
1119 theOleClipboard
->latest_snapshot
= NULL
;
1120 LeaveCriticalSection(&latest_snapshot_cs
);
1122 if(This
->data
) IDataObject_Release(This
->data
);
1123 HeapFree(GetProcessHeap(), 0, This
);
1129 /************************************************************
1130 * get_current_ole_clip_window
1132 * Return the window that owns the ole clipboard.
1134 * If the clipboard is flushed or not owned by ole this will
1137 static HWND
get_current_ole_clip_window(void)
1142 h
= GetClipboardData(dataobject_clipboard_format
);
1144 ptr
= GlobalLock(h
);
1145 if(!ptr
) return NULL
;
1151 /************************************************************
1152 * get_current_dataobject
1154 * Return an unmarshalled IDataObject if there is a current
1155 * (ie non-flushed) object on the ole clipboard.
1157 static HRESULT
get_current_dataobject(IDataObject
**data
)
1159 HRESULT hr
= S_FALSE
;
1160 HWND wnd
= get_current_ole_clip_window();
1167 if(!wnd
) return S_FALSE
;
1169 h
= GetClipboardData(wine_marshal_clipboard_format
);
1170 if(!h
) return S_FALSE
;
1171 if(GlobalSize(h
) <= 1) return S_FALSE
;
1172 ptr
= GlobalLock(h
);
1173 if(!ptr
) return S_FALSE
;
1175 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &stm
);
1176 if(FAILED(hr
)) goto end
;
1178 hr
= IStream_Write(stm
, ptr
, GlobalSize(h
), NULL
);
1182 IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, NULL
);
1183 hr
= CoUnmarshalInterface(stm
, &IID_IDataObject
, (void**)data
);
1185 IStream_Release(stm
);
1192 static DWORD
get_tymed_from_nonole_cf(UINT cf
)
1194 if(cf
>= 0xc000) return TYMED_ISTREAM
| TYMED_HGLOBAL
;
1200 case CF_UNICODETEXT
:
1202 return TYMED_ISTREAM
| TYMED_HGLOBAL
;
1203 case CF_ENHMETAFILE
:
1205 case CF_METAFILEPICT
:
1206 return TYMED_MFPICT
;
1210 FIXME("returning TYMED_NULL for cf %04x\n", cf
);
1215 /***********************************************************
1218 * Returns a copy of the Ole Private Data
1220 static HRESULT
get_priv_data(ole_priv_data
**data
)
1224 ole_priv_data
*ret
= NULL
;
1228 handle
= GetClipboardData( ole_private_data_clipboard_format
);
1231 ole_priv_data
*src
= GlobalLock(handle
);
1236 /* FIXME: sanity check on size */
1237 ret
= HeapAlloc(GetProcessHeap(), 0, src
->size
);
1240 GlobalUnlock(handle
);
1241 return E_OUTOFMEMORY
;
1243 memcpy(ret
, src
, src
->size
);
1244 GlobalUnlock(handle
);
1246 /* Fixup any target device offsets to ptrs */
1247 for(i
= 0; i
< ret
->count
; i
++)
1248 ret
->entries
[i
].fmtetc
.ptd
=
1249 td_offs_to_ptr(ret
, (DWORD_PTR
) ret
->entries
[i
].fmtetc
.ptd
);
1253 if(!ret
) /* Non-ole data */
1256 DWORD count
= 0, idx
, size
= FIELD_OFFSET(ole_priv_data
, entries
);
1258 for(cf
= 0; (cf
= EnumClipboardFormats(cf
)) != 0; count
++)
1261 if (GetClipboardFormatNameW(cf
, buf
, ARRAY_SIZE(buf
)))
1262 TRACE("cf %04x %s\n", cf
, debugstr_w(buf
));
1264 TRACE("cf %04x\n", cf
);
1266 TRACE("count %ld\n", count
);
1267 size
+= count
* sizeof(ret
->entries
[0]);
1269 /* There are holes in fmtetc so zero init */
1270 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
1271 if(!ret
) return E_OUTOFMEMORY
;
1275 for(cf
= 0, idx
= 0; (cf
= EnumClipboardFormats(cf
)) != 0; idx
++)
1277 ret
->entries
[idx
].fmtetc
.cfFormat
= cf
;
1278 ret
->entries
[idx
].fmtetc
.ptd
= NULL
;
1279 ret
->entries
[idx
].fmtetc
.dwAspect
= DVASPECT_CONTENT
;
1280 ret
->entries
[idx
].fmtetc
.lindex
= -1;
1281 ret
->entries
[idx
].fmtetc
.tymed
= get_tymed_from_nonole_cf(cf
);
1282 ret
->entries
[idx
].first_use
= 1;
1290 /************************************************************************
1291 * get_stgmed_for_global
1293 * Returns a stg medium with a copy of the global handle
1295 static HRESULT
get_stgmed_for_global(HGLOBAL h
, STGMEDIUM
*med
)
1299 med
->pUnkForRelease
= NULL
;
1300 med
->tymed
= TYMED_NULL
;
1302 hr
= dup_global_mem(h
, GMEM_MOVEABLE
, &med
->u
.hGlobal
);
1304 if(SUCCEEDED(hr
)) med
->tymed
= TYMED_HGLOBAL
;
1309 /************************************************************************
1310 * get_stgmed_for_stream
1312 * Returns a stg medium with a stream based on the handle
1314 static HRESULT
get_stgmed_for_stream(HGLOBAL h
, STGMEDIUM
*med
)
1319 med
->pUnkForRelease
= NULL
;
1320 med
->tymed
= TYMED_NULL
;
1322 hr
= dup_global_mem(h
, GMEM_MOVEABLE
, &dst
);
1323 if(FAILED(hr
)) return hr
;
1325 hr
= CreateStreamOnHGlobal(dst
, TRUE
, &med
->u
.pstm
);
1332 med
->tymed
= TYMED_ISTREAM
;
1336 /************************************************************************
1337 * get_stgmed_for_storage
1339 * Returns a stg medium with a storage based on the handle
1341 static HRESULT
get_stgmed_for_storage(HGLOBAL h
, STGMEDIUM
*med
)
1347 med
->pUnkForRelease
= NULL
;
1348 med
->tymed
= TYMED_NULL
;
1350 hr
= dup_global_mem(h
, GMEM_MOVEABLE
, &dst
);
1351 if(FAILED(hr
)) return hr
;
1353 hr
= CreateILockBytesOnHGlobal(dst
, TRUE
, &lbs
);
1360 hr
= StgIsStorageILockBytes(lbs
);
1363 ILockBytes_Release(lbs
);
1365 return SUCCEEDED(hr
) ? E_FAIL
: hr
;
1368 hr
= StgOpenStorageOnILockBytes(lbs
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &med
->u
.pstg
);
1369 ILockBytes_Release(lbs
);
1376 med
->tymed
= TYMED_ISTORAGE
;
1380 /************************************************************************
1381 * get_stgmed_for_emf
1383 * Returns a stg medium with an enhanced metafile based on the handle
1385 static HRESULT
get_stgmed_for_emf(HENHMETAFILE hemf
, STGMEDIUM
*med
)
1387 med
->pUnkForRelease
= NULL
;
1388 med
->tymed
= TYMED_NULL
;
1390 med
->u
.hEnhMetaFile
= CopyEnhMetaFileW(hemf
, NULL
);
1391 if(!med
->u
.hEnhMetaFile
) return E_OUTOFMEMORY
;
1392 med
->tymed
= TYMED_ENHMF
;
1396 /************************************************************************
1397 * get_stgmed_for_bitmap
1399 * Returns a stg medium with a bitmap based on the handle
1401 static HRESULT
get_stgmed_for_bitmap(HBITMAP hbmp
, STGMEDIUM
*med
)
1405 med
->pUnkForRelease
= NULL
;
1406 med
->tymed
= TYMED_NULL
;
1408 hr
= dup_bitmap(hbmp
, &med
->u
.hBitmap
);
1413 med
->tymed
= TYMED_GDI
;
1417 static inline BOOL
string_off_equal(const DVTARGETDEVICE
*t1
, WORD off1
, const DVTARGETDEVICE
*t2
, WORD off2
)
1419 const WCHAR
*str1
, *str2
;
1421 if(off1
== 0 && off2
== 0) return TRUE
;
1422 if(off1
== 0 || off2
== 0) return FALSE
;
1424 str1
= (const WCHAR
*)((const char*)t1
+ off1
);
1425 str2
= (const WCHAR
*)((const char*)t2
+ off2
);
1427 return !wcscmp(str1
, str2
);
1430 static inline BOOL
td_equal(const DVTARGETDEVICE
*t1
, const DVTARGETDEVICE
*t2
)
1432 if(t1
== NULL
&& t2
== NULL
) return TRUE
;
1433 if(t1
== NULL
|| t2
== NULL
) return FALSE
;
1435 if(!string_off_equal(t1
, t1
->tdDriverNameOffset
, t2
, t2
->tdDriverNameOffset
))
1437 if(!string_off_equal(t1
, t1
->tdDeviceNameOffset
, t2
, t2
->tdDeviceNameOffset
))
1439 if(!string_off_equal(t1
, t1
->tdPortNameOffset
, t2
, t2
->tdPortNameOffset
))
1442 /* FIXME check devmode? */
1447 /************************************************************************
1450 static HRESULT WINAPI
snapshot_GetData(IDataObject
*iface
, FORMATETC
*fmt
,
1453 snapshot
*This
= impl_from_IDataObject(iface
);
1456 ole_priv_data
*enum_data
= NULL
;
1457 ole_priv_data_entry
*entry
;
1460 TRACE("(%p, %p {%s}, %p)\n", iface
, fmt
, dump_fmtetc(fmt
), med
);
1462 if ( !fmt
|| !med
) return E_INVALIDARG
;
1464 memset(med
, 0, sizeof(*med
));
1466 if ( !OpenClipboard(NULL
)) return CLIPBRD_E_CANT_OPEN
;
1469 hr
= get_current_dataobject(&This
->data
);
1473 hr
= IDataObject_GetData(This
->data
, fmt
, med
);
1480 if(fmt
->lindex
!= -1)
1482 hr
= DV_E_FORMATETC
;
1486 if(!IsClipboardFormatAvailable(fmt
->cfFormat
))
1488 hr
= DV_E_FORMATETC
;
1492 hr
= get_priv_data(&enum_data
);
1493 if(FAILED(hr
)) goto end
;
1495 entry
= find_format_in_list(enum_data
->entries
, enum_data
->count
, fmt
->cfFormat
);
1498 if(!td_equal(fmt
->ptd
, entry
->fmtetc
.ptd
))
1500 hr
= DV_E_FORMATETC
;
1503 mask
= fmt
->tymed
& entry
->fmtetc
.tymed
;
1504 if(!mask
&& (entry
->fmtetc
.tymed
& (TYMED_ISTREAM
| TYMED_HGLOBAL
| TYMED_ISTORAGE
)))
1505 mask
= fmt
->tymed
& (TYMED_ISTREAM
| TYMED_HGLOBAL
| TYMED_ISTORAGE
);
1507 else /* non-Ole format */
1508 mask
= fmt
->tymed
& get_tymed_from_nonole_cf(fmt
->cfFormat
);
1516 h
= GetClipboardData(fmt
->cfFormat
);
1519 hr
= DV_E_FORMATETC
;
1523 if(mask
& TYMED_HGLOBAL
)
1524 hr
= get_stgmed_for_global(h
, med
);
1525 else if(mask
& TYMED_ISTREAM
)
1526 hr
= get_stgmed_for_stream(h
, med
);
1527 else if(mask
& TYMED_ISTORAGE
)
1528 hr
= get_stgmed_for_storage(h
, med
);
1529 else if(mask
& TYMED_ENHMF
)
1530 hr
= get_stgmed_for_emf((HENHMETAFILE
)h
, med
);
1531 else if(mask
& TYMED_GDI
)
1532 hr
= get_stgmed_for_bitmap((HBITMAP
)h
, med
);
1535 FIXME("Unhandled tymed - mask %lx req tymed %lx\n", mask
, fmt
->tymed
);
1541 HeapFree(GetProcessHeap(), 0, enum_data
);
1542 if ( !CloseClipboard() ) hr
= CLIPBRD_E_CANT_CLOSE
;
1546 /************************************************************************
1547 * snapshot_GetDataHere
1549 static HRESULT WINAPI
snapshot_GetDataHere(IDataObject
*iface
, FORMATETC
*fmt
,
1552 snapshot
*This
= impl_from_IDataObject(iface
);
1555 ole_priv_data
*enum_data
= NULL
;
1556 ole_priv_data_entry
*entry
;
1559 if ( !fmt
|| !med
) return E_INVALIDARG
;
1561 TRACE("%p, %p {%s}, %p (tymed %lx)\n", iface
, fmt
, dump_fmtetc(fmt
), med
, med
->tymed
);
1563 if ( !OpenClipboard(NULL
)) return CLIPBRD_E_CANT_OPEN
;
1566 hr
= get_current_dataobject(&This
->data
);
1570 hr
= IDataObject_GetDataHere(This
->data
, fmt
, med
);
1578 h
= GetClipboardData(fmt
->cfFormat
);
1581 hr
= DV_E_FORMATETC
;
1585 hr
= get_priv_data(&enum_data
);
1586 if(FAILED(hr
)) goto end
;
1588 entry
= find_format_in_list(enum_data
->entries
, enum_data
->count
, fmt
->cfFormat
);
1591 if(!td_equal(fmt
->ptd
, entry
->fmtetc
.ptd
))
1593 hr
= DV_E_FORMATETC
;
1596 supported
= entry
->fmtetc
.tymed
;
1598 else /* non-Ole format */
1599 supported
= TYMED_HGLOBAL
;
1605 DWORD src_size
= GlobalSize(h
);
1606 DWORD dst_size
= GlobalSize(med
->u
.hGlobal
);
1608 if(dst_size
>= src_size
)
1610 void *src
= GlobalLock(h
);
1611 void *dst
= GlobalLock(med
->u
.hGlobal
);
1613 memcpy(dst
, src
, src_size
);
1614 GlobalUnlock(med
->u
.hGlobal
);
1622 DWORD src_size
= GlobalSize(h
);
1623 void *src
= GlobalLock(h
);
1624 hr
= IStream_Write(med
->u
.pstm
, src
, src_size
, NULL
);
1628 case TYMED_ISTORAGE
:
1631 if(!(supported
& TYMED_ISTORAGE
))
1636 hr
= get_stgmed_for_storage(h
, ©
);
1639 hr
= IStorage_CopyTo(copy
.u
.pstg
, 0, NULL
, NULL
, med
->u
.pstg
);
1640 ReleaseStgMedium(©
);
1645 FIXME("Unhandled tymed - supported %x req tymed %lx\n", supported
, med
->tymed
);
1651 HeapFree(GetProcessHeap(), 0, enum_data
);
1652 if ( !CloseClipboard() ) hr
= CLIPBRD_E_CANT_CLOSE
;
1656 /************************************************************************
1657 * snapshot_QueryGetData
1659 * The OLE Clipboard's implementation of this method delegates to
1660 * a data source if there is one or wraps around the windows clipboard
1661 * function IsClipboardFormatAvailable() otherwise.
1664 static HRESULT WINAPI
snapshot_QueryGetData(IDataObject
*iface
, FORMATETC
*fmt
)
1666 TRACE("(%p, %p {%s})\n", iface
, fmt
, dump_fmtetc(fmt
));
1668 if (!fmt
) return E_INVALIDARG
;
1670 if ( fmt
->dwAspect
!= DVASPECT_CONTENT
) return DV_E_FORMATETC
;
1672 if ( fmt
->lindex
!= -1 ) return DV_E_FORMATETC
;
1674 return (IsClipboardFormatAvailable(fmt
->cfFormat
)) ? S_OK
: DV_E_CLIPFORMAT
;
1677 /************************************************************************
1678 * snapshot_GetCanonicalFormatEtc
1680 static HRESULT WINAPI
snapshot_GetCanonicalFormatEtc(IDataObject
*iface
, FORMATETC
*fmt_in
,
1683 TRACE("(%p, %p, %p)\n", iface
, fmt_in
, fmt_out
);
1685 if ( !fmt_in
|| !fmt_out
) return E_INVALIDARG
;
1688 return DATA_S_SAMEFORMATETC
;
1691 /************************************************************************
1694 * The OLE Clipboard does not implement this method
1696 static HRESULT WINAPI
snapshot_SetData(IDataObject
*iface
, FORMATETC
*fmt
,
1697 STGMEDIUM
*med
, BOOL release
)
1699 TRACE("(%p, %p, %p, %d): not implemented\n", iface
, fmt
, med
, release
);
1703 /************************************************************************
1704 * snapshot_EnumFormatEtc
1707 static HRESULT WINAPI
snapshot_EnumFormatEtc(IDataObject
*iface
, DWORD dir
,
1708 IEnumFORMATETC
**enum_fmt
)
1711 ole_priv_data
*data
= NULL
;
1713 TRACE("%p, %lx, %p.\n", iface
, dir
, enum_fmt
);
1717 if ( dir
!= DATADIR_GET
) return E_NOTIMPL
;
1718 if ( !OpenClipboard(NULL
) ) return CLIPBRD_E_CANT_OPEN
;
1720 hr
= get_priv_data(&data
);
1722 if(FAILED(hr
)) goto end
;
1724 hr
= enum_fmtetc_construct( data
, 0, enum_fmt
);
1727 if ( !CloseClipboard() ) hr
= CLIPBRD_E_CANT_CLOSE
;
1731 /************************************************************************
1734 * The OLE Clipboard does not implement this method
1736 static HRESULT WINAPI
snapshot_DAdvise(IDataObject
*iface
, FORMATETC
*fmt
,
1737 DWORD flags
, IAdviseSink
*sink
,
1740 TRACE("%p, %p, %lx, %p, %p.\n", iface
, fmt
, flags
, sink
, conn
);
1744 /************************************************************************
1745 * snapshot_DUnadvise
1747 * The OLE Clipboard does not implement this method
1749 static HRESULT WINAPI
snapshot_DUnadvise(IDataObject
* iface
, DWORD conn
)
1751 TRACE("%p, %ld.\n", iface
, conn
);
1755 /************************************************************************
1756 * snapshot_EnumDAdvise
1758 * The OLE Clipboard does not implement this method
1760 static HRESULT WINAPI
snapshot_EnumDAdvise(IDataObject
* iface
,
1761 IEnumSTATDATA
** enum_advise
)
1763 TRACE("(%p, %p): not implemented\n", iface
, enum_advise
);
1767 static const IDataObjectVtbl snapshot_vtable
=
1769 snapshot_QueryInterface
,
1773 snapshot_GetDataHere
,
1774 snapshot_QueryGetData
,
1775 snapshot_GetCanonicalFormatEtc
,
1777 snapshot_EnumFormatEtc
,
1780 snapshot_EnumDAdvise
1783 /*---------------------------------------------------------------------*
1784 * Internal implementation methods for the OLE clipboard
1785 *---------------------------------------------------------------------*/
1787 static snapshot
*snapshot_construct(DWORD seq_no
)
1791 This
= HeapAlloc( GetProcessHeap(), 0, sizeof(*This
) );
1792 if (!This
) return NULL
;
1794 This
->IDataObject_iface
.lpVtbl
= &snapshot_vtable
;
1796 This
->seq_no
= seq_no
;
1802 /*********************************************************************
1803 * set_clipboard_formats
1805 * Enumerate all formats supported by the source and make
1806 * those formats available using delayed rendering using SetClipboardData.
1807 * Cache the enumeration list and make that list visible as the
1808 * 'Ole Private Data' format on the clipboard.
1811 static HRESULT
set_clipboard_formats(ole_clipbrd
*clipbrd
, IDataObject
*data
)
1815 IEnumFORMATETC
*enum_fmt
;
1816 HGLOBAL priv_data_handle
;
1817 DWORD_PTR target_offset
;
1818 ole_priv_data
*priv_data
;
1819 DWORD count
= 0, needed
= sizeof(*priv_data
), idx
;
1821 hr
= IDataObject_EnumFormatEtc(data
, DATADIR_GET
, &enum_fmt
);
1822 if(FAILED(hr
)) return hr
;
1824 while(IEnumFORMATETC_Next(enum_fmt
, 1, &fmt
, NULL
) == S_OK
)
1827 needed
+= sizeof(priv_data
->entries
[0]);
1830 needed
+= fmt
.ptd
->tdSize
;
1831 CoTaskMemFree(fmt
.ptd
);
1835 /* Windows pads the list with two empty ole_priv_data_entries, one
1836 * after the entries array and one after the target device data.
1837 * Allocating with zero init to zero these pads. */
1839 needed
+= sizeof(priv_data
->entries
[0]); /* initialisation of needed includes one of these. */
1840 priv_data_handle
= GlobalAlloc(GMEM_DDESHARE
| GMEM_MOVEABLE
| GMEM_ZEROINIT
, needed
);
1841 priv_data
= GlobalLock(priv_data_handle
);
1843 priv_data
->unk1
= 0;
1844 priv_data
->size
= needed
;
1845 priv_data
->unk2
= 1;
1846 priv_data
->count
= count
;
1847 priv_data
->unk3
[0] = 0;
1848 priv_data
->unk3
[1] = 0;
1850 IEnumFORMATETC_Reset(enum_fmt
);
1853 target_offset
= FIELD_OFFSET(ole_priv_data
, entries
[count
+ 1]); /* count entries + one pad. */
1855 while(IEnumFORMATETC_Next(enum_fmt
, 1, &fmt
, NULL
) == S_OK
)
1857 TRACE("%s\n", dump_fmtetc(&fmt
));
1859 priv_data
->entries
[idx
].fmtetc
= fmt
;
1862 memcpy((char*)priv_data
+ target_offset
, fmt
.ptd
, fmt
.ptd
->tdSize
);
1863 priv_data
->entries
[idx
].fmtetc
.ptd
= (DVTARGETDEVICE
*)target_offset
;
1864 target_offset
+= fmt
.ptd
->tdSize
;
1865 CoTaskMemFree(fmt
.ptd
);
1868 priv_data
->entries
[idx
].first_use
= !find_format_in_list(priv_data
->entries
, idx
, fmt
.cfFormat
);
1869 priv_data
->entries
[idx
].unk
[0] = 0;
1870 priv_data
->entries
[idx
].unk
[1] = 0;
1872 if (priv_data
->entries
[idx
].first_use
)
1873 SetClipboardData(fmt
.cfFormat
, NULL
);
1878 IEnumFORMATETC_Release(enum_fmt
);
1880 /* Cache the list and fixup any target device offsets to ptrs */
1881 clipbrd
->cached_enum
= HeapAlloc(GetProcessHeap(), 0, needed
);
1882 memcpy(clipbrd
->cached_enum
, priv_data
, needed
);
1883 for(idx
= 0; idx
< clipbrd
->cached_enum
->count
; idx
++)
1884 clipbrd
->cached_enum
->entries
[idx
].fmtetc
.ptd
=
1885 td_offs_to_ptr(clipbrd
->cached_enum
, (DWORD_PTR
)clipbrd
->cached_enum
->entries
[idx
].fmtetc
.ptd
);
1887 GlobalUnlock(priv_data_handle
);
1888 if(!SetClipboardData(ole_private_data_clipboard_format
, priv_data_handle
))
1890 GlobalFree(priv_data_handle
);
1891 return CLIPBRD_E_CANT_SET
;
1897 static HWND
create_clipbrd_window(void);
1899 /***********************************************************************
1900 * get_clipbrd_window
1902 static inline HRESULT
get_clipbrd_window(ole_clipbrd
*clipbrd
, HWND
*wnd
)
1904 if ( !clipbrd
->window
)
1905 clipbrd
->window
= create_clipbrd_window();
1907 *wnd
= clipbrd
->window
;
1908 return *wnd
? S_OK
: E_FAIL
;
1912 /**********************************************************************
1913 * release_marshal_data
1915 * Releases the data and sets the stream back to zero size.
1917 static inline void release_marshal_data(IStream
*stm
)
1920 ULARGE_INTEGER size
;
1921 pos
.QuadPart
= size
.QuadPart
= 0;
1923 IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, NULL
);
1924 CoReleaseMarshalData(stm
);
1925 IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, NULL
);
1926 IStream_SetSize(stm
, size
);
1929 /***********************************************************************
1930 * expose_marshalled_dataobject
1932 * Sets the marshalled dataobject to the clipboard. In the flushed case
1933 * we set a zero sized HGLOBAL to clear the old marshalled data.
1935 static HRESULT
expose_marshalled_dataobject(ole_clipbrd
*clipbrd
, IDataObject
*data
)
1942 GetHGlobalFromStream(clipbrd
->marshal_data
, &h_stm
);
1943 dup_global_mem(h_stm
, GMEM_DDESHARE
|GMEM_MOVEABLE
, &h
);
1946 h
= GlobalAlloc(GMEM_DDESHARE
|GMEM_MOVEABLE
, 1);
1948 if(!h
) return E_OUTOFMEMORY
;
1950 if(!SetClipboardData(wine_marshal_clipboard_format
, h
))
1953 return CLIPBRD_E_CANT_SET
;
1958 /***********************************************************************
1959 * set_src_dataobject
1961 * Clears and sets the clipboard's src IDataObject.
1963 * To marshal the source dataobject we do something rather different from Windows.
1964 * We set a clipboard format which contains the marshalled data.
1965 * Windows sets two window props one of which is an IID, the other is an endpoint number.
1967 static HRESULT
set_src_dataobject(ole_clipbrd
*clipbrd
, IDataObject
*data
)
1972 if(FAILED(hr
= get_clipbrd_window(clipbrd
, &wnd
))) return hr
;
1974 if(clipbrd
->src_data
)
1976 release_marshal_data(clipbrd
->marshal_data
);
1978 IDataObject_Release(clipbrd
->src_data
);
1979 clipbrd
->src_data
= NULL
;
1980 HeapFree(GetProcessHeap(), 0, clipbrd
->cached_enum
);
1981 clipbrd
->cached_enum
= NULL
;
1988 IDataObject_AddRef(data
);
1989 clipbrd
->src_data
= data
;
1991 IDataObject_QueryInterface(data
, &IID_IUnknown
, (void**)&unk
);
1992 hr
= CoMarshalInterface(clipbrd
->marshal_data
, &IID_IDataObject
, unk
,
1993 MSHCTX_LOCAL
, NULL
, MSHLFLAGS_TABLESTRONG
);
1994 IUnknown_Release(unk
); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
1995 if(FAILED(hr
)) return hr
;
1996 hr
= set_clipboard_formats(clipbrd
, data
);
2001 /***********************************************************************
2002 * clipbrd_uninitialize()
2003 * Un-Initializes the OLE clipboard
2005 void clipbrd_uninitialize(void)
2007 ole_clipbrd
*clipbrd
= theOleClipboard
;
2013 /* OleUninitialize() does not release the reference to the dataobject, so
2014 take an additional reference here. This reference is then leaked. */
2015 if (clipbrd
->src_data
)
2017 IDataObject_AddRef(clipbrd
->src_data
);
2018 set_src_dataobject(clipbrd
, NULL
);
2021 if ( clipbrd
->window
)
2023 DestroyWindow(clipbrd
->window
);
2024 UnregisterClassW( clipbrd_wndclass
, GetModuleHandleW(L
"ole32") );
2025 clipbrd
->window
= NULL
;
2030 /***********************************************************************
2032 * Destroy the OLE clipboard
2034 void clipbrd_destroy(void)
2036 ole_clipbrd
*clipbrd
= theOleClipboard
;
2038 if (!clipbrd
) return;
2040 clipbrd_uninitialize();
2042 IStream_Release(clipbrd
->marshal_data
);
2043 HeapFree(GetProcessHeap(), 0, clipbrd
);
2044 theOleClipboard
= NULL
;
2047 /***********************************************************************
2050 static LRESULT CALLBACK
clipbrd_wndproc(HWND hwnd
, UINT message
, WPARAM wparam
, LPARAM lparam
)
2052 ole_clipbrd
*clipbrd
;
2054 get_ole_clipbrd(&clipbrd
);
2058 case WM_RENDERFORMAT
:
2061 ole_priv_data_entry
*entry
;
2063 TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf
);
2065 if (!clipbrd
|| !clipbrd
->cached_enum
) break;
2066 entry
= find_format_in_list(clipbrd
->cached_enum
->entries
, clipbrd
->cached_enum
->count
, cf
);
2069 render_format(clipbrd
->src_data
, &entry
->fmtetc
);
2074 case WM_RENDERALLFORMATS
:
2077 ole_priv_data_entry
*entries
;
2079 TRACE("(): WM_RENDERALLFORMATS\n");
2081 if (!clipbrd
|| !clipbrd
->cached_enum
) break;
2082 entries
= clipbrd
->cached_enum
->entries
;
2083 for(i
= 0; i
< clipbrd
->cached_enum
->count
; i
++)
2085 if(entries
[i
].first_use
)
2086 render_format(clipbrd
->src_data
, &entries
[i
].fmtetc
);
2091 case WM_DESTROYCLIPBOARD
:
2093 TRACE("(): WM_DESTROYCLIPBOARD\n");
2095 set_src_dataobject(clipbrd
, NULL
);
2100 return DefWindowProcW(hwnd
, message
, wparam
, lparam
);
2107 /***********************************************************************
2108 * create_clipbrd_window
2110 static HWND
create_clipbrd_window(void)
2113 HINSTANCE hinst
= GetModuleHandleW(L
"ole32");
2115 class.cbSize
= sizeof(class);
2117 class.lpfnWndProc
= clipbrd_wndproc
;
2118 class.cbClsExtra
= 0;
2119 class.cbWndExtra
= 0;
2120 class.hInstance
= hinst
;
2123 class.hbrBackground
= 0;
2124 class.lpszMenuName
= NULL
;
2125 class.lpszClassName
= clipbrd_wndclass
;
2126 class.hIconSm
= NULL
;
2128 RegisterClassExW(&class);
2130 return CreateWindowW(clipbrd_wndclass
, L
"ClipboardWindow", WS_POPUP
| WS_CLIPSIBLINGS
| WS_OVERLAPPED
,
2131 0, 0, 0, 0, HWND_MESSAGE
, NULL
, hinst
, 0);
2134 /*********************************************************************
2135 * set_dataobject_format
2137 * Windows creates a 'DataObject' clipboard format that contains the
2138 * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
2140 static HRESULT
set_dataobject_format(HWND hwnd
)
2142 HGLOBAL h
= GlobalAlloc(GMEM_DDESHARE
| GMEM_MOVEABLE
, sizeof(hwnd
));
2145 if(!h
) return E_OUTOFMEMORY
;
2147 data
= GlobalLock(h
);
2151 if(!SetClipboardData(dataobject_clipboard_format
, h
))
2154 return CLIPBRD_E_CANT_SET
;
2160 /*---------------------------------------------------------------------*
2161 * Win32 OLE clipboard API
2162 *---------------------------------------------------------------------*/
2164 /***********************************************************************
2165 * OleSetClipboard [OLE32.@]
2166 * Places a pointer to the specified data object onto the clipboard,
2167 * making the data object accessible to the OleGetClipboard function.
2171 * S_OK IDataObject pointer placed on the clipboard
2172 * CLIPBRD_E_CANT_OPEN OpenClipboard failed
2173 * CLIPBRD_E_CANT_EMPTY EmptyClipboard failed
2174 * CLIPBRD_E_CANT_CLOSE CloseClipboard failed
2175 * CLIPBRD_E_CANT_SET SetClipboard failed
2178 HRESULT WINAPI
OleSetClipboard(IDataObject
* data
)
2180 struct oletls
*info
= COM_CurrentInfo();
2182 ole_clipbrd
*clipbrd
;
2185 TRACE("(%p)\n", data
);
2187 if(!info
->ole_inits
)
2188 return CO_E_NOTINITIALIZED
;
2190 if(FAILED(hr
= get_ole_clipbrd(&clipbrd
))) return hr
;
2192 if(FAILED(hr
= get_clipbrd_window(clipbrd
, &wnd
))) return hr
;
2194 if ( !OpenClipboard(wnd
) ) return CLIPBRD_E_CANT_OPEN
;
2196 if ( !EmptyClipboard() )
2198 hr
= CLIPBRD_E_CANT_EMPTY
;
2202 hr
= set_src_dataobject(clipbrd
, data
);
2203 if(FAILED(hr
)) goto end
;
2207 hr
= expose_marshalled_dataobject(clipbrd
, data
);
2208 if(FAILED(hr
)) goto end
;
2209 hr
= set_dataobject_format(wnd
);
2214 if ( !CloseClipboard() ) hr
= CLIPBRD_E_CANT_CLOSE
;
2218 expose_marshalled_dataobject(clipbrd
, NULL
);
2219 set_src_dataobject(clipbrd
, NULL
);
2226 /***********************************************************************
2227 * OleGetClipboard [OLE32.@]
2228 * Returns a pointer to our internal IDataObject which represents the conceptual
2229 * state of the Windows clipboard. If the current clipboard already contains
2230 * an IDataObject, our internal IDataObject will delegate to this object.
2232 HRESULT WINAPI
OleGetClipboard(IDataObject
**obj
)
2235 ole_clipbrd
*clipbrd
;
2238 TRACE("(%p)\n", obj
);
2240 if(!obj
) return E_INVALIDARG
;
2243 if(FAILED(hr
= get_ole_clipbrd(&clipbrd
))) return hr
;
2245 seq_no
= GetClipboardSequenceNumber();
2246 EnterCriticalSection(&latest_snapshot_cs
);
2247 if(clipbrd
->latest_snapshot
&& clipbrd
->latest_snapshot
->seq_no
!= seq_no
)
2248 clipbrd
->latest_snapshot
= NULL
;
2250 if(!clipbrd
->latest_snapshot
)
2252 clipbrd
->latest_snapshot
= snapshot_construct(seq_no
);
2253 if(!clipbrd
->latest_snapshot
)
2255 LeaveCriticalSection(&latest_snapshot_cs
);
2256 return E_OUTOFMEMORY
;
2260 *obj
= &clipbrd
->latest_snapshot
->IDataObject_iface
;
2261 IDataObject_AddRef(*obj
);
2262 LeaveCriticalSection(&latest_snapshot_cs
);
2267 /******************************************************************************
2268 * OleFlushClipboard [OLE32.@]
2269 * Renders the data from the source IDataObject into the windows clipboard
2271 * TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
2272 * by copying the storage into global memory. Subsequently the default
2273 * data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
2274 * back to TYMED_IStorage.
2276 HRESULT WINAPI
OleFlushClipboard(void)
2278 struct oletls
*info
= COM_CurrentInfo();
2280 ole_clipbrd
*clipbrd
;
2285 if(FAILED(hr
= get_ole_clipbrd(&clipbrd
))) return hr
;
2287 if(!info
->ole_inits
)
2290 if(FAILED(hr
= get_clipbrd_window(clipbrd
, &wnd
))) return hr
;
2293 * Already flushed or no source DataObject? Nothing to do.
2295 if (!clipbrd
->src_data
) return S_OK
;
2297 if (!OpenClipboard(wnd
)) return CLIPBRD_E_CANT_OPEN
;
2299 SendMessageW(wnd
, WM_RENDERALLFORMATS
, 0, 0);
2301 hr
= set_dataobject_format(NULL
);
2303 expose_marshalled_dataobject(clipbrd
, NULL
);
2304 set_src_dataobject(clipbrd
, NULL
);
2306 if ( !CloseClipboard() ) hr
= CLIPBRD_E_CANT_CLOSE
;
2312 /***********************************************************************
2313 * OleIsCurrentClipboard [OLE32.@]
2315 HRESULT WINAPI
OleIsCurrentClipboard(IDataObject
*data
)
2318 ole_clipbrd
*clipbrd
;
2321 if(FAILED(hr
= get_ole_clipbrd(&clipbrd
))) return hr
;
2323 if (data
== NULL
) return S_FALSE
;
2325 return (data
== clipbrd
->src_data
) ? S_OK
: S_FALSE
;