dlls/ole32/clipboard.c

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