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 /****************************************************************************
 129  * ole_clipbrd
 130  */
 131 typedef struct ole_clipbrd
 132 {
 133     const IDataObjectVtbl* lpvtbl;  /* Exposed IDataObject vtable */
 134
 135     LONG ref;
 136
 137     HWND hWndClipboard;              /* Hidden clipboard window */
 138     IDataObject *pIDataObjectSrc;    /* Source object passed to OleSetClipboard */
 139     ole_priv_data *cached_enum;      /* Cached result from the enumeration of src data object */
 140 } ole_clipbrd;
 141
 142 static inline ole_clipbrd *impl_from_IDataObject(IDataObject *iface)
 143 {
 144     return (ole_clipbrd*)((char*)iface - FIELD_OFFSET(ole_clipbrd, lpvtbl));
 145 }
 146
 147 typedef struct PresentationDataHeader
 148 {
 149   BYTE unknown1[28];
 150   DWORD dwObjectExtentX;
 151   DWORD dwObjectExtentY;
 152   DWORD dwSize;
 153 } PresentationDataHeader;
 154
 155 /*
 156  * The one and only ole_clipbrd object which is created by OLEClipbrd_Initialize()
 157  */
 158 static ole_clipbrd* theOleClipboard;
 159
 160 static inline HRESULT get_ole_clipbrd(ole_clipbrd **clipbrd)
 161 {
 162     struct oletls *info = COM_CurrentInfo();
 163     *clipbrd = NULL;
 164
 165     if(!info->ole_inits)
 166         return CO_E_NOTINITIALIZED;
 167     *clipbrd = theOleClipboard;
 168
 169     return S_OK;
 170 }
 171
 172 /*
 173  * Name of our registered OLE clipboard window class
 174  */
 175 static const WCHAR clipbrd_wndclass[] = {'C','L','I','P','B','R','D','W','N','D','C','L','A','S','S',0};
 176
 177 static UINT dataobject_clipboard_format;
 178 static UINT ole_priv_data_clipboard_format;
 179 static UINT embed_source_clipboard_format;
 180
 181 static inline char *dump_fmtetc(FORMATETC *fmt)
 182 {
 183     static char buf[100];
 184
 185     snprintf(buf, sizeof(buf), "cf %04x ptd %p aspect %x lindex %d tymed %x",
 186              fmt->cfFormat, fmt->ptd, fmt->dwAspect, fmt->lindex, fmt->tymed);
 187     return buf;
 188 }
 189
 190 /*---------------------------------------------------------------------*
 191  *  Implementation of the internal IEnumFORMATETC interface returned by
 192  *  the OLE clipboard's IDataObject.
 193  *---------------------------------------------------------------------*/
 194
 195 typedef struct enum_fmtetc
 196 {
 197     const IEnumFORMATETCVtbl *lpVtbl;
 198     LONG ref;
 199
 200     UINT pos;    /* current enumerator position */
 201     ole_priv_data *data;
 202 } enum_fmtetc;
 203
 204 static inline enum_fmtetc *impl_from_IEnumFORMATETC(IEnumFORMATETC *iface)
 205 {
 206     return (enum_fmtetc*)((char*)iface - FIELD_OFFSET(enum_fmtetc, lpVtbl));
 207 }
 208
 209 /************************************************************************
 210  * OLEClipbrd_IEnumFORMATETC_QueryInterface (IUnknown)
 211  *
 212  * See Windows documentation for more details on IUnknown methods.
 213  */
 214 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface
 215   (LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
 216 {
 217   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 218
 219   TRACE("(%p)->(IID: %s, %p)\n", This, debugstr_guid(riid), ppvObj);
 220
 221   *ppvObj = NULL;
 222
 223   if(IsEqualIID(riid, &IID_IUnknown) ||
 224      IsEqualIID(riid, &IID_IEnumFORMATETC))
 225   {
 226     *ppvObj = iface;
 227   }
 228
 229   if(*ppvObj)
 230   {
 231     IEnumFORMATETC_AddRef((IEnumFORMATETC*)*ppvObj);
 232     TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
 233     return S_OK;
 234   }
 235
 236   TRACE("-- Interface: E_NOINTERFACE\n");
 237   return E_NOINTERFACE;
 238 }
 239
 240 /************************************************************************
 241  * OLEClipbrd_IEnumFORMATETC_AddRef (IUnknown)
 242  *
 243  */
 244 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface)
 245 {
 246   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 247   TRACE("(%p)->(count=%u)\n",This, This->ref);
 248
 249   return InterlockedIncrement(&This->ref);
 250 }
 251
 252 /************************************************************************
 253  * OLEClipbrd_IEnumFORMATETC_Release (IUnknown)
 254  *
 255  * See Windows documentation for more details on IUnknown methods.
 256  */
 257 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface)
 258 {
 259   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 260   ULONG ref;
 261
 262   TRACE("(%p)->(count=%u)\n",This, This->ref);
 263
 264   ref = InterlockedDecrement(&This->ref);
 265   if (!ref)
 266   {
 267     TRACE("() - destroying IEnumFORMATETC(%p)\n",This);
 268     HeapFree(GetProcessHeap(), 0, This->data);
 269     HeapFree(GetProcessHeap(), 0, This);
 270   }
 271   return ref;
 272 }
 273
 274 /************************************************************************
 275  * OLEClipbrd_IEnumFORMATETC_Next (IEnumFORMATETC)
 276  *
 277  * Standard enumerator members for IEnumFORMATETC
 278  */
 279 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next
 280   (LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
 281 {
 282   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 283   UINT cfetch, i;
 284   HRESULT hres = S_FALSE;
 285
 286   TRACE("(%p)->(pos=%u)\n", This, This->pos);
 287
 288   if (This->pos < This->data->count)
 289   {
 290     cfetch = This->data->count - This->pos;
 291     if (cfetch >= celt)
 292     {
 293       cfetch = celt;
 294       hres = S_OK;
 295     }
 296
 297     for(i = 0; i < cfetch; i++)
 298     {
 299       rgelt[i] = This->data->entries[This->pos++].fmtetc;
 300       if(rgelt[i].ptd)
 301       {
 302         DVTARGETDEVICE *target = (DVTARGETDEVICE *)((char *)This->data + (DWORD)rgelt[i].ptd);
 303         rgelt[i].ptd = CoTaskMemAlloc(target->tdSize);
 304         if(!rgelt[i].ptd) return E_OUTOFMEMORY;
 305         memcpy(rgelt[i].ptd, target, target->tdSize);
 306       }
 307     }
 308   }
 309   else
 310   {
 311     cfetch = 0;
 312   }
 313
 314   if (pceltFethed)
 315   {
 316     *pceltFethed = cfetch;
 317   }
 318
 319   return hres;
 320 }
 321
 322 /************************************************************************
 323  * OLEClipbrd_IEnumFORMATETC_Skip (IEnumFORMATETC)
 324  *
 325  * Standard enumerator members for IEnumFORMATETC
 326  */
 327 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface, ULONG celt)
 328 {
 329   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 330   TRACE("(%p)->(num=%u)\n", This, celt);
 331
 332   This->pos += celt;
 333   if (This->pos > This->data->count)
 334   {
 335     This->pos = This->data->count;
 336     return S_FALSE;
 337   }
 338   return S_OK;
 339 }
 340
 341 /************************************************************************
 342  * OLEClipbrd_IEnumFORMATETC_Reset (IEnumFORMATETC)
 343  *
 344  * Standard enumerator members for IEnumFORMATETC
 345  */
 346 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface)
 347 {
 348   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 349   TRACE("(%p)->()\n", This);
 350
 351   This->pos = 0;
 352   return S_OK;
 353 }
 354
 355 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj);
 356
 357 /************************************************************************
 358  * OLEClipbrd_IEnumFORMATETC_Clone (IEnumFORMATETC)
 359  *
 360  * Standard enumerator members for IEnumFORMATETC
 361  */
 362 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone
 363   (LPENUMFORMATETC iface, LPENUMFORMATETC* obj)
 364 {
 365   enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 366   ole_priv_data *new_data;
 367
 368   TRACE("(%p)->(%p)\n", This, obj);
 369
 370   if ( !obj ) return E_INVALIDARG;
 371   *obj = NULL;
 372
 373   new_data = HeapAlloc(GetProcessHeap(), 0, This->data->size);
 374   if(!new_data) return E_OUTOFMEMORY;
 375
 376   return enum_fmtetc_construct(new_data, This->pos, obj);
 377 }
 378
 379 static const IEnumFORMATETCVtbl efvt =
 380 {
 381   OLEClipbrd_IEnumFORMATETC_QueryInterface,
 382   OLEClipbrd_IEnumFORMATETC_AddRef,
 383   OLEClipbrd_IEnumFORMATETC_Release,
 384   OLEClipbrd_IEnumFORMATETC_Next,
 385   OLEClipbrd_IEnumFORMATETC_Skip,
 386   OLEClipbrd_IEnumFORMATETC_Reset,
 387   OLEClipbrd_IEnumFORMATETC_Clone
 388 };
 389
 390 /************************************************************************
 391  * enum_fmtetc_construct
 392  *
 393  * Creates an IEnumFORMATETC enumerator from ole_priv_data which it then owns.
 394  */
 395 static HRESULT enum_fmtetc_construct(ole_priv_data *data, UINT pos, IEnumFORMATETC **obj)
 396 {
 397   enum_fmtetc* ef;
 398
 399   *obj = NULL;
 400   ef = HeapAlloc(GetProcessHeap(), 0, sizeof(*ef));
 401   if (!ef) return E_OUTOFMEMORY;
 402
 403   ef->ref = 1;
 404   ef->lpVtbl = &efvt;
 405   ef->data = data;
 406   ef->pos = pos;
 407
 408   TRACE("(%p)->()\n", ef);
 409   *obj = (IEnumFORMATETC *)ef;
 410   return S_OK;
 411 }
 412
 413 /***********************************************************************
 414  *                    dup_global_mem
 415  *
 416  * Helper method to duplicate an HGLOBAL chunk of memory
 417  */
 418 static HRESULT dup_global_mem( HGLOBAL src, DWORD flags, HGLOBAL *dst )
 419 {
 420     void *src_ptr, *dst_ptr;
 421     DWORD size;
 422
 423     *dst = NULL;
 424     if ( !src ) return S_FALSE;
 425
 426     size = GlobalSize(src);
 427
 428     *dst = GlobalAlloc( flags, size );
 429     if ( !*dst ) return E_OUTOFMEMORY;
 430
 431     src_ptr = GlobalLock(src);
 432     dst_ptr = GlobalLock(*dst);
 433
 434     memcpy(dst_ptr, src_ptr, size);
 435
 436     GlobalUnlock(*dst);
 437     GlobalUnlock(src);
 438
 439     return S_OK;
 440 }
 441
 442 /************************************************************
 443  *              render_embed_source_hack
 444  *
 445  * This is clearly a hack and has no place in the clipboard code.
 446  *
 447  */
 448 static HRESULT render_embed_source_hack(IDataObject *data, LPFORMATETC fmt)
 449 {
 450     STGMEDIUM std;
 451     HGLOBAL hStorage = 0;
 452     HRESULT hr = S_OK;
 453     ILockBytes *ptrILockBytes;
 454
 455     memset(&std, 0, sizeof(STGMEDIUM));
 456     std.tymed = fmt->tymed = TYMED_ISTORAGE;
 457
 458     hStorage = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, 0);
 459     if (hStorage == NULL) return E_OUTOFMEMORY;
 460     hr = CreateILockBytesOnHGlobal(hStorage, FALSE, &ptrILockBytes);
 461     hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
 462     ILockBytes_Release(ptrILockBytes);
 463
 464     if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->pIDataObjectSrc, fmt, &std)))
 465     {
 466         WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%x)\n", hr);
 467         GlobalFree(hStorage);
 468         return hr;
 469     }
 470
 471     if (1) /* check whether the presentation data is already -not- present */
 472     {
 473         FORMATETC fmt2;
 474         STGMEDIUM std2;
 475         METAFILEPICT *mfp = 0;
 476
 477         fmt2.cfFormat = CF_METAFILEPICT;
 478         fmt2.ptd = 0;
 479         fmt2.dwAspect = DVASPECT_CONTENT;
 480         fmt2.lindex = -1;
 481         fmt2.tymed = TYMED_MFPICT;
 482
 483         memset(&std2, 0, sizeof(STGMEDIUM));
 484         std2.tymed = TYMED_MFPICT;
 485
 486         /* Get the metafile picture out of it */
 487
 488         if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->pIDataObjectSrc, &fmt2, &std2)))
 489         {
 490             mfp = GlobalLock(std2.u.hGlobal);
 491         }
 492
 493         if (mfp)
 494         {
 495             OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
 496             IStream *pStream = 0;
 497             void *mfBits;
 498             PresentationDataHeader pdh;
 499             INT nSize;
 500             CLSID clsID;
 501             LPOLESTR strProgID;
 502             CHAR strOleTypeName[51];
 503             BYTE OlePresStreamHeader [] =
 504             {
 505                 0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
 506                 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 507                 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
 508                 0x00, 0x00, 0x00, 0x00
 509             };
 510
 511             nSize = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
 512
 513             memset(&pdh, 0, sizeof(PresentationDataHeader));
 514             memcpy(&pdh, OlePresStreamHeader, sizeof(OlePresStreamHeader));
 515
 516             pdh.dwObjectExtentX = mfp->xExt;
 517             pdh.dwObjectExtentY = mfp->yExt;
 518             pdh.dwSize = nSize;
 519
 520             hr = IStorage_CreateStream(std.u.pstg, name, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
 521
 522             hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
 523
 524             mfBits = HeapAlloc(GetProcessHeap(), 0, nSize);
 525             nSize = GetMetaFileBitsEx(mfp->hMF, nSize, mfBits);
 526
 527             hr = IStream_Write(pStream, mfBits, nSize, NULL);
 528
 529             IStream_Release(pStream);
 530
 531             HeapFree(GetProcessHeap(), 0, mfBits);
 532
 533             GlobalUnlock(std2.u.hGlobal);
 534             ReleaseStgMedium(&std2);
 535
 536             ReadClassStg(std.u.pstg, &clsID);
 537             ProgIDFromCLSID(&clsID, &strProgID);
 538
 539             WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
 540             OLECONVERT_CreateOleStream(std.u.pstg);
 541             OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
 542         }
 543     }
 544
 545     if ( !SetClipboardData( fmt->cfFormat, hStorage ) )
 546     {
 547         WARN("() : Failed to set rendered clipboard data into clipboard!\n");
 548         GlobalFree(hStorage);
 549         hr = CLIPBRD_E_CANT_SET;
 550     }
 551
 552     ReleaseStgMedium(&std);
 553     return hr;
 554 }
 555
 556 /************************************************************************
 557  *           find_format_in_list
 558  *
 559  * Returns the first entry that matches the provided clipboard format.
 560  */
 561 static inline ole_priv_data_entry *find_format_in_list(ole_priv_data_entry *entries, DWORD num, UINT cf)
 562 {
 563     DWORD i;
 564     for(i = 0; i < num; i++)
 565         if(entries[i].fmtetc.cfFormat == cf)
 566             return &entries[i];
 567
 568     return NULL;
 569 }
 570
 571 /***************************************************************************
 572  *         get_data_from_storage
 573  *
 574  * Returns storage data in an HGLOBAL.
 575  */
 576 static HRESULT get_data_from_storage(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 577 {
 578     HGLOBAL h;
 579     IStorage *stg;
 580     HRESULT hr;
 581     FORMATETC stg_fmt;
 582     STGMEDIUM med;
 583     ILockBytes *lbs;
 584
 585     *mem = NULL;
 586
 587     h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
 588     if(!h) return E_OUTOFMEMORY;
 589
 590     hr = CreateILockBytesOnHGlobal(h, FALSE, &lbs);
 591     if(SUCCEEDED(hr))
 592     {
 593         hr = StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
 594         ILockBytes_Release(lbs);
 595     }
 596     if(FAILED(hr))
 597     {
 598         GlobalFree(h);
 599         return hr;
 600     }
 601
 602     stg_fmt = *fmt;
 603     med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
 604     med.u.pstg = stg;
 605     med.pUnkForRelease = NULL;
 606
 607     hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
 608     if(FAILED(hr))
 609     {
 610         med.u.pstg = NULL;
 611         hr = IDataObject_GetData(data, &stg_fmt, &med);
 612         if(FAILED(hr)) goto end;
 613
 614         hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
 615         ReleaseStgMedium(&med);
 616         if(FAILED(hr)) goto end;
 617     }
 618     *mem = h;
 619
 620 end:
 621     IStorage_Release(stg);
 622     if(FAILED(hr)) GlobalFree(h);
 623     return hr;
 624 }
 625
 626 /***************************************************************************
 627  *         get_data_from_stream
 628  *
 629  * Returns stream data in an HGLOBAL.
 630  */
 631 static HRESULT get_data_from_stream(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 632 {
 633     HGLOBAL h;
 634     IStream *stm = NULL;
 635     HRESULT hr;
 636     FORMATETC stm_fmt;
 637     STGMEDIUM med;
 638
 639     *mem = NULL;
 640
 641     h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
 642     if(!h) return E_OUTOFMEMORY;
 643
 644     hr = CreateStreamOnHGlobal(h, FALSE, &stm);
 645     if(FAILED(hr)) goto error;
 646
 647     stm_fmt = *fmt;
 648     med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
 649     med.u.pstm = stm;
 650     med.pUnkForRelease = NULL;
 651
 652     hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
 653     if(FAILED(hr))
 654     {
 655         LARGE_INTEGER offs;
 656         ULARGE_INTEGER pos;
 657
 658         med.u.pstm = NULL;
 659         hr = IDataObject_GetData(data, &stm_fmt, &med);
 660         if(FAILED(hr)) goto error;
 661
 662         offs.QuadPart = 0;
 663         IStream_Seek(med.u.pstm, offs, STREAM_SEEK_CUR, &pos);
 664         IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
 665         hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
 666         ReleaseStgMedium(&med);
 667         if(FAILED(hr)) goto error;
 668     }
 669     *mem = h;
 670     IStream_Release(stm);
 671     return S_OK;
 672
 673 error:
 674     if(stm) IStream_Release(stm);
 675     GlobalFree(h);
 676     return hr;
 677 }
 678
 679 /***************************************************************************
 680  *         get_data_from_global
 681  *
 682  * Returns global data in an HGLOBAL.
 683  */
 684 static HRESULT get_data_from_global(IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
 685 {
 686     HGLOBAL h;
 687     HRESULT hr;
 688     FORMATETC mem_fmt;
 689     STGMEDIUM med;
 690
 691     *mem = NULL;
 692
 693     mem_fmt = *fmt;
 694     mem_fmt.tymed = TYMED_HGLOBAL;
 695
 696     hr = IDataObject_GetData(data, &mem_fmt, &med);
 697     if(FAILED(hr)) return hr;
 698
 699     hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
 700
 701     if(SUCCEEDED(hr)) *mem = h;
 702
 703     ReleaseStgMedium(&med);
 704
 705     return hr;
 706 }
 707
 708 /***********************************************************************
 709  *                render_format
 710  *
 711  * Render the clipboard data. Note that this call will delegate to the
 712  * source data object.
 713  */
 714 static HRESULT render_format(IDataObject *data, LPFORMATETC fmt)
 715 {
 716     HGLOBAL clip_data = NULL;
 717     HRESULT hr;
 718
 719     /* Embed source hack */
 720     if(fmt->cfFormat == embed_source_clipboard_format)
 721     {
 722         return render_embed_source_hack(data, fmt);
 723     }
 724
 725     if(fmt->tymed & TYMED_ISTORAGE)
 726     {
 727         hr = get_data_from_storage(data, fmt, &clip_data);
 728     }
 729     else if(fmt->tymed & TYMED_ISTREAM)
 730     {
 731         hr = get_data_from_stream(data, fmt, &clip_data);
 732     }
 733     else if(fmt->tymed & TYMED_HGLOBAL)
 734     {
 735         hr = get_data_from_global(data, fmt, &clip_data);
 736     }
 737     else
 738     {
 739         FIXME("Unhandled tymed %x\n", fmt->tymed);
 740         hr = DV_E_FORMATETC;
 741     }
 742
 743     if(SUCCEEDED(hr))
 744     {
 745         if ( !SetClipboardData(fmt->cfFormat, clip_data) )
 746         {
 747             WARN("() : Failed to set rendered clipboard data into clipboard!\n");
 748             GlobalFree(clip_data);
 749             hr = CLIPBRD_E_CANT_SET;
 750         }
 751     }
 752
 753     return hr;
 754 }
 755
 756 /***********************************************************************
 757  *                   clipbrd_wndproc
 758  */
 759 static LRESULT CALLBACK clipbrd_wndproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
 760 {
 761     ole_clipbrd *clipbrd;
 762
 763     get_ole_clipbrd(&clipbrd);
 764
 765     switch (message)
 766     {
 767     case WM_RENDERFORMAT:
 768     {
 769         UINT cf = wparam;
 770         ole_priv_data_entry *entry;
 771
 772         TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
 773         entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
 774
 775         if(entry)
 776             render_format(clipbrd->pIDataObjectSrc, &entry->fmtetc);
 777
 778         break;
 779     }
 780
 781     case WM_RENDERALLFORMATS:
 782     {
 783         DWORD i;
 784         ole_priv_data_entry *entries = clipbrd->cached_enum->entries;
 785
 786         TRACE("(): WM_RENDERALLFORMATS\n");
 787
 788         for(i = 0; i < clipbrd->cached_enum->count; i++)
 789         {
 790             if(entries[i].first_use)
 791                 render_format(clipbrd->pIDataObjectSrc, &entries[i].fmtetc);
 792         }
 793         break;
 794     }
 795
 796     case WM_DESTROYCLIPBOARD:
 797     {
 798         TRACE("(): WM_DESTROYCLIPBOARD\n");
 799
 800         if ( clipbrd->pIDataObjectSrc )
 801         {
 802             IDataObject_Release(clipbrd->pIDataObjectSrc);
 803             clipbrd->pIDataObjectSrc = NULL;
 804             HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
 805             clipbrd->cached_enum = NULL;
 806         }
 807         break;
 808     }
 809
 810     default:
 811         return DefWindowProcW(hwnd, message, wparam, lparam);
 812     }
 813
 814     return 0;
 815 }
 816
 817
 818 /*---------------------------------------------------------------------*
 819  *  Implementation of the internal IDataObject interface exposed by
 820  *  the OLE clipboard.
 821  *---------------------------------------------------------------------*/
 822
 823
 824 /************************************************************************
 825  * OLEClipbrd_IDataObject_QueryInterface (IUnknown)
 826  *
 827  * See Windows documentation for more details on IUnknown methods.
 828  */
 829 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryInterface(
 830             IDataObject*     iface,
 831             REFIID           riid,
 832             void**           ppvObject)
 833 {
 834   ole_clipbrd *This = impl_from_IDataObject(iface);
 835   TRACE("(%p)->(IID:%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 836
 837   if ( (This==0) || (ppvObject==0) )
 838     return E_INVALIDARG;
 839
 840   *ppvObject = 0;
 841
 842   if (IsEqualIID(&IID_IUnknown, riid) ||
 843       IsEqualIID(&IID_IDataObject, riid))
 844   {
 845     *ppvObject = iface;
 846   }
 847   else
 848   {
 849     WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
 850     return E_NOINTERFACE;
 851   }
 852
 853   IUnknown_AddRef((IUnknown*)*ppvObject);
 854
 855   return S_OK;
 856 }
 857
 858 /************************************************************************
 859  * OLEClipbrd_IDataObject_AddRef (IUnknown)
 860  *
 861  * See Windows documentation for more details on IUnknown methods.
 862  */
 863 static ULONG WINAPI OLEClipbrd_IDataObject_AddRef(
 864             IDataObject*     iface)
 865 {
 866   ole_clipbrd *This = impl_from_IDataObject(iface);
 867
 868   TRACE("(%p)->(count=%u)\n",This, This->ref);
 869
 870   return InterlockedIncrement(&This->ref);
 871 }
 872
 873 /***********************************************************************
 874  * OLEClipbrd_DestroyWindow(HWND)
 875  * Destroy the clipboard window and unregister its class
 876  */
 877 static void OLEClipbrd_DestroyWindow(HWND hwnd)
 878 {
 879     static const WCHAR ole32W[] = {'o','l','e','3','2',0};
 880     HINSTANCE hinst = GetModuleHandleW(ole32W);
 881
 882     DestroyWindow(hwnd);
 883     UnregisterClassW( clipbrd_wndclass, hinst );
 884 }
 885
 886 static void OLEClipbrd_Destroy(ole_clipbrd* This)
 887 {
 888     TRACE("()\n");
 889
 890     if (!This) return;
 891
 892     if ( This->hWndClipboard )
 893         OLEClipbrd_DestroyWindow(This->hWndClipboard);
 894
 895     HeapFree(GetProcessHeap(), 0, This);
 896 }
 897
 898 /************************************************************************
 899  * OLEClipbrd_IDataObject_Release (IUnknown)
 900  *
 901  * See Windows documentation for more details on IUnknown methods.
 902  */
 903 static ULONG WINAPI OLEClipbrd_IDataObject_Release(
 904             IDataObject*     iface)
 905 {
 906   ole_clipbrd *This = impl_from_IDataObject(iface);
 907   ULONG ref;
 908
 909   TRACE("(%p)->(count=%u)\n",This, This->ref);
 910
 911   ref = InterlockedDecrement(&This->ref);
 912
 913   if (ref == 0)
 914   {
 915     OLEClipbrd_Destroy(This);
 916   }
 917
 918   return ref;
 919 }
 920
 921
 922 /************************************************************************
 923  * OLEClipbrd_IDataObject_GetData (IDataObject)
 924  *
 925  * The OLE Clipboard's implementation of this method delegates to
 926  * a data source if there is one or wraps around the windows clipboard
 927  *
 928  * See Windows documentation for more details on IDataObject methods.
 929  */
 930 static HRESULT WINAPI OLEClipbrd_IDataObject_GetData(
 931             IDataObject*     iface,
 932             LPFORMATETC      pformatetcIn,
 933             STGMEDIUM*       pmedium)
 934 {
 935   HANDLE h, hData = 0;
 936   ole_clipbrd *This = impl_from_IDataObject(iface);
 937   HRESULT hr;
 938
 939   TRACE("(%p,%p,%p)\n", iface, pformatetcIn, pmedium);
 940
 941   if ( !pformatetcIn || !pmedium )
 942     return E_INVALIDARG;
 943
 944   /*
 945    * If we have a data source placed on the clipboard (via OleSetClipboard)
 946    * simply delegate to the source object's QueryGetData
 947    * NOTE: This code assumes that the IDataObject is in the same address space!
 948    * We will need to add marshalling support when Wine handles multiple processes.
 949    */
 950   if ( This->pIDataObjectSrc )
 951   {
 952     return IDataObject_GetData(This->pIDataObjectSrc, pformatetcIn, pmedium);
 953   }
 954
 955   if ( pformatetcIn->lindex != -1 )
 956     return DV_E_FORMATETC;
 957
 958   if ( (pformatetcIn->tymed & TYMED_HGLOBAL) != TYMED_HGLOBAL )
 959     return DV_E_TYMED;
 960 /*
 961    if ( pformatetcIn->dwAspect != DVASPECT_CONTENT )
 962      return DV_E_DVASPECT;
 963 */
 964
 965   /*
 966    * Otherwise, get the data from the windows clipboard using GetClipboardData
 967    */
 968   if ( !OpenClipboard(theOleClipboard->hWndClipboard)) return CLIPBRD_E_CANT_OPEN;
 969
 970   h = GetClipboardData(pformatetcIn->cfFormat);
 971   hr = dup_global_mem(h, GMEM_MOVEABLE, &hData);
 972
 973   /*
 974    * Return the clipboard data in the storage medium structure
 975    */
 976   pmedium->tymed = (hData == 0) ? TYMED_NULL : TYMED_HGLOBAL;
 977   pmedium->u.hGlobal = hData;
 978   pmedium->pUnkForRelease = NULL;
 979
 980   if ( !CloseClipboard() ) return CLIPBRD_E_CANT_CLOSE;
 981
 982   if(FAILED(hr)) return hr;
 983   return (hData == 0) ? DV_E_FORMATETC : S_OK;
 984 }
 985
 986 static HRESULT WINAPI OLEClipbrd_IDataObject_GetDataHere(
 987             IDataObject*     iface,
 988             LPFORMATETC      pformatetc,
 989             STGMEDIUM*       pmedium)
 990 {
 991   FIXME(": Stub\n");
 992   return E_NOTIMPL;
 993 }
 994
 995 /************************************************************************
 996  * OLEClipbrd_IDataObject_QueryGetData (IDataObject)
 997  *
 998  * The OLE Clipboard's implementation of this method delegates to
 999  * a data source if there is one or wraps around the windows clipboard
1000  * function IsClipboardFormatAvailable() otherwise.
1001  *
1002  * See Windows documentation for more details on IDataObject methods.
1003  */
1004 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryGetData(
1005             IDataObject*     iface,
1006             LPFORMATETC      pformatetc)
1007 {
1008   TRACE("(%p, %p)\n", iface, pformatetc);
1009
1010   if (!pformatetc)
1011     return E_INVALIDARG;
1012
1013   if ( pformatetc->dwAspect != DVASPECT_CONTENT )
1014     return DV_E_FORMATETC;
1015
1016   if ( pformatetc->lindex != -1 )
1017     return DV_E_FORMATETC;
1018
1019   /*
1020    * Delegate to the Windows clipboard function IsClipboardFormatAvailable
1021    */
1022   return (IsClipboardFormatAvailable(pformatetc->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
1023 }
1024
1025 /************************************************************************
1026  * OLEClipbrd_IDataObject_GetCanonicalFormatEtc (IDataObject)
1027  *
1028  * See Windows documentation for more details on IDataObject methods.
1029  */
1030 static HRESULT WINAPI OLEClipbrd_IDataObject_GetCanonicalFormatEtc(
1031             IDataObject*     iface,
1032             LPFORMATETC      pformatectIn,
1033             LPFORMATETC      pformatetcOut)
1034 {
1035   TRACE("(%p, %p, %p)\n", iface, pformatectIn, pformatetcOut);
1036
1037   if ( !pformatectIn || !pformatetcOut )
1038     return E_INVALIDARG;
1039
1040   *pformatetcOut = *pformatectIn;
1041   return DATA_S_SAMEFORMATETC;
1042 }
1043
1044 /************************************************************************
1045  * OLEClipbrd_IDataObject_SetData (IDataObject)
1046  *
1047  * The OLE Clipboard's does not implement this method
1048  *
1049  * See Windows documentation for more details on IDataObject methods.
1050  */
1051 static HRESULT WINAPI OLEClipbrd_IDataObject_SetData(
1052             IDataObject*     iface,
1053             LPFORMATETC      pformatetc,
1054             STGMEDIUM*       pmedium,
1055             BOOL             fRelease)
1056 {
1057   TRACE("\n");
1058   return E_NOTIMPL;
1059 }
1060
1061 /************************************************************************
1062  * OLEClipbrd_IDataObject_EnumFormatEtc (IDataObject)
1063  *
1064  * See Windows documentation for more details on IDataObject methods.
1065  */
1066 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumFormatEtc(
1067             IDataObject*     iface,
1068             DWORD            dwDirection,
1069             IEnumFORMATETC** enum_fmt)
1070 {
1071     HRESULT hr = S_OK;
1072     ole_clipbrd *This = impl_from_IDataObject(iface);
1073     HGLOBAL handle;
1074     ole_priv_data *data = NULL;
1075
1076     TRACE("(%p, %x, %p)\n", iface, dwDirection, enum_fmt);
1077
1078     *enum_fmt = NULL;
1079
1080     if ( dwDirection != DATADIR_GET ) return E_NOTIMPL;
1081     if ( !OpenClipboard(This->hWndClipboard) ) return CLIPBRD_E_CANT_OPEN;
1082
1083     handle = GetClipboardData( ole_priv_data_clipboard_format );
1084     if(handle)
1085     {
1086         ole_priv_data *src = GlobalLock(handle);
1087         if(src)
1088         {
1089             /* FIXME: sanity check on size */
1090             data = HeapAlloc(GetProcessHeap(), 0, src->size);
1091             if(!data)
1092             {
1093                 GlobalUnlock(handle);
1094                 hr = E_OUTOFMEMORY;
1095                 goto end;
1096             }
1097             memcpy(data, src, src->size);
1098             GlobalUnlock(handle);
1099         }
1100     }
1101
1102     if(!data) hr = create_empty_priv_data(&data);
1103     if(FAILED(hr)) goto end;
1104
1105     hr = enum_fmtetc_construct( data, 0, enum_fmt );
1106
1107 end:
1108     if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1109     return hr;
1110 }
1111
1112 /************************************************************************
1113  * OLEClipbrd_IDataObject_DAdvise (IDataObject)
1114  *
1115  * The OLE Clipboard's does not implement this method
1116  *
1117  * See Windows documentation for more details on IDataObject methods.
1118  */
1119 static HRESULT WINAPI OLEClipbrd_IDataObject_DAdvise(
1120             IDataObject*     iface,
1121             FORMATETC*       pformatetc,
1122             DWORD            advf,
1123             IAdviseSink*     pAdvSink,
1124             DWORD*           pdwConnection)
1125 {
1126   TRACE("\n");
1127   return E_NOTIMPL;
1128 }
1129
1130 /************************************************************************
1131  * OLEClipbrd_IDataObject_DUnadvise (IDataObject)
1132  *
1133  * The OLE Clipboard's does not implement this method
1134  *
1135  * See Windows documentation for more details on IDataObject methods.
1136  */
1137 static HRESULT WINAPI OLEClipbrd_IDataObject_DUnadvise(
1138             IDataObject*     iface,
1139             DWORD            dwConnection)
1140 {
1141   TRACE("\n");
1142   return E_NOTIMPL;
1143 }
1144
1145 /************************************************************************
1146  * OLEClipbrd_IDataObject_EnumDAdvise (IDataObject)
1147  *
1148  * The OLE Clipboard does not implement this method
1149  *
1150  * See Windows documentation for more details on IDataObject methods.
1151  */
1152 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumDAdvise(
1153             IDataObject*     iface,
1154             IEnumSTATDATA**  ppenumAdvise)
1155 {
1156   TRACE("\n");
1157   return E_NOTIMPL;
1158 }
1159
1160 static const IDataObjectVtbl OLEClipbrd_IDataObject_VTable =
1161 {
1162   OLEClipbrd_IDataObject_QueryInterface,
1163   OLEClipbrd_IDataObject_AddRef,
1164   OLEClipbrd_IDataObject_Release,
1165   OLEClipbrd_IDataObject_GetData,
1166   OLEClipbrd_IDataObject_GetDataHere,
1167   OLEClipbrd_IDataObject_QueryGetData,
1168   OLEClipbrd_IDataObject_GetCanonicalFormatEtc,
1169   OLEClipbrd_IDataObject_SetData,
1170   OLEClipbrd_IDataObject_EnumFormatEtc,
1171   OLEClipbrd_IDataObject_DAdvise,
1172   OLEClipbrd_IDataObject_DUnadvise,
1173   OLEClipbrd_IDataObject_EnumDAdvise
1174 };
1175
1176 /*---------------------------------------------------------------------*
1177  *           Internal implementation methods for the OLE clipboard
1178  *---------------------------------------------------------------------*/
1179
1180 /*********************************************************
1181  * Construct the OLEClipbrd class.
1182  */
1183 static ole_clipbrd* OLEClipbrd_Construct(void)
1184 {
1185     ole_clipbrd* This;
1186
1187     This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
1188     if (!This) return NULL;
1189
1190     This->lpvtbl = &OLEClipbrd_IDataObject_VTable;
1191     This->ref = 1;
1192
1193     This->hWndClipboard = NULL;
1194     This->pIDataObjectSrc = NULL;
1195     This->cached_enum = NULL;
1196
1197     return This;
1198 }
1199
1200 static void register_clipboard_formats(void)
1201 {
1202     static const WCHAR DataObjectW[] = { 'D','a','t','a','O','b','j','e','c','t',0 };
1203     static const WCHAR OlePrivateDataW[] = { 'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0 };
1204     static const WCHAR EmbedSourceW[] = { 'E','m','b','e','d',' ','S','o','u','r','c','e',0 };
1205
1206     if(!dataobject_clipboard_format)
1207         dataobject_clipboard_format = RegisterClipboardFormatW(DataObjectW);
1208     if(!ole_priv_data_clipboard_format)
1209         ole_priv_data_clipboard_format = RegisterClipboardFormatW(OlePrivateDataW);
1210     if(!embed_source_clipboard_format)
1211         embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSourceW);
1212 }
1213
1214 /***********************************************************************
1215  * OLEClipbrd_Initialize()
1216  * Initializes the OLE clipboard.
1217  */
1218 void OLEClipbrd_Initialize(void)
1219 {
1220   register_clipboard_formats();
1221
1222   if ( !theOleClipboard )
1223   {
1224     TRACE("()\n");
1225     theOleClipboard = OLEClipbrd_Construct();
1226   }
1227 }
1228
1229
1230 /***********************************************************************
1231  * OLEClipbrd_UnInitialize()
1232  * Un-Initializes the OLE clipboard
1233  */
1234 void OLEClipbrd_UnInitialize(void)
1235 {
1236   TRACE("()\n");
1237   /*
1238    * Destroy the clipboard if no one holds a reference to us.
1239    * Note that the clipboard was created with a reference count of 1.
1240    */
1241   if ( theOleClipboard && (theOleClipboard->ref <= 1) )
1242   {
1243     OLEClipbrd_Destroy( theOleClipboard );
1244     theOleClipboard = NULL;
1245   }
1246   else
1247   {
1248     WARN( "() : OLEClipbrd_UnInitialize called while client holds an IDataObject reference!\n");
1249   }
1250 }
1251
1252 /***********************************************************************
1253  * OLEClipbrd_CreateWindow()
1254  * Create the clipboard window
1255  */
1256 static HWND OLEClipbrd_CreateWindow(void)
1257 {
1258     WNDCLASSEXW class;
1259     static const WCHAR ole32W[] = {'o','l','e','3','2',0};
1260     static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
1261     HINSTANCE hinst = GetModuleHandleW(ole32W);
1262
1263     class.cbSize         = sizeof(class);
1264     class.style          = 0;
1265     class.lpfnWndProc    = clipbrd_wndproc;
1266     class.cbClsExtra     = 0;
1267     class.cbWndExtra     = 0;
1268     class.hInstance      = hinst;
1269     class.hIcon          = 0;
1270     class.hCursor        = 0;
1271     class.hbrBackground  = 0;
1272     class.lpszMenuName   = NULL;
1273     class.lpszClassName  = clipbrd_wndclass;
1274     class.hIconSm        = NULL;
1275
1276     RegisterClassExW(&class);
1277
1278     return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
1279                          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
1280                          NULL, NULL, hinst, 0);
1281 }
1282
1283 /*********************************************************************
1284  *          set_clipboard_formats
1285  *
1286  * Enumerate all formats supported by the source and make
1287  * those formats available using delayed rendering using SetClipboardData.
1288  * Cache the enumeration list and make that list visibile as the
1289  * 'Ole Private Data' format on the clipboard.
1290  *
1291  */
1292 static HRESULT set_clipboard_formats(ole_clipbrd *clipbrd, IDataObject *data)
1293 {
1294     HRESULT hr;
1295     FORMATETC fmt;
1296     IEnumFORMATETC *enum_fmt;
1297     HGLOBAL priv_data_handle;
1298     DWORD target_offset;
1299     ole_priv_data *priv_data;
1300     DWORD count = 0, needed = sizeof(*priv_data), idx;
1301
1302     hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
1303     if(FAILED(hr)) return hr;
1304
1305     while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1306     {
1307         count++;
1308         needed += sizeof(priv_data->entries[0]);
1309         if(fmt.ptd)
1310         {
1311             needed += fmt.ptd->tdSize;
1312             CoTaskMemFree(fmt.ptd);
1313         }
1314     }
1315
1316     /* Windows pads the list with two empty ole_priv_data_entries, one
1317      * after the entries array and one after the target device data.
1318      * Allocating with zero init to zero these pads. */
1319
1320     needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
1321     priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
1322     priv_data = GlobalLock(priv_data_handle);
1323
1324     priv_data->unk1 = 0;
1325     priv_data->size = needed;
1326     priv_data->unk2 = 1;
1327     priv_data->count = count;
1328     priv_data->unk3[0] = 0;
1329     priv_data->unk3[1] = 0;
1330
1331     IEnumFORMATETC_Reset(enum_fmt);
1332
1333     idx = 0;
1334     target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
1335
1336     while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
1337     {
1338         TRACE("%s\n", dump_fmtetc(&fmt));
1339
1340         priv_data->entries[idx].fmtetc = fmt;
1341         if(fmt.ptd)
1342         {
1343             memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
1344             priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
1345             target_offset += fmt.ptd->tdSize;
1346             CoTaskMemFree(fmt.ptd);
1347         }
1348
1349         priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
1350         priv_data->entries[idx].unk[0] = 0;
1351         priv_data->entries[idx].unk[1] = 0;
1352
1353         if (priv_data->entries[idx].first_use)
1354             SetClipboardData(fmt.cfFormat, NULL);
1355
1356         idx++;
1357     }
1358
1359     IEnumFORMATETC_Release(enum_fmt);
1360
1361     /* Cache the list and fixup any target device offsets to ptrs */
1362     clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
1363     memcpy(clipbrd->cached_enum, priv_data, needed);
1364     for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
1365         if(clipbrd->cached_enum->entries[idx].fmtetc.ptd)
1366             clipbrd->cached_enum->entries[idx].fmtetc.ptd =
1367                 (DVTARGETDEVICE *)((char*)clipbrd->cached_enum + (DWORD)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
1368
1369     GlobalUnlock(priv_data_handle);
1370     SetClipboardData(ole_priv_data_clipboard_format, priv_data_handle);
1371
1372     return S_OK;
1373 }
1374
1375 /*********************************************************************
1376  *          set_dataobject_format
1377  *
1378  * Windows creates a 'DataObject' clipboard format that contains the
1379  * clipboard window's HWND or NULL if the Ole clipboard has been flushed.
1380  */
1381 static HRESULT set_dataobject_format(HWND hwnd)
1382 {
1383     HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
1384     HWND *data;
1385
1386     if(!h) return E_OUTOFMEMORY;
1387
1388     data = GlobalLock(h);
1389     *data = hwnd;
1390     GlobalUnlock(h);
1391
1392     if(!SetClipboardData(dataobject_clipboard_format, h))
1393     {
1394         GlobalFree(h);
1395         return CLIPBRD_E_CANT_SET;
1396     }
1397
1398     return S_OK;
1399 }
1400
1401 /*---------------------------------------------------------------------*
1402  *           Win32 OLE clipboard API
1403  *---------------------------------------------------------------------*/
1404
1405 /***********************************************************************
1406  *           OleSetClipboard     [OLE32.@]
1407  *  Places a pointer to the specified data object onto the clipboard,
1408  *  making the data object accessible to the OleGetClipboard function.
1409  *
1410  * RETURNS
1411  *
1412  *    S_OK                  IDataObject pointer placed on the clipboard
1413  *    CLIPBRD_E_CANT_OPEN   OpenClipboard failed
1414  *    CLIPBRD_E_CANT_EMPTY  EmptyClipboard failed
1415  *    CLIPBRD_E_CANT_CLOSE  CloseClipboard failed
1416  *    CLIPBRD_E_CANT_SET    SetClipboard failed
1417  */
1418
1419 HRESULT WINAPI OleSetClipboard(IDataObject* pDataObj)
1420 {
1421   HRESULT hr;
1422   ole_clipbrd *clipbrd;
1423
1424   TRACE("(%p)\n", pDataObj);
1425
1426   if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1427
1428   /*
1429    * If the Ole clipboard window hasn't been created yet, create it now.
1430    */
1431   if ( !clipbrd->hWndClipboard )
1432     clipbrd->hWndClipboard = OLEClipbrd_CreateWindow();
1433   if ( !clipbrd->hWndClipboard ) return E_FAIL;
1434
1435   if ( !OpenClipboard(clipbrd->hWndClipboard) ) return CLIPBRD_E_CANT_OPEN;
1436
1437   /*
1438    * Empty the current clipboard and make our window the clipboard owner
1439    * NOTE: This will trigger a WM_DESTROYCLIPBOARD message
1440    */
1441   if ( !EmptyClipboard() )
1442   {
1443     hr = CLIPBRD_E_CANT_EMPTY;
1444     goto end;
1445   }
1446
1447   /*
1448    * If we are already holding on to an IDataObject first release that.
1449    */
1450   if ( clipbrd->pIDataObjectSrc )
1451   {
1452     IDataObject_Release(clipbrd->pIDataObjectSrc);
1453     clipbrd->pIDataObjectSrc = NULL;
1454     HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1455     clipbrd->cached_enum = NULL;
1456   }
1457
1458   /* A NULL value indicates that the clipboard should be emptied. */
1459   clipbrd->pIDataObjectSrc = pDataObj;
1460   if ( pDataObj )
1461   {
1462     IDataObject_AddRef(clipbrd->pIDataObjectSrc);
1463     hr = set_clipboard_formats(clipbrd, pDataObj);
1464     if(FAILED(hr)) goto end;
1465   }
1466
1467   hr = set_dataobject_format(clipbrd->hWndClipboard);
1468
1469 end:
1470
1471   if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1472
1473   if ( FAILED(hr) )
1474   {
1475     if (clipbrd->pIDataObjectSrc)
1476     {
1477       IDataObject_Release(clipbrd->pIDataObjectSrc);
1478       clipbrd->pIDataObjectSrc = NULL;
1479       HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1480       clipbrd->cached_enum = NULL;
1481     }
1482   }
1483
1484   return hr;
1485 }
1486
1487
1488 /***********************************************************************
1489  * OleGetClipboard [OLE32.@]
1490  * Returns a pointer to our internal IDataObject which represents the conceptual
1491  * state of the Windows clipboard. If the current clipboard already contains
1492  * an IDataObject, our internal IDataObject will delegate to this object.
1493  */
1494 HRESULT WINAPI OleGetClipboard(IDataObject** ppDataObj)
1495 {
1496     HRESULT hr;
1497     ole_clipbrd *clipbrd;
1498     TRACE("()\n");
1499
1500     if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1501
1502     hr = IDataObject_QueryInterface( (IDataObject*)&(clipbrd->lpvtbl),
1503                                      &IID_IDataObject,  (void**)ppDataObj);
1504     return hr;
1505 }
1506
1507 /******************************************************************************
1508  *              OleFlushClipboard        [OLE32.@]
1509  *  Renders the data from the source IDataObject into the windows clipboard
1510  *
1511  *  TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
1512  *  by copying the storage into global memory. Subsequently the default
1513  *  data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
1514  *  back to TYMED_IStorage.
1515  */
1516 HRESULT WINAPI OleFlushClipboard(void)
1517 {
1518   IEnumFORMATETC* penumFormatetc = NULL;
1519   FORMATETC rgelt;
1520   HRESULT hr;
1521   ole_clipbrd *clipbrd;
1522
1523   TRACE("()\n");
1524
1525   if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1526
1527   /*
1528    * Already flushed or no source DataObject? Nothing to do.
1529    */
1530   if (!clipbrd->pIDataObjectSrc)
1531     return S_OK;
1532
1533   if (!OpenClipboard(clipbrd->hWndClipboard))
1534     return CLIPBRD_E_CANT_OPEN;
1535
1536   /*
1537    * Render all HGLOBAL formats supported by the source into
1538    * the windows clipboard.
1539    */
1540   if ( FAILED( hr = IDataObject_EnumFormatEtc( clipbrd->pIDataObjectSrc,
1541                                                DATADIR_GET,
1542                                                &penumFormatetc) ))
1543     goto end;
1544
1545
1546   while ( S_OK == IEnumFORMATETC_Next(penumFormatetc, 1, &rgelt, NULL) )
1547   {
1548     if ( rgelt.tymed == TYMED_HGLOBAL )
1549     {
1550       CHAR szFmtName[80];
1551       TRACE("(cfFormat=%d:%s)\n", rgelt.cfFormat,
1552             GetClipboardFormatNameA(rgelt.cfFormat, szFmtName, sizeof(szFmtName)-1)
1553               ? szFmtName : "");
1554
1555       if ( FAILED(render_format( clipbrd->pIDataObjectSrc, &rgelt )) )
1556         continue;
1557     }
1558   }
1559
1560   IEnumFORMATETC_Release(penumFormatetc);
1561
1562   hr = set_dataobject_format(NULL);
1563
1564   IDataObject_Release(clipbrd->pIDataObjectSrc);
1565   clipbrd->pIDataObjectSrc = NULL;
1566   HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
1567   clipbrd->cached_enum = NULL;
1568
1569 end:
1570
1571   if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
1572
1573   return hr;
1574 }
1575
1576
1577 /***********************************************************************
1578  *           OleIsCurrentClipboard [OLE32.@]
1579  */
1580 HRESULT WINAPI OleIsCurrentClipboard(IDataObject *pDataObject)
1581 {
1582   HRESULT hr;
1583   ole_clipbrd *clipbrd;
1584   TRACE("()\n");
1585
1586   if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
1587
1588   if (pDataObject == NULL)
1589     return S_FALSE;
1590
1591   return (pDataObject == clipbrd->pIDataObjectSrc) ? S_OK : S_FALSE;
1592 }