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