dlls/ole32/clipboard.c

   1 /*
   2  *  OLE 2 clipboard support
   3  *
   4  *      Copyright 1999  Noel Borthwick <noel@macadamian.com>
   5  *      Copyright 2000  Abey George <abey@macadamian.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * NOTES:
  22  *    This file contains the implementation for the OLE Clipboard and its
  23  *    internal interfaces. The OLE clipboard interacts with an IDataObject
  24  *    interface via the OleSetClipboard, OleGetClipboard and
  25  *    OleIsCurrentClipboard API's. An internal IDataObject delegates
  26  *    to a client supplied IDataObject or the WIN32 clipboard API depending
  27  *    on whether OleSetClipboard has been invoked.
  28  *    Here are some operating scenarios:
  29  *
  30  *    1. OleSetClipboard called: In this case the internal IDataObject
  31  *       delegates to the client supplied IDataObject. Additionally OLE takes
  32  *       ownership of the Windows clipboard and any HGLOCBAL IDataObject
  33  *       items are placed on the Windows clipboard. This allows non OLE aware
  34  *       applications to access these. A local WinProc fields WM_RENDERFORMAT
  35  *       and WM_RENDERALLFORMATS messages in this case.
  36  *
  37  *    2. OleGetClipboard called without previous OleSetClipboard. Here the internal
  38  *       IDataObject functionality wraps around the WIN32 clipboard API.
  39  *
  40  *    3. OleGetClipboard called after previous OleSetClipboard. Here the internal
  41  *       IDataObject delegates to the source IDataObjects functionality directly,
  42  *       thereby bypassing the Windows clipboard.
  43  *
  44  *    Implementation references : Inside OLE 2'nd  edition by Kraig Brockschmidt
  45  *
  46  * TODO:
  47  *    - Support for pasting between different processes. OLE clipboard support
  48  *      currently works only for in process copy and paste. Since we internally
  49  *      store a pointer to the source's IDataObject and delegate to that, this
  50  *      will fail if the IDataObject client belongs to a different process.
  51  *    - IDataObject::GetDataHere is not implemented
  52  *    - OleFlushClipboard needs to additionally handle TYMED_IStorage media
  53  *      by copying the storage into global memory. Subsequently the default
  54  *      data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
  55  *      back to TYMED_IStorage.
  56  *    - OLE1 compatibility formats to be synthesized from OLE2 formats and put on
  57  *      clipboard in OleSetClipboard.
  58  *
  59  */
  60
  61 #include <assert.h>
  62 #include <stdarg.h>
  63 #include <string.h>
  64 #include <stdio.h>
  65
  66 #define COBJMACROS
  67 #define NONAMELESSUNION
  68 #define NONAMELESSSTRUCT
  69
  70 #include "windef.h"
  71 #include "winbase.h"
  72 #include "wingdi.h"
  73 #include "winuser.h"
  74 #include "winerror.h"
  75 #include "winnls.h"
  76 #include "ole2.h"
  77 #include "wine/debug.h"
  78 #include "olestd.h"
  79
  80 #include "storage32.h"
  81
  82 #include "compobj_private.h"
  83
  84 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  85
  86 #define HANDLE_ERROR(err) do { hr = err; TRACE("(HRESULT=%x)\n", (HRESULT)err); goto CLEANUP; } while (0)
  87
  88 /* Structure of 'Ole Private Data' clipboard format */
  89 typedef struct
  90 {
  91     FORMATETC fmtetc;
  92     DWORD first_use;  /* Has this cf been added to the list already */
  93     DWORD unk[2];
  94 } ole_priv_data_entry;
  95
  96 typedef struct
  97 {
  98     DWORD unk1;
  99     DWORD size; /* in bytes of the entire structure */
 100     DWORD unk2;
 101     DWORD count; /* no. of format entries */
 102     DWORD unk3[2];
 103     ole_priv_data_entry entries[1]; /* array of size count */
 104     /* then follows any DVTARGETDEVICE structures referenced in the FORMATETCs */
 105 } ole_priv_data;
 106
 107 /*****************************************************************************
 108  *           create_empty_priv_data
 109  *
 110  * Create an empty data structure.  The only thing that really matters
 111  * here is setting count and size members.  This is used by the enumerator as a
 112  * convenience when there's an empty list.
 113  */
 114 static HRESULT create_empty_priv_data(ole_priv_data **data)
 115 {
 116     ole_priv_data *ptr;
 117
 118     *data = NULL;
 119     ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(*ptr));
 120     if(!ptr) return E_OUTOFMEMORY;
 121     ptr->size = sizeof(*ptr);
 122     ptr->count = 0;
 123     *data = ptr;
 124     return S_OK;
 125 }
 126
 127 /****************************************************************************
 128  * Consumer snapshot.  Represents the state of the ole clipboard
 129  * returned by OleGetClipboard().
 130  */
 131 typedef struct snapshot
 132 {
 133     const IDataObjectVtbl* lpVtbl;
 134     LONG ref;
 135
 136     DWORD seq_no;                   /* Clipboard sequence number corresponding to this snapshot */
 137
 138     IDataObject *data;              /* If we unmarshal a remote data object we hold a ref here */
 139 } snapshot;
 140
 141 /****************************************************************************
 142  * ole_clipbrd
 143  */
 144 typedef struct ole_clipbrd
 145 {
 146     snapshot *latest_snapshot;       /* Latest consumer snapshot */
 147
 148     HWND window;                     /* Hidden clipboard window */
 149     IDataObject *src_data;           /* Source object passed to OleSetClipboard */
 150     ole_priv_data *cached_enum;      /* Cached result from the enumeration of src data object */
 151     IStream *marshal_data;           /* Stream onto which to marshal src_data */
 152 } ole_clipbrd;
 153
 154 static inline snapshot *impl_from_IDataObject(IDataObject *iface)
 155 {
 156     return (snapshot*)((char*)iface - FIELD_OFFSET(snapshot, lpVtbl));
 157 }
 158
 159 typedef struct PresentationDataHeader
 160 {
 161   BYTE unknown1[28];
 162   DWORD dwObjectExtentX;
 163   DWORD dwObjectExtentY;
 164   DWORD dwSize;
 165 } PresentationDataHeader;
 166
 167 /*
 168  * The one and only ole_clipbrd object which is created by OLEClipbrd_Initialize()
 169  */
 170 static ole_clipbrd* theOleClipboard;
 171
 172 static inline HRESULT get_ole_clipbrd(ole_clipbrd **clipbrd)
 173 {
 174     struct oletls *info = COM_CurrentInfo();
 175     *clipbrd = NULL;
 176
 177     if(!info->ole_inits)
 178         return CO_E_NOTINITIALIZED;
 179     *clipbrd = theOleClipboard;
 180
 181     return S_OK;
 182 }
 183
 184 /*
 185  * Name of our registered OLE clipboard window class
 186  */
 187 static const WCHAR clipbrd_wndclass[] = {'C','L','I','P','B','R','D','W','N','D','C','L','A','S','S',0};
 188
 189 static const WCHAR wine_marshal_dataobject[] = {'W','i','n','e',' ','m','a','r','s','h','a','l',' ','d','a','t','a','o','b','j','e','c','t',0};
 190
 191 static UINT dataobject_clipboard_format;
 192 static UINT ole_priv_data_clipboard_format;
 193 static UINT embed_source_clipboard_format;
 194
 195 static inline char *dump_fmtetc(FORMATETC *fmt)
 196 {
 197     static char buf[100];
 198
 199     snprintf(buf, sizeof(buf), "cf %04x ptd %p aspect %x lindex %d tymed %x",
 200              fmt->cfFormat, fmt->ptd, fmt->dwAspect, fmt->lindex, fmt->tymed);
 201     return buf;
 202 }
 203
 204 /*---------------------------------------------------------------------*
 205  *  Implementation of the internal IEnumFORMATETC interface returned by
 206  *  the OLE clipboard's IDataObject.
 207  *---------------------------------------------------------------------*/
 208
 209 typedef struct enum_fmtetc
 210 {
 211     const IEnumFORMATETCVtbl *lpVtbl;
 212     LONG ref;
 213
 214     UINT pos;    /* current enumerator position */
 215     ole_priv_data *data;
 216 } enum_fmtetc;
 217
 218 static inline enum_fmtetc *impl_from_IEnumFORMATETC(IEnumFORMATETC *iface)
 219 {
 220     return (enum_fmtetc*)((char*)iface - FIELD_OFFSET(enum_fmtetc, lpVtbl));
 221 }
 222
 223 /************************************************************************
 224  * OLEClipbrd_IEnumFORMATETC_QueryInterface (IUnknown)
 225  *
 226  * See Windows documentation for more details on IUnknown methods.
 227  */
 228 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface
 229   (LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
 230 {
 231   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 232
 233   TRACE("(%p)->(IID: %s, %p)\n", This, debugstr_guid(riid), ppvObj);
 234
 235   *ppvObj = NULL;
 236
 237   if(IsEqualIID(riid, &IID_IUnknown) ||
 238      IsEqualIID(riid, &IID_IEnumFORMATETC))
 239   {
 240     *ppvObj = iface;
 241   }
 242
 243   if(*ppvObj)
 244   {
 245     IEnumFORMATETC_AddRef((IEnumFORMATETC*)*ppvObj);
 246     TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
 247     return S_OK;
 248   }
 249
 250   TRACE("-- Interface: E_NOINTERFACE\n");
 251   return E_NOINTERFACE;
 252 }
 253
 254 /************************************************************************
 255  * OLEClipbrd_IEnumFORMATETC_AddRef (IUnknown)
 256  *
 257  */
 258 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface)
 259 {
 260   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 261   TRACE("(%p)->(count=%u)\n",This, This->ref);
 262
 263   return InterlockedIncrement(&This->ref);
 264 }
 265
 266 /************************************************************************
 267  * OLEClipbrd_IEnumFORMATETC_Release (IUnknown)
 268  *
 269  * See Windows documentation for more details on IUnknown methods.
 270  */
 271 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface)
 272 {
 273   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 274   ULONG ref;
 275
 276   TRACE("(%p)->(count=%u)\n",This, This->ref);
 277
 278   ref = InterlockedDecrement(&This->ref);
 279   if (!ref)
 280   {
 281     TRACE("() - destroying IEnumFORMATETC(%p)\n",This);
 282     HeapFree(GetProcessHeap(), 0, This->data);
 283     HeapFree(GetProcessHeap(), 0, This);
 284   }
 285   return ref;
 286 }
 287
 288 /************************************************************************
 289  * OLEClipbrd_IEnumFORMATETC_Next (IEnumFORMATETC)
 290  *
 291  * Standard enumerator members for IEnumFORMATETC
 292  */
 293 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next
 294   (LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
 295 {
 296   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 297   UINT cfetch, i;
 298   HRESULT hres = S_FALSE;
 299
 300   TRACE("(%p)->(pos=%u)\n", This, This->pos);
 301
 302   if (This->pos < This->data->count)
 303   {
 304     cfetch = This->data->count - This->pos;
 305     if (cfetch >= celt)
 306     {
 307       cfetch = celt;
 308       hres = S_OK;
 309     }
 310
 311     for(i = 0; i < cfetch; i++)
 312     {
 313       rgelt[i] = This->data->entries[This->pos++].fmtetc;
 314       if(rgelt[i].ptd)
 315       {
 316         DVTARGETDEVICE *target = (DVTARGETDEVICE *)((char *)This->data + (DWORD)rgelt[i].ptd);
 317         rgelt[i].ptd = CoTaskMemAlloc(target->tdSize);
 318         if(!rgelt[i].ptd) return E_OUTOFMEMORY;
 319         memcpy(rgelt[i].ptd, target, target->tdSize);
 320       }
 321     }
 322   }
 323   else
 324   {
 325     cfetch = 0;
 326   }
 327
 328   if (pceltFethed)
 329   {
 330     *pceltFethed = cfetch;
 331   }
 332
 333   return hres;
 334 }
 335
 336 /************************************************************************
 337  * OLEClipbrd_IEnumFORMATETC_Skip (IEnumFORMATETC)
 338  *
 339  * Standard enumerator members for IEnumFORMATETC
 340  */
 341 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface, ULONG celt)
 342 {
 343   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 344   TRACE("(%p)->(num=%u)\n", This, celt);
 345
 346   This->pos += celt;
 347   if (This->pos > This->data->count)
 348   {
 349     This->pos = This->data->count;
 350     return S_FALSE;
 351   }
 352   return S_OK;
 353 }
 354
 355 /************************************************************************
 356  * OLEClipbrd_IEnumFORMATETC_Reset (IEnumFORMATETC)
 357  *
 358  * Standard enumerator members for IEnumFORMATETC
 359  */
 360 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface)
 361 {
 362   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 363   TRACE("(%p)->()\n", This);
 364
 365   This->pos = 0;
 366   return S_OK;
 367 }
 368
 369 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj);
 370
 371 /************************************************************************
 372  * OLEClipbrd_IEnumFORMATETC_Clone (IEnumFORMATETC)
 373  *
 374  * Standard enumerator members for IEnumFORMATETC
 375  */
 376 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone
 377   (LPENUMFORMATETC iface, LPENUMFORMATETC* obj)
 378 {
 379   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 380   ole_priv_data *new_data;
 381
 382   TRACE("(%p)->(%p)\n", This, obj);
 383
 384   if ( !obj ) return E_INVALIDARG;
 385   *obj = NULL;
 386
 387   new_data = HeapAlloc(GetProcessHeap(), 0, This->data->size);
 388   if(!new_data) return E_OUTOFMEMORY;
 389
 390   return enum_fmtetc_construct(new_data, This->pos, obj);
 391 }
 392
 393 static const IEnumFORMATETCVtbl efvt =
 394 {
 395   OLEClipbrd_IEnumFORMATETC_QueryInterface,
 396   OLEClipbrd_IEnumFORMATETC_AddRef,
 397   OLEClipbrd_IEnumFORMATETC_Release,
 398   OLEClipbrd_IEnumFORMATETC_Next,
 399   OLEClipbrd_IEnumFORMATETC_Skip,
 400   OLEClipbrd_IEnumFORMATETC_Reset,
 401   OLEClipbrd_IEnumFORMATETC_Clone
 402 };
 403
 404 /************************************************************************
 405  * enum_fmtetc_construct
 406  *
 407  * Creates an IEnumFORMATETC enumerator from ole_priv_data which it then owns.
 408  */
 409 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj)
 410 {
 411   enum_fmtetc* ef;
 412
 413   *obj = NULL;
 414   ef = HeapAlloc(GetProcessHeap(), 0, sizeof(*ef));
 415   if (!ef) return E_OUTOFMEMORY;
 416
 417   ef->ref = 1;
 418   ef->lpVtbl = &efvt;
 419   ef->data = data;
 420   ef->pos = pos;
 421
 422   TRACE("(%p)->()\n", ef);
 423   *obj = (IEnumFORMATETC *)ef;
 424   return S_OK;
 425 }
 426
 427 /***********************************************************************
 428  *                    dup_global_mem
 429  *
 430  * Helper method to duplicate an HGLOBAL chunk of memory
 431  */
 432 static HRESULT dup_global_mem( HGLOBAL src, DWORD flags, HGLOBAL *dst )
 433 {
 434     void *src_ptr, *dst_ptr;
 435     DWORD size;
 436
 437     *dst = NULL;
 438     if ( !src ) return S_FALSE;
 439
 440     size = GlobalSize(src);
 441
 442     *dst = GlobalAlloc( flags, size );
 443     if ( !*dst ) return E_OUTOFMEMORY;
 444
 445     src_ptr = GlobalLock(src);
 446     dst_ptr = GlobalLock(*dst);
 447
 448     memcpy(dst_ptr, src_ptr, size);
 449
 450     GlobalUnlock(*dst);
 451     GlobalUnlock(src);
 452
 453     return S_OK;
 454 }
 455
 456 /************************************************************
 457  *              render_embed_source_hack
 458  *
 459  * This is clearly a hack and has no place in the clipboard code.
 460  *
 461  */
 462 static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
 463 {
 464     STGMEDIUM std;
 465     HGLOBAL hStorage = 0;
 466     HRESULT hr = S_OK;
 467     ILockBytes *ptrILockBytes;
 468
 469     memset(&std, 0, sizeof(STGMEDIUM));
 470     std.tymed = fmt->tymed = TYMED_ISTORAGE;
 471
 472     hStorage = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, 0);
 473     if (hStorage == NULL) return E_OUTOFMEMORY;
 474     hr = CreateILockBytesOnHGlobal(hStorage, FALSE, &ptrILockBytes);
 475     hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
 476     ILockBytes_Release(ptrILockBytes);
 477
 478     if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->src_data, fmt, &std)))
 479     {
 480         WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%x)\n", hr);
 481         GlobalFree(hStorage);
 482         return hr;
 483     }
 484
 485     if (1) /* check whether the presentation data is already -not- present */
 486     {
 487         FORMATETC fmt2;
 488         STGMEDIUM std2;
 489         METAFILEPICT *mfp = 0;
 490
 491         fmt2.cfFormat = CF_METAFILEPICT;
 492         fmt2.ptd = 0;
 493         fmt2.dwAspect = DVASPECT_CONTENT;
 494         fmt2.lindex = -1;
 495         fmt2.tymed = TYMED_MFPICT;
 496
 497         memset(&std2, 0, sizeof(STGMEDIUM));
 498         std2.tymed = TYMED_MFPICT;
 499
 500         /* Get the metafile picture out of it */
 501
 502         if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->src_data, &fmt2, &std2)))
 503         {
 504             mfp = GlobalLock(std2.u.hGlobal);
 505         }
 506
 507         if (mfp)
 508         {
 509             OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
 510             IStream *pStream = 0;
 511             void *mfBits;
 512             PresentationDataHeader pdh;
 513             INT nSize;
 514             CLSID clsID;
 515             LPOLESTR strProgID;
 516             CHAR strOleTypeName[51];
 517             BYTE OlePresStreamHeader [] =
 518             {
 519                 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
 520                 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 521                 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
 522                 0x00, 0x00, 0x00, 0x00
 523             };
 524
 525             nSize = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
 526
 527             memset(&pdh, 0, sizeof(PresentationDataHeader));
 528             memcpy(&pdh, OlePresStreamHeader, sizeof(OlePresStreamHeader));
 529
 530             pdh.dwObjectExtentX = mfp->xExt;
 531             pdh.dwObjectExtentY = mfp->yExt;
 532             pdh.dwSize = nSize;
 533
 534             hr = IStorage_CreateStream(std.u.pstg, name, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
 535
 536             hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
 537
 538             mfBits = HeapAlloc(GetProcessHeap(), 0, nSize);
 539             nSize = GetMetaFileBitsEx(mfp->hMF, nSize, mfBits);
 540
 541             hr = IStream_Write(pStream, mfBits, nSize, NULL);
 542
 543             IStream_Release(pStream);
 544
 545             HeapFree(GetProcessHeap(), 0, mfBits);
 546
 547             GlobalUnlock(std2.u.hGlobal);
 548             ReleaseStgMedium(&std2);
 549
 550             ReadClassStg(std.u.pstg, &clsID);
 551             ProgIDFromCLSID(&clsID, &strProgID);
 552
 553             WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
 554             OLECONVERT_CreateOleStream(std.u.pstg);
 555             OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
 556         }
 557     }
 558
 559     if ( !SetClipboardData( fmt->cfFormat, hStorage ) )
 560     {
 561         WARN("() : Failed to set rendered clipboard data into clipboard!\n");
 562         GlobalFree(hStorage);
 563         hr = CLIPBRD_E_CANT_SET;
 564     }
 565
 566     ReleaseStgMedium(&std);
 567     return hr;
 568 }
 569
 570 /************************************************************************
 571  *           find_format_in_list
 572  *
 573  * Returns the first entry that matches the provided clipboard format.
 574  */
 575 static inline ole_priv_data_entry *find_format_in_list(ole_priv_data_entry *entries, DWORD num, UINT cf)
 576 {
 577     DWORD i;
 578     for(i = 0; i < num; i++)
 579         if(entries[i].fmtetc.cfFormat == cf)
 580             return &entries[i];
 581
 582     return NULL;
 583 }
 584
 585 /***************************************************************************
 586  *         get_data_from_storage
 587  *
 588  * Returns storage data in an HGLOBAL.
 589  */
 590 static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 591 {
 592     HGLOBAL h;
 593     IStorage *stg;
 594     HRESULT hr;
 595     FORMATETC stg_fmt;
 596     STGMEDIUM med;
 597     ILockBytes *lbs;
 598
 599     *mem = NULL;
 600
 601     h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
 602     if(!h) return E_OUTOFMEMORY;
 603
 604     hr = CreateILockBytesOnHGlobal(h, FALSE, &lbs);
 605     if(SUCCEEDED(hr))
 606     {
 607         hr = StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
 608         ILockBytes_Release(lbs);
 609     }
 610     if(FAILED(hr))
 611     {
 612         GlobalFree(h);
 613         return hr;
 614     }
 615
 616     stg_fmt = *fmt;
 617     med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
 618     med.u.pstg = stg;
 619     med.pUnkForRelease = NULL;
 620
 621     hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
 622     if(FAILED(hr))
 623     {
 624         med.u.pstg = NULL;
 625         hr = IDataObject_GetData(data, &stg_fmt, &med);
 626         if(FAILED(hr)) goto end;
 627
 628         hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
 629         ReleaseStgMedium(&med);
 630         if(FAILED(hr)) goto end;
 631     }
 632     *mem = h;
 633
 634 end:
 635     IStorage_Release(stg);
 636     if(FAILED(hr)) GlobalFree(h);
 637     return hr;
 638 }
 639
 640 /***************************************************************************
 641  *         get_data_from_stream
 642  *
 643  * Returns stream data in an HGLOBAL.
 644  */
 645 static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 646 {
 647     HGLOBAL h;
 648     IStream *stm = NULL;
 649     HRESULT hr;
 650     FORMATETC stm_fmt;
 651     STGMEDIUM med;
 652
 653     *mem = NULL;
 654
 655     h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
 656     if(!h) return E_OUTOFMEMORY;
 657
 658     hr = CreateStreamOnHGlobal(h, FALSE, &stm);
 659     if(FAILED(hr)) goto error;
 660
 661     stm_fmt = *fmt;
 662     med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
 663     med.u.pstm = stm;
 664     med.pUnkForRelease = NULL;
 665
 666     hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
 667     if(FAILED(hr))
 668     {
 669         LARGE_INTEGER offs;
 670         ULARGE_INTEGER pos;
 671
 672         med.u.pstm = NULL;
 673         hr = IDataObject_GetData(data, &stm_fmt, &med);
 674         if(FAILED(hr)) goto error;
 675
 676         offs.QuadPart = 0;
 677         IStream_Seek(med.u.pstm, offs, STREAM_SEEK_CUR, &pos);
 678         IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
 679         hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
 680         ReleaseStgMedium(&med);
 681         if(FAILED(hr)) goto error;
 682     }
 683     *mem = h;
 684     IStream_Release(stm);
 685     return S_OK;
 686
 687 error:
 688     if(stm) IStream_Release(stm);
 689     GlobalFree(h);
 690     return hr;
 691 }
 692
 693 /***************************************************************************
 694  *         get_data_from_global
 695  *
 696  * Returns global data in an HGLOBAL.
 697  */
 698 static HRESULT get_data_from_global(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 699 {
 700     HGLOBAL h;
 701     HRESULT hr;
 702     FORMATETC mem_fmt;
 703     STGMEDIUM med;
 704
 705     *mem = NULL;
 706
 707     mem_fmt = *fmt;
 708     mem_fmt.tymed = TYMED_HGLOBAL;
 709
 710     hr = IDataObject_GetData(data, &mem_fmt, &med);
 711     if(FAILED(hr)) return hr;
 712
 713     hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
 714
 715     if(SUCCEEDED(hr)) *mem = h;
 716
 717     ReleaseStgMedium(&med);
 718
 719     return hr;
 720 }
 721
 722 /***********************************************************************
 723  *                render_format
 724  *
 725  * Render the clipboard data. Note that this call will delegate to the
 726  * source data object.
 727  */
 728 static HRESULT render_format(IDataObject *data, LPFORMATETC fmt)
 729 {
 730     HGLOBAL clip_data = NULL;
 731     HRESULT hr;
 732
 733     /* Embed source hack */
 734     if(fmt->cfFormat == embed_source_clipboard_format)
 735     {
 736         return render_embed_source_hack(data, fmt);
 737     }
 738
 739     if(fmt->tymed & TYMED_ISTORAGE)
 740     {
 741         hr = get_data_from_storage(data, fmt, &clip_data);
 742     }
 743     else if(fmt->tymed & TYMED_ISTREAM)
 744     {
 745         hr = get_data_from_stream(data, fmt, &clip_data);
 746     }
 747     else if(fmt->tymed & TYMED_HGLOBAL)
 748     {
 749         hr = get_data_from_global(data, fmt, &clip_data);
 750     }
 751     else
 752     {
 753         FIXME("Unhandled tymed %x\n", fmt->tymed);
 754         hr = DV_E_FORMATETC;
 755     }
 756
 757     if(SUCCEEDED(hr))
 758     {
 759         if ( !SetClipboardData(fmt->cfFormat, clip_data) )
 760         {
 761             WARN("() : Failed to set rendered clipboard data into clipboard!\n");
 762             GlobalFree(clip_data);
 763             hr = CLIPBRD_E_CANT_SET;
 764         }
 765     }
 766
 767     return hr;
 768 }
 769
 770 /*---------------------------------------------------------------------*
 771  *  Implementation of the internal IDataObject interface exposed by
 772  *  the OLE clipboard.
 773  *---------------------------------------------------------------------*/
 774
 775
 776 /************************************************************************
 777  *           snapshot_QueryInterface
 778  */
 779 static HRESULT WINAPI snapshot_QueryInterface(IDataObject *iface,
 780                                               REFIID riid, void **ppvObject)
 781 {
 782   snapshot *This = impl_from_IDataObject(iface);
 783   TRACE("(%p)->(IID:%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 784
 785   if ( (This==0) || (ppvObject==0) )
 786     return E_INVALIDARG;
 787
 788   *ppvObject = 0;
 789
 790   if (IsEqualIID(&IID_IUnknown, riid) ||
 791       IsEqualIID(&IID_IDataObject, riid))
 792   {
 793     *ppvObject = iface;
 794   }
 795   else
 796   {
 797     WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
 798     return E_NOINTERFACE;
 799   }
 800
 801   IUnknown_AddRef((IUnknown*)*ppvObject);
 802
 803   return S_OK;
 804 }
 805
 806 /************************************************************************
 807  *              snapshot_AddRef
 808  */
 809 static ULONG WINAPI snapshot_AddRef(IDataObject *iface)
 810 {
 811     snapshot *This = impl_from_IDataObject(iface);
 812
 813     TRACE("(%p)->(count=%u)\n", This, This->ref);
 814
 815     return InterlockedIncrement(&This->ref);
 816 }
 817
 818 /************************************************************************
 819  *      snapshot_Release
 820  */
 821 static ULONG WINAPI snapshot_Release(IDataObject *iface)
 822 {
 823     snapshot *This = impl_from_IDataObject(iface);
 824     ULONG ref;
 825
 826     TRACE("(%p)->(count=%u)\n", This, This->ref);
 827
 828     ref = InterlockedDecrement(&This->ref);
 829
 830     if (ref == 0)
 831     {
 832         ole_clipbrd *clipbrd;
 833         HRESULT hr = get_ole_clipbrd(&clipbrd);
 834
 835         if(This->data) IDataObject_Release(This->data);
 836
 837         if(SUCCEEDED(hr) && clipbrd->latest_snapshot == This)
 838             clipbrd->latest_snapshot = NULL;
 839         HeapFree(GetProcessHeap(), 0, This);
 840     }
 841
 842     return ref;
 843 }
 844
 845 /************************************************************
 846  *              get_current_ole_clip_window
 847  *
 848  * Return the window that owns the ole clipboard.
 849  *
 850  * If the clipboard is flushed or not owned by ole this will
 851  * return NULL.
 852  */
 853 static HWND get_current_ole_clip_window(void)
 854 {
 855     HGLOBAL h;
 856     HWND *ptr, wnd;
 857
 858     h = GetClipboardData(dataobject_clipboard_format);
 859     if(!h) return NULL;
 860     ptr = GlobalLock(h);
 861     if(!ptr) return NULL;
 862     wnd = *ptr;
 863     GlobalUnlock(h);
 864     return wnd;
 865 }
 866
 867 /************************************************************
 868  *              get_current_dataobject
 869  *
 870  * Return an unmarshalled IDataObject if there is a current
 871  * (ie non-flushed) object on the ole clipboard.
 872  */
 873 static HRESULT get_current_dataobject(IDataObject **data)
 874 {
 875     HRESULT hr = S_FALSE;
 876     HWND wnd = get_current_ole_clip_window();
 877     HGLOBAL h;
 878     void *ptr;
 879     IStream *stm;
 880     LARGE_INTEGER pos;
 881
 882     *data = NULL;
 883     if(!wnd) return S_FALSE;
 884
 885     h = GetPropW(wnd, wine_marshal_dataobject);
 886     if(!h) return S_FALSE;
 887     ptr = GlobalLock(h);
 888     if(!ptr) return S_FALSE;
 889
 890     hr = CreateStreamOnHGlobal(NULL, TRUE, &stm);
 891     if(FAILED(hr)) goto end;
 892
 893     hr = IStream_Write(stm, ptr, GlobalSize(h), NULL);
 894     if(SUCCEEDED(hr))
 895     {
 896         pos.QuadPart = 0;
 897         IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
 898         hr = CoUnmarshalInterface(stm, &IID_IDataObject, (void**)data);
 899     }
 900     IStream_Release(stm);
 901
 902 end:
 903     GlobalUnlock(h);
 904     return hr;
 905 }
 906
 907 /***********************************************************
 908  *     get_priv_data
 909  *
 910  * Returns a copy of the Ole Private Data
 911  */
 912 static HRESULT get_priv_data(ole_priv_data **data)
 913 {
 914     HGLOBAL handle;
 915     HRESULT hr = S_OK;
 916
 917     *data = NULL;
 918
 919     handle = GetClipboardData( ole_priv_data_clipboard_format );
 920     if(handle)
 921     {
 922         ole_priv_data *src = GlobalLock(handle);
 923         if(src)
 924         {
 925             /* FIXME: sanity check on size */
 926             *data = HeapAlloc(GetProcessHeap(), 0, src->size);
 927             if(!*data)
 928             {
 929                 GlobalUnlock(handle);
 930                 return E_OUTOFMEMORY;
 931             }
 932             memcpy(*data, src, src->size);
 933             GlobalUnlock(handle);
 934         }
 935     }
 936
 937     if(!*data) hr = create_empty_priv_data(data);
 938
 939     return hr;
 940 }
 941
 942 /************************************************************************
 943  *                    get_stgmed_for_global
 944  *
 945  * Returns a stg medium with a copy of the global handle
 946  */
 947 static HRESULT get_stgmed_for_global(HGLOBAL h, STGMEDIUM *med)
 948 {
 949     HRESULT hr;
 950
 951     med->pUnkForRelease = NULL;
 952     med->tymed = TYMED_NULL;
 953
 954     hr = dup_global_mem(h, GMEM_MOVEABLE, &med->u.hGlobal);
 955
 956     if(SUCCEEDED(hr)) med->tymed = TYMED_HGLOBAL;
 957
 958     return hr;
 959 }
 960
 961 /************************************************************************
 962  *         snapshot_GetData
 963  */
 964 static HRESULT WINAPI snapshot_GetData(IDataObject *iface, FORMATETC *fmt,
 965                                        STGMEDIUM *med)
 966 {
 967     snapshot *This = impl_from_IDataObject(iface);
 968     HANDLE h;
 969     HRESULT hr;
 970     ole_priv_data *enum_data = NULL;
 971     ole_priv_data_entry *entry;
 972     DWORD mask;
 973
 974     TRACE("(%p,%p,%p)\n", iface, fmt, med);
 975
 976     if ( !fmt || !med ) return E_INVALIDARG;
 977
 978     if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
 979
 980     if(!This->data)
 981         hr = get_current_dataobject(&This->data);
 982
 983     if(This->data)
 984     {
 985         hr = IDataObject_GetData(This->data, fmt, med);
 986         CloseClipboard();
 987         return hr;
 988     }
 989
 990     h = GetClipboardData(fmt->cfFormat);
 991     if(!h)
 992     {
 993         hr = DV_E_FORMATETC;
 994         goto end;
 995     }
 996
 997     hr = get_priv_data(&enum_data);
 998     if(FAILED(hr)) goto end;
 999
1000     entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
1001     if(entry)
1002         mask = fmt->tymed & entry->fmtetc.tymed;
1003     else /* non-Ole format */
1004         mask = fmt->tymed & TYMED_HGLOBAL;
1005
1006     if(mask & TYMED_HGLOBAL)
1007         hr = get_stgmed_for_global(h, med);
1008     else
1009     {
1010         FIXME("Unhandled tymed - emum tymed %x req tymed %x\n", entry->fmtetc.tymed, fmt->tymed);
1011         hr = E_FAIL;
1012         goto end;
1013     }
1014
1015 end:
1016     if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1017     return hr;
1018 }
1019
1020 /************************************************************************
1021  *          snapshot_GetDataHere
1022  */
1023 static HRESULT WINAPI snapshot_GetDataHere(IDataObject *iface, FORMATETC *fmt,
1024                                            STGMEDIUM *med)
1025 {
1026     FIXME("(%p, %p, %p): stub\n", iface, fmt, med);
1027     return E_NOTIMPL;
1028 }
1029
1030 /************************************************************************
1031  *           snapshot_QueryGetData
1032  *
1033  * The OLE Clipboard's implementation of this method delegates to
1034  * a data source if there is one or wraps around the windows clipboard
1035  * function IsClipboardFormatAvailable() otherwise.
1036  *
1037  */
1038 static HRESULT WINAPI snapshot_QueryGetData(IDataObject *iface, FORMATETC *fmt)
1039 {
1040     FIXME("(%p, %p)\n", iface, fmt);
1041
1042     if (!fmt) return E_INVALIDARG;
1043
1044     if ( fmt->dwAspect != DVASPECT_CONTENT ) return DV_E_FORMATETC;
1045
1046     if ( fmt->lindex != -1 ) return DV_E_FORMATETC;
1047
1048     return (IsClipboardFormatAvailable(fmt->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
1049 }
1050
1051 /************************************************************************
1052  *              snapshot_GetCanonicalFormatEtc
1053  */
1054 static HRESULT WINAPI snapshot_GetCanonicalFormatEtc(IDataObject *iface, FORMATETC *fmt_in,
1055                                                      FORMATETC *fmt_out)
1056 {
1057     TRACE("(%p, %p, %p)\n", iface, fmt_in, fmt_out);
1058
1059     if ( !fmt_in || !fmt_out ) return E_INVALIDARG;
1060
1061     *fmt_out = *fmt_in;
1062     return DATA_S_SAMEFORMATETC;
1063 }
1064
1065 /************************************************************************
1066  *              snapshot_SetData
1067  *
1068  * The OLE Clipboard does not implement this method
1069  */
1070 static HRESULT WINAPI snapshot_SetData(IDataObject *iface, FORMATETC *fmt,
1071                                        STGMEDIUM *med, BOOL release)
1072 {
1073     TRACE("(%p, %p, %p, %d): not implemented\n", iface, fmt, med, release);
1074     return E_NOTIMPL;
1075 }
1076
1077 /************************************************************************
1078  *             snapshot_EnumFormatEtc
1079  *
1080  */
1081 static HRESULT WINAPI snapshot_EnumFormatEtc(IDataObject *iface, DWORD dir,
1082                                              IEnumFORMATETC **enum_fmt)
1083 {
1084     HRESULT hr;
1085     ole_priv_data *data = NULL;
1086
1087     TRACE("(%p, %x, %p)\n", iface, dir, enum_fmt);
1088
1089     *enum_fmt = NULL;
1090
1091     if ( dir != DATADIR_GET ) return E_NOTIMPL;
1092     if ( !OpenClipboard(NULL) ) return CLIPBRD_E_CANT_OPEN;
1093
1094     hr = get_priv_data(&data);
1095
1096     if(FAILED(hr)) goto end;
1097
1098     hr = enum_fmtetc_construct( data, 0, enum_fmt );
1099
1100 end:
1101     if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1102     return hr;
1103 }
1104
1105 /************************************************************************
1106  *               snapshot_DAdvise
1107  *
1108  * The OLE Clipboard does not implement this method
1109  */
1110 static HRESULT WINAPI snapshot_DAdvise(IDataObject *iface, FORMATETC *fmt,
1111                                        DWORD flags, IAdviseSink *sink,
1112                                        DWORD *conn)
1113 {
1114     TRACE("(%p, %p, %x, %p, %p): not implemented\n", iface, fmt, flags, sink, conn);
1115     return E_NOTIMPL;
1116 }
1117
1118 /************************************************************************
1119  *              snapshot_DUnadvise
1120  *
1121  * The OLE Clipboard does not implement this method
1122  */
1123 static HRESULT WINAPI snapshot_DUnadvise(IDataObject* iface, DWORD conn)
1124 {
1125     TRACE("(%p, %d): not implemented\n", iface, conn);
1126     return E_NOTIMPL;
1127 }
1128
1129 /************************************************************************
1130  *             snapshot_EnumDAdvise
1131  *
1132  * The OLE Clipboard does not implement this method
1133  */
1134 static HRESULT WINAPI snapshot_EnumDAdvise(IDataObject* iface,
1135                                            IEnumSTATDATA** enum_advise)
1136 {
1137     TRACE("(%p, %p): not implemented\n", iface, enum_advise);
1138     return E_NOTIMPL;
1139 }
1140
1141 static const IDataObjectVtbl snapshot_vtable =
1142 {
1143     snapshot_QueryInterface,
1144     snapshot_AddRef,
1145     snapshot_Release,
1146     snapshot_GetData,
1147     snapshot_GetDataHere,
1148     snapshot_QueryGetData,
1149     snapshot_GetCanonicalFormatEtc,
1150     snapshot_SetData,
1151     snapshot_EnumFormatEtc,
1152     snapshot_DAdvise,
1153     snapshot_DUnadvise,
1154     snapshot_EnumDAdvise
1155 };
1156
1157 /*---------------------------------------------------------------------*
1158  *           Internal implementation methods for the OLE clipboard
1159  *---------------------------------------------------------------------*/
1160
1161 static snapshot *snapshot_construct(DWORD seq_no)
1162 {
1163     snapshot *This;
1164
1165     This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
1166     if (!This) return NULL;
1167
1168     This->lpVtbl = &snapshot_vtable;
1169     This->ref = 0;
1170     This->seq_no = seq_no;
1171     This->data = NULL;
1172
1173     return This;
1174 }
1175
1176 /*********************************************************
1177  *               register_clipboard_formats
1178  */
1179 static void register_clipboard_formats(void)
1180 {
1181     static const WCHAR DataObjectW[] = { 'D','a','t','a','O','b','j','e','c','t',0 };
1182     static const WCHAR OlePrivateDataW[] = { 'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0 };
1183     static const WCHAR EmbedSourceW[] = { 'E','m','b','e','d',' ','S','o','u','r','c','e',0 };
1184
1185     if(!dataobject_clipboard_format)
1186         dataobject_clipboard_format = RegisterClipboardFormatW(DataObjectW);
1187     if(!ole_priv_data_clipboard_format)
1188         ole_priv_data_clipboard_format = RegisterClipboardFormatW(OlePrivateDataW);
1189     if(!embed_source_clipboard_format)
1190         embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSourceW);
1191 }
1192
1193 /***********************************************************************
1194  * OLEClipbrd_Initialize()
1195  * Initializes the OLE clipboard.
1196  */
1197 void OLEClipbrd_Initialize(void)
1198 {
1199     register_clipboard_formats();
1200
1201     if ( !theOleClipboard )
1202     {
1203         ole_clipbrd* clipbrd;
1204         HGLOBAL h;
1205
1206         TRACE("()\n");
1207
1208         clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
1209         if (!clipbrd) return;
1210
1211         clipbrd->latest_snapshot = NULL;
1212         clipbrd->window = NULL;
1213         clipbrd->src_data = NULL;
1214         clipbrd->cached_enum = NULL;
1215
1216         h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
1217         if(!h)
1218         {
1219             HeapFree(GetProcessHeap(), 0, clipbrd);
1220             return;
1221         }
1222
1223         if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
1224         {
1225             GlobalFree(h);
1226             HeapFree(GetProcessHeap(), 0, clipbrd);
1227             return;
1228         }
1229
1230         theOleClipboard = clipbrd;
1231     }
1232 }
1233
1234 /***********************************************************************
1235  * OLEClipbrd_UnInitialize()
1236  * Un-Initializes the OLE clipboard
1237  */
1238 void OLEClipbrd_UnInitialize(void)
1239 {
1240     ole_clipbrd *clipbrd = theOleClipboard;
1241
1242     TRACE("()\n");
1243
1244     if ( clipbrd )
1245     {
1246         static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1247         HINSTANCE hinst = GetModuleHandleW(ole32W);
1248
1249         if ( clipbrd->window )
1250         {
1251             DestroyWindow(clipbrd->window);
1252             UnregisterClassW( clipbrd_wndclass, hinst );
1253         }
1254
1255         IStream_Release(clipbrd->marshal_data);
1256         HeapFree(GetProcessHeap(), 0, clipbrd);
1257         theOleClipboard = NULL;
1258     }
1259 }
1260
1261 /*********************************************************************
1262  *          set_clipboard_formats
1263  *
1264  * Enumerate all formats supported by the source and make
1265  * those formats available using delayed rendering using SetClipboardData.
1266  * Cache the enumeration list and make that list visibile as the
1267  * 'Ole Private Data' format on the clipboard.
1268  *
1269  */
1270 static HRESULT set_clipboard_formats(ole_clipbrd *clipbrd, IDataObject *data)
1271 {
1272     HRESULT hr;
1273     FORMATETC fmt;
1274     IEnumFORMATETC *enum_fmt;
1275     HGLOBAL priv_data_handle;
1276     DWORD target_offset;
1277     ole_priv_data *priv_data;
1278     DWORD count = 0, needed = sizeof(*priv_data), idx;
1279
1280     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
1281     if(FAILED(hr)) return hr;
1282
1283     while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1284     {
1285         count++;
1286         needed += sizeof(priv_data->entries[0]);
1287         if(fmt.ptd)
1288         {
1289             needed += fmt.ptd->tdSize;
1290             CoTaskMemFree(fmt.ptd);
1291         }
1292     }
1293
1294     /* Windows pads the list with two empty ole_priv_data_entries, one
1295      * after the entries array and one after the target device data.
1296      * Allocating with zero init to zero these pads. */
1297
1298     needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
1299     priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
1300     priv_data = GlobalLock(priv_data_handle);
1301
1302     priv_data->unk1 = 0;
1303     priv_data->size = needed;
1304     priv_data->unk2 = 1;
1305     priv_data->count = count;
1306     priv_data->unk3[0] = 0;
1307     priv_data->unk3[1] = 0;
1308
1309     IEnumFORMATETC_Reset(enum_fmt);
1310
1311     idx = 0;
1312     target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
1313
1314     while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1315     {
1316         TRACE("%s\n", dump_fmtetc(&fmt));
1317
1318         priv_data->entries[idx].fmtetc = fmt;
1319         if(fmt.ptd)
1320         {
1321             memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
1322             priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
1323             target_offset += fmt.ptd->tdSize;
1324             CoTaskMemFree(fmt.ptd);
1325         }
1326
1327         priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
1328         priv_data->entries[idx].unk[0] = 0;
1329         priv_data->entries[idx].unk[1] = 0;
1330
1331         if (priv_data->entries[idx].first_use)
1332             SetClipboardData(fmt.cfFormat, NULL);
1333
1334         idx++;
1335     }
1336
1337     IEnumFORMATETC_Release(enum_fmt);
1338
1339     /* Cache the list and fixup any target device offsets to ptrs */
1340     clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
1341     memcpy(clipbrd->cached_enum, priv_data, needed);
1342     for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
1343         if(clipbrd->cached_enum->entries[idx].fmtetc.ptd)
1344             clipbrd->cached_enum->entries[idx].fmtetc.ptd =
1345                 (DVTARGETDEVICE *)((char*)clipbrd->cached_enum + (DWORD)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
1346
1347     GlobalUnlock(priv_data_handle);
1348     SetClipboardData(ole_priv_data_clipboard_format, priv_data_handle);
1349
1350     return S_OK;
1351 }
1352
1353 static HWND create_clipbrd_window(void);
1354
1355 /***********************************************************************
1356  *                 get_clipbrd_window
1357  */
1358 static inline HRESULT get_clipbrd_window(ole_clipbrd *clipbrd, HWND *wnd)
1359 {
1360     if ( !clipbrd->window )
1361         clipbrd->window = create_clipbrd_window();
1362
1363     *wnd = clipbrd->window;
1364     return *wnd ? S_OK : E_FAIL;
1365 }
1366
1367
1368 /**********************************************************************
1369  *                  release_marshal_data
1370  *
1371  * Releases the data and sets the stream back to zero size.
1372  */
1373 static inline void release_marshal_data(IStream *stm)
1374 {
1375     LARGE_INTEGER pos;
1376     ULARGE_INTEGER size;
1377     pos.QuadPart = size.QuadPart = 0;
1378
1379     IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1380     CoReleaseMarshalData(stm);
1381     IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
1382     IStream_SetSize(stm, size);
1383 }
1384
1385 /***********************************************************************
1386  *                   set_src_dataobject
1387  *
1388  * Clears and sets the clipboard's src IDataObject.
1389  *
1390  * To marshal the source dataobject we do something rather different from Windows.
1391  * We set a window prop which contains the marshalled data.
1392  * Windows set two props one of which is an IID, the other is an endpoint number.
1393  */
1394 static HRESULT set_src_dataobject(ole_clipbrd *clipbrd, IDataObject *data)
1395 {
1396     HRESULT hr;
1397     HWND wnd;
1398
1399     if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1400
1401     if(clipbrd->src_data)
1402     {
1403         RemovePropW(wnd, wine_marshal_dataobject);
1404         release_marshal_data(clipbrd->marshal_data);
1405
1406         IDataObject_Release(clipbrd->src_data);
1407         clipbrd->src_data = NULL;
1408         HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1409         clipbrd->cached_enum = NULL;
1410     }
1411
1412     if(data)
1413     {
1414         HGLOBAL h;
1415         IUnknown *unk;
1416
1417         IDataObject_AddRef(data);
1418         clipbrd->src_data = data;
1419
1420         IDataObject_QueryInterface(data, &IID_IUnknown, (void**)&unk);
1421         hr = CoMarshalInterface(clipbrd->marshal_data, &IID_IDataObject, unk,
1422                                 MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
1423         IUnknown_Release(unk); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
1424         if(FAILED(hr)) return hr;
1425         GetHGlobalFromStream(clipbrd->marshal_data, &h);
1426         SetPropW(wnd, wine_marshal_dataobject, h);
1427         hr = set_clipboard_formats(clipbrd, data);
1428     }
1429     return hr;
1430 }
1431
1432 /***********************************************************************
1433  *                   clipbrd_wndproc
1434  */
1435 static LRESULT CALLBACK clipbrd_wndproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1436 {
1437     ole_clipbrd *clipbrd;
1438
1439     get_ole_clipbrd(&clipbrd);
1440
1441     switch (message)
1442     {
1443     case WM_RENDERFORMAT:
1444     {
1445         UINT cf = wparam;
1446         ole_priv_data_entry *entry;
1447
1448         TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
1449         entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
1450
1451         if(entry)
1452             render_format(clipbrd->src_data, &entry->fmtetc);
1453
1454         break;
1455     }
1456
1457     case WM_RENDERALLFORMATS:
1458     {
1459         DWORD i;
1460         ole_priv_data_entry *entries = clipbrd->cached_enum->entries;
1461
1462         TRACE("(): WM_RENDERALLFORMATS\n");
1463
1464         for(i = 0; i < clipbrd->cached_enum->count; i++)
1465         {
1466             if(entries[i].first_use)
1467                 render_format(clipbrd->src_data, &entries[i].fmtetc);
1468         }
1469         break;
1470     }
1471
1472     case WM_DESTROYCLIPBOARD:
1473     {
1474         TRACE("(): WM_DESTROYCLIPBOARD\n");
1475
1476         set_src_dataobject(clipbrd, NULL);
1477         break;
1478     }
1479
1480     default:
1481         return DefWindowProcW(hwnd, message, wparam, lparam);
1482     }
1483
1484     return 0;
1485 }
1486
1487
1488 /***********************************************************************
1489  *                 create_clipbrd_window
1490  */
1491 static HWND create_clipbrd_window(void)
1492 {
1493     WNDCLASSEXW class;
1494     static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1495     static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
1496     HINSTANCE hinst = GetModuleHandleW(ole32W);
1497
1498     class.cbSize         = sizeof(class);
1499     class.style          = 0;
1500     class.lpfnWndProc    = clipbrd_wndproc;
1501     class.cbClsExtra     = 0;
1502     class.cbWndExtra     = 0;
1503     class.hInstance      = hinst;
1504     class.hIcon          = 0;
1505     class.hCursor        = 0;
1506     class.hbrBackground  = 0;
1507     class.lpszMenuName   = NULL;
1508     class.lpszClassName  = clipbrd_wndclass;
1509     class.hIconSm        = NULL;
1510
1511     RegisterClassExW(&class);
1512
1513     return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
1514                          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1515                          NULL, NULL, hinst, 0);
1516 }
1517
1518 /*********************************************************************
1519  *          set_dataobject_format
1520  *
1521  * Windows creates a 'DataObject' clipboard format that contains the
1522  * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
1523  */
1524 static HRESULT set_dataobject_format(HWND hwnd)
1525 {
1526     HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
1527     HWND *data;
1528
1529     if(!h) return E_OUTOFMEMORY;
1530
1531     data = GlobalLock(h);
1532     *data = hwnd;
1533     GlobalUnlock(h);
1534
1535     if(!SetClipboardData(dataobject_clipboard_format, h))
1536     {
1537         GlobalFree(h);
1538         return CLIPBRD_E_CANT_SET;
1539     }
1540
1541     return S_OK;
1542 }
1543
1544 /*---------------------------------------------------------------------*
1545  *           Win32 OLE clipboard API
1546  *---------------------------------------------------------------------*/
1547
1548 /***********************************************************************
1549  *           OleSetClipboard     [OLE32.@]
1550  *  Places a pointer to the specified data object onto the clipboard,
1551  *  making the data object accessible to the OleGetClipboard function.
1552  *
1553  * RETURNS
1554  *
1555  *    S_OK                  IDataObject pointer placed on the clipboard
1556  *    CLIPBRD_E_CANT_OPEN   OpenClipboard failed
1557  *    CLIPBRD_E_CANT_EMPTY  EmptyClipboard failed
1558  *    CLIPBRD_E_CANT_CLOSE  CloseClipboard failed
1559  *    CLIPBRD_E_CANT_SET    SetClipboard failed
1560  */
1561
1562 HRESULT WINAPI OleSetClipboard(IDataObject* data)
1563 {
1564   HRESULT hr;
1565   ole_clipbrd *clipbrd;
1566   HWND wnd;
1567
1568   TRACE("(%p)\n", data);
1569
1570   if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1571
1572   if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1573
1574   if ( !OpenClipboard(wnd) ) return CLIPBRD_E_CANT_OPEN;
1575
1576   if ( !EmptyClipboard() )
1577   {
1578     hr = CLIPBRD_E_CANT_EMPTY;
1579     goto end;
1580   }
1581
1582   hr = set_src_dataobject(clipbrd, data);
1583   if(FAILED(hr)) goto end;
1584
1585   hr = set_dataobject_format(wnd);
1586
1587 end:
1588
1589   if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1590
1591   if ( FAILED(hr) )
1592   {
1593     set_src_dataobject(clipbrd, NULL);
1594   }
1595
1596   return hr;
1597 }
1598
1599
1600 /***********************************************************************
1601  * OleGetClipboard [OLE32.@]
1602  * Returns a pointer to our internal IDataObject which represents the conceptual
1603  * state of the Windows clipboard. If the current clipboard already contains
1604  * an IDataObject, our internal IDataObject will delegate to this object.
1605  */
1606 HRESULT WINAPI OleGetClipboard(IDataObject **obj)
1607 {
1608     HRESULT hr;
1609     ole_clipbrd *clipbrd;
1610     DWORD seq_no;
1611
1612     TRACE("(%p)\n", obj);
1613
1614     if(!obj) return E_INVALIDARG;
1615
1616     if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1617
1618     seq_no = GetClipboardSequenceNumber();
1619     if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
1620         clipbrd->latest_snapshot = NULL;
1621
1622     if(!clipbrd->latest_snapshot)
1623     {
1624         clipbrd->latest_snapshot = snapshot_construct(seq_no);
1625         if(!clipbrd->latest_snapshot) return E_OUTOFMEMORY;
1626     }
1627
1628     *obj = (IDataObject*)&clipbrd->latest_snapshot->lpVtbl;
1629     IDataObject_AddRef(*obj);
1630
1631     return S_OK;
1632 }
1633
1634 /******************************************************************************
1635  *              OleFlushClipboard        [OLE32.@]
1636  *  Renders the data from the source IDataObject into the windows clipboard
1637  *
1638  *  TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
1639  *  by copying the storage into global memory. Subsequently the default
1640  *  data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
1641  *  back to TYMED_IStorage.
1642  */
1643 HRESULT WINAPI OleFlushClipboard(void)
1644 {
1645   IEnumFORMATETC* penumFormatetc = NULL;
1646   FORMATETC rgelt;
1647   HRESULT hr;
1648   ole_clipbrd *clipbrd;
1649   HWND wnd;
1650
1651   TRACE("()\n");
1652
1653   if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1654
1655   if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
1656
1657   /*
1658    * Already flushed or no source DataObject? Nothing to do.
1659    */
1660   if (!clipbrd->src_data) return S_OK;
1661
1662   if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
1663
1664   /*
1665    * Render all HGLOBAL formats supported by the source into
1666    * the windows clipboard.
1667    */
1668   if ( FAILED( hr = IDataObject_EnumFormatEtc( clipbrd->src_data,
1669                                                DATADIR_GET,
1670                                                &penumFormatetc) ))
1671     goto end;
1672
1673
1674   while ( S_OK == IEnumFORMATETC_Next(penumFormatetc, 1, &rgelt, NULL) )
1675   {
1676     if ( rgelt.tymed == TYMED_HGLOBAL )
1677     {
1678       CHAR szFmtName[80];
1679       TRACE("(cfFormat=%d:%s)\n", rgelt.cfFormat,
1680             GetClipboardFormatNameA(rgelt.cfFormat, szFmtName, sizeof(szFmtName)-1)
1681               ? szFmtName : "");
1682
1683       if ( FAILED(render_format( clipbrd->src_data, &rgelt )) )
1684         continue;
1685     }
1686   }
1687
1688   IEnumFORMATETC_Release(penumFormatetc);
1689
1690   hr = set_dataobject_format(NULL);
1691
1692   set_src_dataobject(clipbrd, NULL);
1693
1694 end:
1695
1696   if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1697
1698   return hr;
1699 }
1700
1701
1702 /***********************************************************************
1703  *           OleIsCurrentClipboard [OLE32.@]
1704  */
1705 HRESULT WINAPI OleIsCurrentClipboard(IDataObject *data)
1706 {
1707     HRESULT hr;
1708     ole_clipbrd *clipbrd;
1709     TRACE("()\n");
1710
1711     if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1712
1713     if (data == NULL) return S_FALSE;
1714
1715     return (data == clipbrd->src_data) ? S_OK : S_FALSE;
1716 }