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