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