ole/clipboard.c

   1 /*
   2  *  OLE 2 clipboard support
   3  *
   4  *      Copyright 1999  Noel Borthwick <noel@macadamian.com>
   5  *
   6  * NOTES:
   7  *    This file contains the implementation for the OLE Clipboard and its
   8  *    internal interfaces. The OLE clipboard interacts with an IDataObject
   9  *    interface via the OleSetClipboard, OleGetClipboard and
  10  *    OleIsCurrentClipboard API's. An internal IDataObject delegates
  11  *    to a client supplied IDataObject or the WIN32 clipboard API depending
  12  *    on whether OleSetClipboard has been invoked.
  13  *    Here are some operating scenarios:
  14  *
  15  *    1. OleSetClipboard called: In this case the internal IDataObject
  16  *       delegates to the client supplied IDataObject. Additionally OLE takes
  17  *       ownership of the Windows clipboard and any HGLOCBAL IDataObject
  18  *       items are placed on the Windows clipboard. This allows non OLE aware
  19  *       applications to access these. A local WinProc fields WM_RENDERFORMAT
  20  *       and WM_RENDERALLFORMATS messages in this case.
  21  *
  22  *    2. OleGetClipboard called without previous OleSetClipboard. Here the internal
  23  *       IDataObject functionality wraps around the WIN32 clipboard API.
  24  *
  25  *    3. OleGetClipboard called after previous OleSetClipboard. Here the internal
  26  *       IDataObject delegates to the source IDataObjects functionality directly,
  27  *       thereby bypassing the Windows clipboard.
  28  *
  29  *    Implementation references : Inside OLE 2'nd  edition by Kraig Brockschmidt
  30  *
  31  * TODO:
  32  *    - Support for pasting between different processes. OLE clipboard support
  33  *      currently works only for in process copy and paste. Since we internally
  34  *      store a pointer to the source's IDataObject and delegate to that, this
  35  *      will fail if the IDataObject client belongs to a different process.
  36  *    - IDataObject::GetDataHere is not implemented
  37  *    - OleFlushClipboard needs to additionally handle TYMED_IStorage media
  38  *      by copying the storage into global memory. Subsequently the default
  39  *      data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
  40  *      back to TYMED_IStorage.
  41  *    - OLE1 compatibility formats to be synthesized from OLE2 formats and put on
  42  *      clipboard in OleSetClipboard.
  43  *
  44  */
  45
  46 #include <assert.h>
  47 #include "winuser.h"
  48 #include "winerror.h"
  49 #include "ole2.h"
  50 #include "class.h"
  51 #include "debugtools.h"
  52
  53
  54 #define HANDLE_ERROR(err) { hr = err; TRACE("(HRESULT=%lx)\n", (HRESULT)err); goto CLEANUP; }
  55
  56 /* For CoGetMalloc (MEMCTX_TASK is currently ignored) */
  57 #ifndef MEMCTX_TASK
  58   #define MEMCTX_TASK -1
  59 #endif
  60
  61 DEFAULT_DEBUG_CHANNEL(ole)
  62
  63 /****************************************************************************
  64  * OLEClipbrd
  65  * DO NOT add any members before the VTables declaration!
  66  */
  67 struct OLEClipbrd
  68 {
  69   /*
  70    * List all interface VTables here
  71    */
  72   ICOM_VTABLE(IDataObject)*  lpvtbl1;  /* IDataObject VTable */
  73
  74   /*
  75    * The hidden OLE clipboard window. This window is used as the bridge between the
  76    * the OLE and windows clipboard API. (Windows creates one such window per process)
  77    */
  78   HWND                       hWndClipboard;
  79
  80   /*
  81    * Pointer to the source data object (via OleSetClipboard)
  82    */
  83   IDataObject*               pIDataObjectSrc;
  84
  85   /*
  86    * The registered DataObject clipboard format
  87    */
  88   UINT                       cfDataObj;
  89
  90   /*
  91    * The handle to our ourself
  92    */
  93   UINT                       hSelf;
  94
  95   /*
  96    * Reference count of this object
  97    */
  98   ULONG                      ref;
  99 };
 100
 101 typedef struct OLEClipbrd OLEClipbrd;
 102
 103
 104 /****************************************************************************
 105 *   IEnumFORMATETC implementation
 106 *   DO NOT add any members before the VTables declaration!
 107 */
 108 typedef struct
 109 {
 110   /* IEnumFORMATETC VTable */
 111   ICOM_VTABLE(IEnumFORMATETC)* lpvtbl;
 112
 113   /* IEnumFORMATETC fields */
 114   UINT                         posFmt;    /* current enumerator position */
 115   UINT                         countFmt;  /* number of EnumFORMATETC's in array */
 116   LPFORMATETC                  pFmt;      /* array of EnumFORMATETC's */
 117
 118   /*
 119    * Reference count of this object
 120    */
 121   DWORD                        ref;
 122
 123   /*
 124    * IUnknown implementation of the parent data object.
 125    */
 126   IUnknown*                    pUnkDataObj;
 127
 128 } IEnumFORMATETCImpl;
 129
 130
 131 /*
 132  * The one and only OLEClipbrd object which is created by OLEClipbrd_Initialize()
 133  */
 134 static HGLOBAL hTheOleClipboard = 0;
 135 static OLEClipbrd* theOleClipboard = NULL;
 136
 137
 138 /*
 139  * Prototypes for the methods of the OLEClipboard class.
 140  */
 141 extern void OLEClipbrd_Initialize();
 142 extern void OLEClipbrd_UnInitialize();
 143 static OLEClipbrd* OLEClipbrd_Construct();
 144 static void OLEClipbrd_Destroy(OLEClipbrd* ptrToDestroy);
 145 static HWND OLEClipbrd_CreateWindow();
 146 static void OLEClipbrd_DestroyWindow(HWND hwnd);
 147 LRESULT CALLBACK OLEClipbrd_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
 148 static HRESULT OLEClipbrd_RenderFormat(LPFORMATETC pFormatetc);
 149 static HGLOBAL OLEClipbrd_GlobalDupMem( HGLOBAL hGlobalSrc );
 150
 151 /*
 152  * Prototypes for the methods of the OLEClipboard class
 153  * that implement IDataObject methods.
 154  */
 155 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryInterface(
 156             IDataObject*     iface,
 157             REFIID           riid,
 158             void**           ppvObject);
 159 static ULONG WINAPI OLEClipbrd_IDataObject_AddRef(
 160             IDataObject*     iface);
 161 static ULONG WINAPI OLEClipbrd_IDataObject_Release(
 162             IDataObject*     iface);
 163 static HRESULT WINAPI OLEClipbrd_IDataObject_GetData(
 164             IDataObject*     iface,
 165             LPFORMATETC      pformatetcIn,
 166             STGMEDIUM*       pmedium);
 167 static HRESULT WINAPI OLEClipbrd_IDataObject_GetDataHere(
 168             IDataObject*     iface,
 169             LPFORMATETC      pformatetc,
 170             STGMEDIUM*       pmedium);
 171 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryGetData(
 172             IDataObject*     iface,
 173             LPFORMATETC      pformatetc);
 174 static HRESULT WINAPI OLEClipbrd_IDataObject_GetCanonicalFormatEtc(
 175             IDataObject*     iface,
 176             LPFORMATETC      pformatectIn,
 177             LPFORMATETC      pformatetcOut);
 178 static HRESULT WINAPI OLEClipbrd_IDataObject_SetData(
 179             IDataObject*     iface,
 180             LPFORMATETC      pformatetc,
 181             STGMEDIUM*       pmedium,
 182             BOOL             fRelease);
 183 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumFormatEtc(
 184             IDataObject*     iface,
 185             DWORD            dwDirection,
 186             IEnumFORMATETC** ppenumFormatEtc);
 187 static HRESULT WINAPI OLEClipbrd_IDataObject_DAdvise(
 188             IDataObject*     iface,
 189             FORMATETC*       pformatetc,
 190             DWORD            advf,
 191             IAdviseSink*     pAdvSink,
 192             DWORD*           pdwConnection);
 193 static HRESULT WINAPI OLEClipbrd_IDataObject_DUnadvise(
 194             IDataObject*     iface,
 195             DWORD            dwConnection);
 196 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumDAdvise(
 197             IDataObject*     iface,
 198             IEnumSTATDATA**  ppenumAdvise);
 199
 200 /*
 201  * Prototypes for the IEnumFORMATETC methods.
 202  */
 203 static LPENUMFORMATETC OLEClipbrd_IEnumFORMATETC_Construct(UINT cfmt, const FORMATETC afmt[],
 204                                                            LPUNKNOWN pUnkDataObj);
 205 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface(LPENUMFORMATETC iface, REFIID riid,
 206                                                                LPVOID* ppvObj);
 207 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface);
 208 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface);
 209 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next(LPENUMFORMATETC iface, ULONG celt,
 210                                                      FORMATETC* rgelt, ULONG* pceltFethed);
 211 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface, ULONG celt);
 212 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface);
 213 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone(LPENUMFORMATETC iface, LPENUMFORMATETC* ppenum);
 214
 215
 216 /*
 217  * Virtual function table for the OLEClipbrd's exposed IDataObject interface
 218  */
 219 static ICOM_VTABLE(IDataObject) OLEClipbrd_IDataObject_VTable =
 220 {
 221   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 222   OLEClipbrd_IDataObject_QueryInterface,
 223   OLEClipbrd_IDataObject_AddRef,
 224   OLEClipbrd_IDataObject_Release,
 225   OLEClipbrd_IDataObject_GetData,
 226   OLEClipbrd_IDataObject_GetDataHere,
 227   OLEClipbrd_IDataObject_QueryGetData,
 228   OLEClipbrd_IDataObject_GetCanonicalFormatEtc,
 229   OLEClipbrd_IDataObject_SetData,
 230   OLEClipbrd_IDataObject_EnumFormatEtc,
 231   OLEClipbrd_IDataObject_DAdvise,
 232   OLEClipbrd_IDataObject_DUnadvise,
 233   OLEClipbrd_IDataObject_EnumDAdvise
 234 };
 235
 236 /*
 237  * Virtual function table for IEnumFORMATETC interface
 238  */
 239 static struct ICOM_VTABLE(IEnumFORMATETC) efvt =
 240 {
 241   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 242   OLEClipbrd_IEnumFORMATETC_QueryInterface,
 243   OLEClipbrd_IEnumFORMATETC_AddRef,
 244   OLEClipbrd_IEnumFORMATETC_Release,
 245   OLEClipbrd_IEnumFORMATETC_Next,
 246   OLEClipbrd_IEnumFORMATETC_Skip,
 247   OLEClipbrd_IEnumFORMATETC_Reset,
 248   OLEClipbrd_IEnumFORMATETC_Clone
 249 };
 250
 251 /*
 252  * Name of our registered OLE clipboard window class
 253  */
 254 CHAR OLEClipbrd_WNDCLASS[] = "CLIPBRDWNDCLASS";
 255
 256 /*
 257  *  If we need to store state info we can store it here.
 258  *  For now we dont need this functionality.
 259  *
 260 typedef struct tagClipboardWindowInfo
 261 {
 262 } ClipboardWindowInfo;
 263  */
 264
 265 /*---------------------------------------------------------------------*
 266  *           Win32 OLE clipboard API
 267  *---------------------------------------------------------------------*/
 268
 269 /***********************************************************************
 270  *           OleSetClipboard     [OLE32.127]
 271  *  Places a pointer to the specified data object onto the clipboard,
 272  *  making the data object accessible to the OleGetClipboard function.
 273  *
 274  * RETURNS:
 275  *
 276  *    S_OK                  IDataObject pointer placed on the clipboard
 277  *    CLIPBRD_E_CANT_OPEN   OpenClipboard failed
 278  *    CLIPBRD_E_CANT_EMPTY  EmptyClipboard failed
 279  *    CLIPBRD_E_CANT_CLOSE  CloseClipboard failed
 280  *    CLIPBRD_E_CANT_SET    SetClipboard failed
 281  */
 282
 283 HRESULT WINAPI OleSetClipboard(IDataObject* pDataObj)
 284 {
 285   HRESULT hr = S_OK;
 286   IEnumFORMATETC* penumFormatetc = NULL;
 287   FORMATETC rgelt;
 288   BOOL bClipboardOpen = FALSE;
 289 /*
 290   HGLOBAL hDataObject = 0;
 291   OLEClipbrd **ppDataObject;
 292 */
 293
 294   TRACE("(%p)\n", pDataObj);
 295
 296   /*
 297    * Make sure we have a clipboard object
 298    */
 299   OLEClipbrd_Initialize();
 300
 301   /*
 302    * If the Ole clipboard window hasn't been created yet, create it now.
 303    */
 304   if ( !theOleClipboard->hWndClipboard )
 305     theOleClipboard->hWndClipboard = OLEClipbrd_CreateWindow();
 306
 307   if ( !theOleClipboard->hWndClipboard ) /* sanity check */
 308     HANDLE_ERROR( E_FAIL );
 309
 310   /*
 311    * Open the Windows clipboard, associating it with our hidden window
 312    */
 313   if ( !(bClipboardOpen = OpenClipboard(theOleClipboard->hWndClipboard)) )
 314     HANDLE_ERROR( CLIPBRD_E_CANT_OPEN );
 315
 316   /*
 317    * Empty the current clipboard and make our window the clipboard owner
 318    * NOTE: This will trigger a WM_DESTROYCLIPBOARD message
 319    */
 320   if ( !EmptyClipboard() )
 321     HANDLE_ERROR( CLIPBRD_E_CANT_EMPTY );
 322
 323   /*
 324    * If we are already holding on to an IDataObject first release that.
 325    */
 326   if ( theOleClipboard->pIDataObjectSrc )
 327   {
 328     IDataObject_Release(theOleClipboard->pIDataObjectSrc);
 329     theOleClipboard->pIDataObjectSrc = NULL;
 330   }
 331
 332   /*
 333    * AddRef the data object passed in and save its pointer.
 334    * A NULL value indicates that the clipboard should be emptied.
 335    */
 336   theOleClipboard->pIDataObjectSrc = pDataObj;
 337   if ( pDataObj )
 338   {
 339     IDataObject_AddRef(theOleClipboard->pIDataObjectSrc);
 340   }
 341
 342   /*
 343    * Enumerate all HGLOBAL formats supported by the source and make
 344    * those formats available using delayed rendering using SetClipboardData.
 345    * Only global memory based data items may be made available to non-OLE
 346    * applications via the standard Windows clipboard API. Data based on other
 347    * mediums(non TYMED_HGLOBAL) can only be accessed via the Ole Clipboard API.
 348    *
 349    * TODO: Do we need to additionally handle TYMED_IStorage media by copying
 350    * the storage into global memory?
 351    */
 352   if ( pDataObj )
 353   {
 354     if ( FAILED(hr = IDataObject_EnumFormatEtc( pDataObj,
 355                                                 DATADIR_GET,
 356                                                 &penumFormatetc )))
 357     {
 358       HANDLE_ERROR( hr );
 359     }
 360
 361     while ( S_OK == IEnumFORMATETC_Next(penumFormatetc, 1, &rgelt, NULL) )
 362     {
 363       if ( rgelt.tymed == TYMED_HGLOBAL )
 364       {
 365         CHAR szFmtName[80];
 366         TRACE("(cfFormat=%d:%s)\n", rgelt.cfFormat,
 367               GetClipboardFormatNameA(rgelt.cfFormat, szFmtName, sizeof(szFmtName)-1)
 368                 ? szFmtName : "");
 369
 370         SetClipboardData( rgelt.cfFormat, (HANDLE)NULL);
 371       }
 372     }
 373     IEnumFORMATETC_Release(penumFormatetc);
 374   }
 375
 376   /*
 377    * Windows additionally creates a new "DataObject" clipboard format
 378    * and stores in on the clipboard. We could possibly store a pointer
 379    * to our internal IDataObject interface on the clipboard. I'm not
 380    * sure what the use of this is though.
 381    * Enable the code below for this functionality.
 382    */
 383 /*
 384    theOleClipboard->cfDataObj = RegisterClipboardFormatA("DataObject");
 385    hDataObject = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT,
 386                              sizeof(OLEClipbrd *));
 387    if (hDataObject==0)
 388      HANDLE_ERROR( E_OUTOFMEMORY );
 389
 390    ppDataObject = (OLEClipbrd**)GlobalLock(hDataObject);
 391    *ppDataObject = theOleClipboard;
 392    GlobalUnlock(hDataObject);
 393
 394    if ( !SetClipboardData( theOleClipboard->cfDataObj, hDataObject ) )
 395      HANDLE_ERROR( CLIPBRD_E_CANT_SET );
 396 */
 397
 398   hr = S_OK;
 399
 400 CLEANUP:
 401
 402   /*
 403    * Close Windows clipboard (It remains associated with our window)
 404    */
 405   if ( bClipboardOpen && !CloseClipboard() )
 406     hr = CLIPBRD_E_CANT_CLOSE;
 407
 408   /*
 409    * Release the source IDataObject if something failed
 410    */
 411   if ( FAILED(hr) )
 412   {
 413     if (theOleClipboard->pIDataObjectSrc)
 414     {
 415       IDataObject_Release(theOleClipboard->pIDataObjectSrc);
 416       theOleClipboard->pIDataObjectSrc = NULL;
 417     }
 418   }
 419
 420   return hr;
 421 }
 422
 423
 424 /***********************************************************************
 425  * OleGetClipboard32 [OLE32.105]
 426  * Returns a pointer to our internal IDataObject which represents the conceptual
 427  * state of the Windows clipboard. If the current clipboard already contains
 428  * an IDataObject, our internal IDataObject will delegate to this object.
 429  */
 430 HRESULT WINAPI OleGetClipboard(IDataObject** ppDataObj)
 431 {
 432   HRESULT hr = S_OK;
 433   TRACE("()\n");
 434
 435   /*
 436    * Make sure we have a clipboard object
 437    */
 438   OLEClipbrd_Initialize();
 439
 440   if (!theOleClipboard)
 441     return E_OUTOFMEMORY;
 442
 443   /* Return a reference counted IDataObject */
 444   hr = IDataObject_QueryInterface( (IDataObject*)&(theOleClipboard->lpvtbl1),
 445                                    &IID_IDataObject,  (void**)ppDataObj);
 446   return hr;
 447 }
 448
 449 /***********************************************************************
 450  *           OleFlushClipboard   [OLE2.76]
 451  */
 452
 453 HRESULT WINAPI OleFlushClipboard16(void)
 454
 455 {
 456   return OleFlushClipboard();
 457 }
 458
 459
 460 /******************************************************************************
 461  *              OleFlushClipboard        [OLE32.103]
 462  *  Renders the data from the source IDataObject into the windows clipboard
 463  *
 464  *  TODO: OleFlushClipboard needs to additionally handle TYMED_IStorage media
 465  *  by copying the storage into global memory. Subsequently the default
 466  *  data object exposed through OleGetClipboard must convert this TYMED_HGLOBAL
 467  *  back to TYMED_IStorage.
 468  */
 469 HRESULT WINAPI OleFlushClipboard()
 470 {
 471   IEnumFORMATETC* penumFormatetc = NULL;
 472   FORMATETC rgelt;
 473   HRESULT hr = S_OK;
 474   BOOL bClipboardOpen = FALSE;
 475
 476   TRACE("()\n");
 477
 478   /*
 479    * Make sure we have a clipboard object
 480    */
 481   OLEClipbrd_Initialize();
 482
 483   /*
 484    * Already flushed or no source DataObject? Nothing to do.
 485    */
 486   if (!theOleClipboard->pIDataObjectSrc)
 487     return S_OK;
 488
 489   /*
 490    * Open the Windows clipboard
 491    */
 492   if ( !(bClipboardOpen = OpenClipboard(theOleClipboard->hWndClipboard)) )
 493     HANDLE_ERROR( CLIPBRD_E_CANT_OPEN );
 494
 495   /*
 496    * Empty the current clipboard
 497    */
 498   if ( !EmptyClipboard() )
 499     HANDLE_ERROR( CLIPBRD_E_CANT_EMPTY );
 500
 501   /*
 502    * Render all HGLOBAL formats supported by the source into
 503    * the windows clipboard.
 504    */
 505   if ( FAILED( hr = IDataObject_EnumFormatEtc( (IDataObject*)&(theOleClipboard->lpvtbl1),
 506                                                DATADIR_GET,
 507                                                &penumFormatetc) ))
 508   {
 509     HANDLE_ERROR( hr );
 510   }
 511
 512   while ( S_OK == IEnumFORMATETC_Next(penumFormatetc, 1, &rgelt, NULL) )
 513   {
 514     if ( rgelt.tymed == TYMED_HGLOBAL )
 515     {
 516       CHAR szFmtName[80];
 517       TRACE("(cfFormat=%d:%s)\n", rgelt.cfFormat,
 518             GetClipboardFormatNameA(rgelt.cfFormat, szFmtName, sizeof(szFmtName)-1)
 519               ? szFmtName : "");
 520
 521       /*
 522        * Render the clipboard data
 523        */
 524       if ( FAILED(OLEClipbrd_RenderFormat( &rgelt )) )
 525         continue;
 526     }
 527   }
 528
 529   IEnumFORMATETC_Release(penumFormatetc);
 530
 531   /*
 532    * Release the data object we are holding on to
 533    */
 534   if ( theOleClipboard->pIDataObjectSrc )
 535   {
 536     IDataObject_Release(theOleClipboard->pIDataObjectSrc);
 537     theOleClipboard->pIDataObjectSrc = NULL;
 538   }
 539
 540 CLEANUP:
 541
 542   /*
 543    * Close Windows clipboard (It remains associated with our window)
 544    */
 545   if ( bClipboardOpen && !CloseClipboard() )
 546     hr = CLIPBRD_E_CANT_CLOSE;
 547
 548   return hr;
 549 }
 550
 551
 552 /***********************************************************************
 553  *           OleIsCurrentClipboard32 [OLE32.110]
 554  */
 555 HRESULT WINAPI OleIsCurrentClipboard (  IDataObject *pDataObject)
 556 {
 557   TRACE("()\n");
 558   /*
 559    * Make sure we have a clipboard object
 560    */
 561   OLEClipbrd_Initialize();
 562
 563   if (!theOleClipboard)
 564     return E_OUTOFMEMORY;
 565
 566   return (pDataObject == theOleClipboard->pIDataObjectSrc) ? S_OK : S_FALSE;
 567 }
 568
 569
 570 /*---------------------------------------------------------------------*
 571  *           Internal implementation methods for the OLE clipboard
 572  *---------------------------------------------------------------------*/
 573
 574 /***********************************************************************
 575  * OLEClipbrd_Initialize()
 576  * Initializes the OLE clipboard.
 577  */
 578 void OLEClipbrd_Initialize()
 579 {
 580   /*
 581    * Create the clipboard if necesary
 582    */
 583   if ( !theOleClipboard )
 584   {
 585     TRACE("()\n");
 586     theOleClipboard = OLEClipbrd_Construct();
 587   }
 588 }
 589
 590
 591 /***********************************************************************
 592  * OLEClipbrd_UnInitialize()
 593  * Un-Initializes the OLE clipboard
 594  */
 595 void OLEClipbrd_UnInitialize()
 596 {
 597   TRACE("()\n");
 598   /*
 599    * Destroy the clipboard if no one holds a reference to us.
 600    * Note that the clipboard was created with a reference count of 1.
 601    */
 602   if ( theOleClipboard && (theOleClipboard->ref <= 1) )
 603   {
 604     OLEClipbrd_Destroy( theOleClipboard );
 605   }
 606   else
 607   {
 608     WARN( "() : OLEClipbrd_UnInitialize called while client holds an IDataObject reference!\n");
 609   }
 610 }
 611
 612
 613 /*********************************************************
 614  * Construct the OLEClipbrd class.
 615  */
 616 static OLEClipbrd* OLEClipbrd_Construct()
 617 {
 618   OLEClipbrd* newObject = NULL;
 619   HGLOBAL hNewObject = 0;
 620
 621   /*
 622    * Allocate space for the object. We use GlobalAlloc since we need
 623    * an HGLOBAL to expose our DataObject as a registered clipboard type.
 624    */
 625   hNewObject = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE|GMEM_ZEROINIT,
 626                            sizeof(OLEClipbrd));
 627   if (hNewObject==0)
 628     return NULL;
 629
 630   /*
 631    * Lock the handle for the entire lifetime of the clipboard.
 632    */
 633   newObject = GlobalLock(hNewObject);
 634
 635   /*
 636    * Initialize the virtual function table.
 637    */
 638   newObject->lpvtbl1 = &OLEClipbrd_IDataObject_VTable;
 639
 640   /*
 641    * Start with one reference count. The caller of this function
 642    * must release the interface pointer when it is done.
 643    */
 644   newObject->ref = 1;
 645
 646   newObject->hSelf = hNewObject;
 647
 648   /*
 649    * The Ole clipboard is a singleton - save the global handle and pointer
 650    */
 651   theOleClipboard = newObject;
 652   hTheOleClipboard = hNewObject;
 653
 654   return theOleClipboard;
 655 }
 656
 657 static void OLEClipbrd_Destroy(OLEClipbrd* ptrToDestroy)
 658 {
 659   TRACE("()\n");
 660
 661   if ( !ptrToDestroy )
 662     return;
 663
 664   /*
 665    * Destroy the Ole clipboard window
 666    */
 667   if ( ptrToDestroy->hWndClipboard )
 668     OLEClipbrd_DestroyWindow(ptrToDestroy->hWndClipboard);
 669
 670   /*
 671    * Free the actual OLE Clipboard structure.
 672    */
 673   TRACE("() - Destroying clipboard data object.\n");
 674   GlobalUnlock(ptrToDestroy->hSelf);
 675   GlobalFree(ptrToDestroy->hSelf);
 676
 677   /*
 678    * The Ole clipboard is a singleton (ptrToDestroy == theOleClipboard)
 679    */
 680   theOleClipboard = NULL;
 681   hTheOleClipboard = 0;
 682 }
 683
 684
 685 /***********************************************************************
 686  * OLEClipbrd_CreateWindow()
 687  * Create the clipboard window
 688  */
 689 static HWND OLEClipbrd_CreateWindow()
 690 {
 691   HWND hwnd = 0;
 692   WNDCLASSEXA wcex;
 693   ATOM atom;
 694
 695   /*
 696    * Register the clipboard window class if necessary
 697    */
 698
 699   if ( !( atom = GlobalFindAtomA(OLEClipbrd_WNDCLASS) ) ||
 700         !( CLASS_FindClassByAtom(atom, 0) ) )
 701   {
 702     ZeroMemory( &wcex, sizeof(WNDCLASSEXA));
 703
 704     wcex.cbSize         = sizeof(WNDCLASSEXA);
 705     /* Windows creates this class with a style mask of 0
 706      * We dont bother doing this since the FindClassByAtom code
 707      * would have to be changed to deal with this idiosyncracy. */
 708     wcex.style          = CS_GLOBALCLASS;
 709     wcex.lpfnWndProc    = (WNDPROC)OLEClipbrd_WndProc;
 710     wcex.hInstance      = 0;
 711     wcex.lpszClassName  = OLEClipbrd_WNDCLASS;
 712
 713     RegisterClassExA(&wcex);
 714   }
 715
 716   /*
 717    * Create a hidden window to receive OLE clipboard messages
 718    */
 719
 720 /*
 721  *  If we need to store state info we can store it here.
 722  *  For now we dont need this functionality.
 723  *   ClipboardWindowInfo clipboardInfo;
 724  *   ZeroMemory( &trackerInfo, sizeof(ClipboardWindowInfo));
 725  */
 726
 727   hwnd = CreateWindowA(OLEClipbrd_WNDCLASS,
 728                                     "ClipboardWindow",
 729                                     WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
 730                                     CW_USEDEFAULT, CW_USEDEFAULT,
 731                                     CW_USEDEFAULT, CW_USEDEFAULT,
 732                                     0,
 733                                     0,
 734                                     0,
 735                                     0 /*(LPVOID)&clipboardInfo */);
 736
 737   return hwnd;
 738 }
 739
 740 /***********************************************************************
 741  * OLEClipbrd_DestroyWindow(HWND)
 742  * Destroy the clipboard window and unregister its class
 743  */
 744 static void OLEClipbrd_DestroyWindow(HWND hwnd)
 745 {
 746   /*
 747    * Destroy clipboard window and unregister its WNDCLASS
 748    */
 749   DestroyWindow(hwnd);
 750   UnregisterClassA( OLEClipbrd_WNDCLASS, 0 );
 751 }
 752
 753 /***********************************************************************
 754  * OLEClipbrd_WndProc(HWND, unsigned, WORD, LONG)
 755  * Processes messages sent to the OLE clipboard window.
 756  * Note that we will intercept messages in our WndProc only when data
 757  * has been placed in the clipboard via OleSetClipboard().
 758  * i.e. Only when OLE owns the windows clipboard.
 759  */
 760 LRESULT CALLBACK OLEClipbrd_WndProc
 761   (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 762 {
 763   switch (message)
 764   {
 765     /*
 766      * WM_RENDERFORMAT
 767      * We receive this message to allow us to handle delayed rendering of
 768      * a specific clipboard format when an application requests data in
 769      * that format by calling GetClipboardData.
 770      * (Recall that in OleSetClipboard, we used SetClipboardData to
 771      * make all HGLOBAL formats supported by the source IDataObject
 772      * available using delayed rendering)
 773      * On receiving this mesage we must actually render the data in the
 774      * specified format and place it on the clipboard by calling the
 775      * SetClipboardData function.
 776      */
 777     case WM_RENDERFORMAT:
 778     {
 779       FORMATETC rgelt;
 780
 781       ZeroMemory( &rgelt, sizeof(FORMATETC));
 782
 783       /*
 784        * Initialize FORMATETC to a Windows clipboard friendly format
 785        */
 786       rgelt.cfFormat = (UINT) wParam;
 787       rgelt.dwAspect = DVASPECT_CONTENT;
 788       rgelt.lindex = -1;
 789       rgelt.tymed = TYMED_HGLOBAL;
 790
 791       TRACE("(): WM_RENDERFORMAT(cfFormat=%d)\n", rgelt.cfFormat);
 792
 793       /*
 794        * Render the clipboard data.
 795        * (We must have a source data object or we wouldn't be in this WndProc)
 796        */
 797       OLEClipbrd_RenderFormat( &rgelt );
 798
 799       break;
 800     }
 801
 802     /*
 803      * WM_RENDERALLFORMATS
 804      * Sent before the clipboard owner window is destroyed.
 805      * We should receive this message only when OleUninitialize is called
 806      * while we have an IDataObject in the clipboard.
 807      * For the content of the clipboard to remain available to other
 808      * applications, we must render data in all the formats the source IDataObject
 809      * is capable of generating, and place the data on the clipboard by calling
 810      * SetClipboardData.
 811      */
 812     case WM_RENDERALLFORMATS:
 813     {
 814       IEnumFORMATETC* penumFormatetc = NULL;
 815       FORMATETC rgelt;
 816
 817       TRACE("(): WM_RENDERALLFORMATS\n");
 818
 819       /*
 820        * Render all HGLOBAL formats supported by the source into
 821        * the windows clipboard.
 822        */
 823       if ( FAILED( IDataObject_EnumFormatEtc( (IDataObject*)&(theOleClipboard->lpvtbl1),
 824                                  DATADIR_GET, &penumFormatetc) ) )
 825       {
 826         WARN("(): WM_RENDERALLFORMATS failed to retrieve EnumFormatEtc!\n");
 827         return 0;
 828       }
 829
 830       while ( S_OK == IEnumFORMATETC_Next(penumFormatetc, 1, &rgelt, NULL) )
 831       {
 832         if ( rgelt.tymed == TYMED_HGLOBAL )
 833         {
 834           /*
 835            * Render the clipboard data.
 836            */
 837           if ( FAILED(OLEClipbrd_RenderFormat( &rgelt )) )
 838             continue;
 839
 840           TRACE("(): WM_RENDERALLFORMATS(cfFormat=%d)\n", rgelt.cfFormat);
 841         }
 842       }
 843
 844       IEnumFORMATETC_Release(penumFormatetc);
 845
 846       break;
 847     }
 848
 849     /*
 850      * WM_DESTROYCLIPBOARD
 851      * This is sent by EmptyClipboard before the clipboard is emptied.
 852      * We should release any IDataObject we are holding onto when we receive
 853      * this message, since it indicates that the OLE clipboard should be empty
 854      * from this point on.
 855      */
 856     case WM_DESTROYCLIPBOARD:
 857     {
 858       TRACE("(): WM_DESTROYCLIPBOARD\n");
 859       /*
 860        * Release the data object we are holding on to
 861        */
 862       if ( theOleClipboard->pIDataObjectSrc )
 863       {
 864         IDataObject_Release(theOleClipboard->pIDataObjectSrc);
 865         theOleClipboard->pIDataObjectSrc = NULL;
 866       }
 867       break;
 868     }
 869
 870 /*
 871     case WM_ASKCBFORMATNAME:
 872     case WM_CHANGECBCHAIN:
 873     case WM_DRAWCLIPBOARD:
 874     case WM_SIZECLIPBOARD:
 875     case WM_HSCROLLCLIPBOARD:
 876     case WM_VSCROLLCLIPBOARD:
 877     case WM_PAINTCLIPBOARD:
 878 */
 879     default:
 880       return DefWindowProcA(hWnd, message, wParam, lParam);
 881   }
 882
 883   return 0;
 884 }
 885
 886
 887 /***********************************************************************
 888  * OLEClipbrd_RenderFormat(LPFORMATETC)
 889  * Render the clipboard data. Note that this call will delegate to the
 890  * source data object.
 891  * Note: This function assumes it is passed an HGLOBAL format to render.
 892  */
 893 static HRESULT OLEClipbrd_RenderFormat(LPFORMATETC pFormatetc)
 894 {
 895   STGMEDIUM medium;
 896   HGLOBAL hDup;
 897   HRESULT hr = S_OK;
 898
 899   if ( FAILED(hr = IDataObject_GetData((IDataObject*)&(theOleClipboard->lpvtbl1),
 900                                        pFormatetc, &medium)) )
 901   {
 902     WARN("() : IDataObject_GetData failed to render clipboard data! (%lx)\n", hr);
 903     return hr;
 904   }
 905
 906   /*
 907    *  Put a copy of the rendered data back on the clipboard
 908    */
 909
 910   if ( !(hDup = OLEClipbrd_GlobalDupMem(medium.u.hGlobal)) )
 911     HANDLE_ERROR( E_OUTOFMEMORY );
 912
 913   if ( !SetClipboardData( pFormatetc->cfFormat, hDup ) )
 914   {
 915     GlobalFree(hDup);
 916     WARN("() : Failed to set rendered clipboard data into clipboard!\n");
 917   }
 918
 919 CLEANUP:
 920
 921   ReleaseStgMedium(&medium);
 922
 923   return hr;
 924 }
 925
 926
 927 /***********************************************************************
 928  * OLEClipbrd_GlobalDupMem( HGLOBAL )
 929  * Helper method to duplicate an HGLOBAL chunk of memory
 930  */
 931 static HGLOBAL OLEClipbrd_GlobalDupMem( HGLOBAL hGlobalSrc )
 932 {
 933     HGLOBAL hGlobalDest;
 934     PVOID pGlobalSrc, pGlobalDest;
 935     DWORD cBytes;
 936
 937     if ( !hGlobalSrc )
 938       return 0;
 939
 940     cBytes = GlobalSize(hGlobalSrc);
 941     if ( 0 == cBytes )
 942       return 0;
 943
 944     hGlobalDest = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE,
 945                                cBytes );
 946     if ( !hGlobalDest )
 947       return 0;
 948
 949     pGlobalSrc = GlobalLock(hGlobalSrc);
 950     pGlobalDest = GlobalLock(hGlobalDest);
 951     if ( !pGlobalSrc || !pGlobalDest )
 952       return 0;
 953
 954     memcpy(pGlobalDest, pGlobalSrc, cBytes);
 955
 956     GlobalUnlock(hGlobalSrc);
 957     GlobalUnlock(hGlobalDest);
 958
 959     return hGlobalDest;
 960 }
 961
 962
 963 /*---------------------------------------------------------------------*
 964  *  Implementation of the internal IDataObject interface exposed by
 965  *  the OLE clipboard.
 966  *---------------------------------------------------------------------*/
 967
 968
 969 /************************************************************************
 970  * OLEClipbrd_IDataObject_QueryInterface (IUnknown)
 971  *
 972  * See Windows documentation for more details on IUnknown methods.
 973  */
 974 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryInterface(
 975             IDataObject*     iface,
 976             REFIID           riid,
 977             void**           ppvObject)
 978 {
 979   /*
 980    * Declare "This" pointer
 981    */
 982   ICOM_THIS(OLEClipbrd, iface);
 983   char    xriid[50];
 984
 985   WINE_StringFromCLSID((LPCLSID)riid,xriid);
 986   TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObject);
 987
 988   /*
 989    * Perform a sanity check on the parameters.
 990    */
 991   if ( (This==0) || (ppvObject==0) )
 992     return E_INVALIDARG;
 993
 994   /*
 995    * Initialize the return parameter.
 996    */
 997   *ppvObject = 0;
 998
 999   /*
1000    * Compare the riid with the interface IDs implemented by this object.
1001    */
1002   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
1003   {
1004     *ppvObject = iface;
1005   }
1006   else if (memcmp(&IID_IDataObject, riid, sizeof(IID_IDataObject)) == 0)
1007   {
1008     *ppvObject = (IDataObject*)&(This->lpvtbl1);
1009   }
1010   else  /* We only support IUnknown and IDataObject */
1011   {
1012     char clsid[50];
1013
1014     WINE_StringFromCLSID((LPCLSID)riid,clsid);
1015     WARN( "() : asking for unsupported interface %s\n", clsid);
1016
1017     return E_NOINTERFACE;
1018   }
1019
1020   /*
1021    * Query Interface always increases the reference count by one when it is
1022    * successful.
1023    */
1024   IUnknown_AddRef((IUnknown*)*ppvObject);
1025
1026   return S_OK;
1027 }
1028
1029 /************************************************************************
1030  * OLEClipbrd_IDataObject_AddRef (IUnknown)
1031  *
1032  * See Windows documentation for more details on IUnknown methods.
1033  */
1034 static ULONG WINAPI OLEClipbrd_IDataObject_AddRef(
1035             IDataObject*     iface)
1036 {
1037   /*
1038    * Declare "This" pointer
1039    */
1040   ICOM_THIS(OLEClipbrd, iface);
1041
1042   TRACE("(%p)->(count=%lu)\n",This, This->ref);
1043
1044   This->ref++;
1045
1046   return This->ref;
1047 }
1048
1049 /************************************************************************
1050  * OLEClipbrd_IDataObject_Release (IUnknown)
1051  *
1052  * See Windows documentation for more details on IUnknown methods.
1053  */
1054 static ULONG WINAPI OLEClipbrd_IDataObject_Release(
1055             IDataObject*     iface)
1056 {
1057   /*
1058    * Declare "This" pointer
1059    */
1060   ICOM_THIS(OLEClipbrd, iface);
1061
1062   TRACE("(%p)->(count=%lu)\n",This, This->ref);
1063
1064   /*
1065    * Decrease the reference count on this object.
1066    */
1067   This->ref--;
1068
1069   /*
1070    * If the reference count goes down to 0, perform suicide.
1071    */
1072   if (This->ref==0)
1073   {
1074     OLEClipbrd_Destroy(This);
1075   }
1076
1077   return This->ref;
1078 }
1079
1080
1081 /************************************************************************
1082  * OLEClipbrd_IDataObject_GetData (IDataObject)
1083  *
1084  * The OLE Clipboard's implementation of this method delegates to
1085  * a data source if there is one or wraps around the windows clipboard
1086  *
1087  * See Windows documentation for more details on IDataObject methods.
1088  */
1089 static HRESULT WINAPI OLEClipbrd_IDataObject_GetData(
1090             IDataObject*     iface,
1091             LPFORMATETC      pformatetcIn,
1092             STGMEDIUM*       pmedium)
1093 {
1094   HANDLE      hData = 0;
1095   /*
1096    * Declare "This" pointer
1097    */
1098   ICOM_THIS(OLEClipbrd, iface);
1099
1100   if ( !pformatetcIn || !pformatetcIn || !pmedium )
1101     return E_INVALIDARG;
1102
1103   TRACE("(%p, %p)\n", iface, pformatetcIn);
1104
1105   /*
1106    * If we have a data source placed on the clipboard (via OleSetClipboard)
1107    * simply delegate to the source object's QueryGetData
1108    * NOTE: This code assumes that the IDataObject is in the same address space!
1109    * We will need to add marshalling support when Wine handles multiple processes.
1110    */
1111   if ( This->pIDataObjectSrc )
1112   {
1113     return IDataObject_GetData(This->pIDataObjectSrc, pformatetcIn, pmedium);
1114   }
1115
1116   if ( pformatetcIn->lindex != -1 )
1117     return DV_E_LINDEX;
1118   if ( (pformatetcIn->tymed & TYMED_HGLOBAL) != TYMED_HGLOBAL )
1119     return DV_E_TYMED;
1120 /*
1121    if ( pformatetcIn->dwAspect != DVASPECT_CONTENT )
1122      return DV_E_DVASPECT;
1123 */
1124
1125   /*
1126    * Otherwise, delegate to the Windows clipboard function GetClipboardData
1127    */
1128   hData = GetClipboardData(pformatetcIn->cfFormat);
1129
1130   /*
1131    * Return the clipboard data in the storage medium structure
1132    */
1133   pmedium->tymed = (hData == 0) ? TYMED_NULL : TYMED_HGLOBAL;
1134   pmedium->u.hGlobal = (HGLOBAL)hData;
1135   pmedium->pUnkForRelease = NULL;
1136
1137   return (hData == 0) ? DV_E_FORMATETC : S_OK;
1138 }
1139
1140 static HRESULT WINAPI OLEClipbrd_IDataObject_GetDataHere(
1141             IDataObject*     iface,
1142             LPFORMATETC      pformatetc,
1143             STGMEDIUM*       pmedium)
1144 {
1145   FIXME(": Stub\n");
1146   return E_NOTIMPL;
1147 }
1148
1149 /************************************************************************
1150  * OLEClipbrd_IDataObject_QueryGetData (IDataObject)
1151  *
1152  * The OLE Clipboard's implementation of this method delegates to
1153  * a data source if there is one or wraps around the windows clipboard
1154  * function IsClipboardFormatAvailable() otherwise.
1155  *
1156  * See Windows documentation for more details on IDataObject methods.
1157  */
1158 static HRESULT WINAPI OLEClipbrd_IDataObject_QueryGetData(
1159             IDataObject*     iface,
1160             LPFORMATETC      pformatetc)
1161 {
1162   /*
1163    * Declare "This" pointer
1164    */
1165   ICOM_THIS(OLEClipbrd, iface);
1166
1167   TRACE("(%p, %p)\n", iface, pformatetc);
1168
1169   /*
1170    * If we have a data source placed on the clipboard (via OleSetClipboard)
1171    * simply delegate to the source object's QueryGetData
1172    */
1173   if ( This->pIDataObjectSrc )
1174   {
1175     return IDataObject_QueryGetData(This->pIDataObjectSrc, pformatetc);
1176   }
1177
1178   if (!pformatetc)
1179     return E_INVALIDARG;
1180 /*
1181    if ( pformatetc->dwAspect != DVASPECT_CONTENT )
1182      return DV_E_DVASPECT;
1183 */
1184   if ( pformatetc->lindex != -1 )
1185     return DV_E_LINDEX;
1186
1187   /* TODO: Handle TYMED_IStorage media which were put on the clipboard
1188    * by copying the storage into global memory. We must convert this
1189    * TYMED_HGLOBAL back to TYMED_IStorage.
1190    */
1191   if ( pformatetc->tymed != TYMED_HGLOBAL )
1192     return DV_E_TYMED;
1193
1194   /*
1195    * Delegate to the Windows clipboard function IsClipboardFormatAvailable
1196    */
1197   return (IsClipboardFormatAvailable(pformatetc->cfFormat)) ? S_OK : DV_E_FORMATETC;
1198 }
1199
1200 /************************************************************************
1201  * OLEClipbrd_IDataObject_GetCanonicalFormatEtc (IDataObject)
1202  *
1203  * See Windows documentation for more details on IDataObject methods.
1204  */
1205 static HRESULT WINAPI OLEClipbrd_IDataObject_GetCanonicalFormatEtc(
1206             IDataObject*     iface,
1207             LPFORMATETC      pformatectIn,
1208             LPFORMATETC      pformatetcOut)
1209 {
1210   TRACE("(%p, %p, %p)\n", iface, pformatectIn, pformatetcOut);
1211
1212   if ( !pformatectIn || !pformatetcOut )
1213     return E_INVALIDARG;
1214
1215   memcpy(pformatetcOut, pformatectIn, sizeof(FORMATETC));
1216   return DATA_S_SAMEFORMATETC;
1217 }
1218
1219 /************************************************************************
1220  * OLEClipbrd_IDataObject_SetData (IDataObject)
1221  *
1222  * The OLE Clipboard's does not implement this method
1223  *
1224  * See Windows documentation for more details on IDataObject methods.
1225  */
1226 static HRESULT WINAPI OLEClipbrd_IDataObject_SetData(
1227             IDataObject*     iface,
1228             LPFORMATETC      pformatetc,
1229             STGMEDIUM*       pmedium,
1230             BOOL             fRelease)
1231 {
1232   return E_NOTIMPL;
1233 }
1234
1235 /************************************************************************
1236  * OLEClipbrd_IDataObject_EnumFormatEtc (IDataObject)
1237  *
1238  * See Windows documentation for more details on IDataObject methods.
1239  */
1240 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumFormatEtc(
1241             IDataObject*     iface,
1242             DWORD            dwDirection,
1243             IEnumFORMATETC** ppenumFormatEtc)
1244 {
1245   HRESULT hr = S_OK;
1246   FORMATETC *afmt = NULL;
1247   int cfmt, i;
1248   UINT format;
1249   BOOL bClipboardOpen;
1250
1251   /*
1252    * Declare "This" pointer
1253    */
1254   ICOM_THIS(OLEClipbrd, iface);
1255
1256   TRACE("(%p, %lx, %p)\n", iface, dwDirection, ppenumFormatEtc);
1257
1258   /*
1259    * If we have a data source placed on the clipboard (via OleSetClipboard)
1260    * simply delegate to the source object's EnumFormatEtc
1261    */
1262   if ( This->pIDataObjectSrc )
1263   {
1264     return IDataObject_EnumFormatEtc(This->pIDataObjectSrc,
1265                                      dwDirection, ppenumFormatEtc);
1266   }
1267
1268   /*
1269    * Otherwise we must provide our own enumerator which wraps around the
1270    * Windows clipboard function EnumClipboardFormats
1271    */
1272   if ( !ppenumFormatEtc )
1273     return E_INVALIDARG;
1274
1275   if ( dwDirection != DATADIR_GET ) /* IDataObject_SetData not implemented */
1276     return E_NOTIMPL;
1277
1278   /*
1279    * Store all current clipboard formats in an array of FORMATETC's,
1280    * and create an IEnumFORMATETC enumerator from this list.
1281    */
1282   cfmt = CountClipboardFormats();
1283   afmt = (FORMATETC *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1284                                 sizeof(FORMATETC) * cfmt);
1285   /*
1286    * Open the Windows clipboard, associating it with our hidden window
1287    */
1288   if ( !(bClipboardOpen = OpenClipboard(This->hWndClipboard)) )
1289     HANDLE_ERROR( CLIPBRD_E_CANT_OPEN );
1290
1291   /*
1292    * Store all current clipboard formats in an array of FORMATETC's
1293    * TODO: Handle TYMED_IStorage media which were put on the clipboard
1294    * by copying the storage into global memory. We must convert this
1295    * TYMED_HGLOBAL back to TYMED_IStorage.
1296    */
1297   for (i = 0, format = 0; i < cfmt; i++)
1298   {
1299     format = EnumClipboardFormats(format);
1300     if (!format)  /* Failed! */
1301     {
1302       ERR("EnumClipboardFormats failed to return format!\n");
1303       HANDLE_ERROR( E_FAIL );
1304     }
1305
1306     /* Init the FORMATETC struct */
1307     afmt[i].cfFormat = format;
1308     afmt[i].ptd = NULL;
1309     afmt[i].dwAspect = DVASPECT_CONTENT;
1310     afmt[i].lindex = -1;
1311     afmt[i].tymed = TYMED_HGLOBAL;
1312   }
1313
1314   /*
1315    * Create an EnumFORMATETC enumerator and return an
1316    * EnumFORMATETC after bumping up its ref count
1317    */
1318   *ppenumFormatEtc = OLEClipbrd_IEnumFORMATETC_Construct( cfmt, afmt, (LPUNKNOWN)iface);
1319   if (!(*ppenumFormatEtc))
1320     HANDLE_ERROR( E_OUTOFMEMORY );
1321
1322   if (FAILED( hr = IEnumFORMATETC_AddRef(*ppenumFormatEtc)))
1323     HANDLE_ERROR( hr );
1324
1325   hr = S_OK;
1326
1327 CLEANUP:
1328   /*
1329    * Free the array of FORMATETC's
1330    */
1331   if (afmt)
1332     HeapFree(GetProcessHeap(), 0, afmt);
1333
1334   /*
1335    * Close Windows clipboard
1336    */
1337   if ( bClipboardOpen && !CloseClipboard() )
1338     hr = CLIPBRD_E_CANT_CLOSE;
1339
1340   return hr;
1341 }
1342
1343 /************************************************************************
1344  * OLEClipbrd_IDataObject_DAdvise (IDataObject)
1345  *
1346  * The OLE Clipboard's does not implement this method
1347  *
1348  * See Windows documentation for more details on IDataObject methods.
1349  */
1350 static HRESULT WINAPI OLEClipbrd_IDataObject_DAdvise(
1351             IDataObject*     iface,
1352             FORMATETC*       pformatetc,
1353             DWORD            advf,
1354             IAdviseSink*     pAdvSink,
1355             DWORD*           pdwConnection)
1356 {
1357   return E_NOTIMPL;
1358 }
1359
1360 /************************************************************************
1361  * OLEClipbrd_IDataObject_DUnadvise (IDataObject)
1362  *
1363  * The OLE Clipboard's does not implement this method
1364  *
1365  * See Windows documentation for more details on IDataObject methods.
1366  */
1367 static HRESULT WINAPI OLEClipbrd_IDataObject_DUnadvise(
1368             IDataObject*     iface,
1369             DWORD            dwConnection)
1370 {
1371   return E_NOTIMPL;
1372 }
1373
1374 /************************************************************************
1375  * OLEClipbrd_IDataObject_EnumDAdvise (IDataObject)
1376  *
1377  * The OLE Clipboard does not implement this method
1378  *
1379  * See Windows documentation for more details on IDataObject methods.
1380  */
1381 static HRESULT WINAPI OLEClipbrd_IDataObject_EnumDAdvise(
1382             IDataObject*     iface,
1383             IEnumSTATDATA**  ppenumAdvise)
1384 {
1385   return E_NOTIMPL;
1386 }
1387
1388
1389 /*---------------------------------------------------------------------*
1390  *  Implementation of the internal IEnumFORMATETC interface returned by
1391  *  the OLE clipboard's IDataObject.
1392  *---------------------------------------------------------------------*/
1393
1394 /************************************************************************
1395  * OLEClipbrd_IEnumFORMATETC_Construct (UINT, const FORMATETC, LPUNKNOWN)
1396  *
1397  * Creates an IEnumFORMATETC enumerator from an array of FORMATETC
1398  * Structures. pUnkOuter is the outer unknown for reference counting only.
1399  * NOTE: this does not AddRef the interface.
1400  */
1401
1402 LPENUMFORMATETC OLEClipbrd_IEnumFORMATETC_Construct(UINT cfmt, const FORMATETC afmt[],
1403                                                     LPUNKNOWN pUnkDataObj)
1404 {
1405   IEnumFORMATETCImpl* ef;
1406   DWORD size=cfmt * sizeof(FORMATETC);
1407   LPMALLOC pIMalloc;
1408
1409   ef = (IEnumFORMATETCImpl*)HeapAlloc(GetProcessHeap(),
1410                                       HEAP_ZERO_MEMORY,
1411                                       sizeof(IEnumFORMATETCImpl));
1412   if (!ef)
1413     return NULL;
1414
1415   ef->ref = 0;
1416   ef->lpvtbl = &efvt;
1417   ef->pUnkDataObj = pUnkDataObj;
1418
1419   ef->posFmt = 0;
1420   ef->countFmt = cfmt;
1421   if (FAILED(CoGetMalloc(MEMCTX_TASK, &pIMalloc)))
1422     return NULL;
1423   ef->pFmt = (LPFORMATETC)IMalloc_Alloc(pIMalloc, size);
1424   IMalloc_Release(pIMalloc);
1425
1426   if (ef->pFmt)
1427     memcpy(ef->pFmt, afmt, size);
1428
1429   TRACE("(%p)->()\n",ef);
1430   return (LPENUMFORMATETC)ef;
1431 }
1432
1433
1434 /************************************************************************
1435  * OLEClipbrd_IEnumFORMATETC_QueryInterface (IUnknown)
1436  *
1437  * See Windows documentation for more details on IUnknown methods.
1438  */
1439 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface
1440   (LPENUMFORMATETC iface, REFIID riid, LPVOID* ppvObj)
1441 {
1442   ICOM_THIS(IEnumFORMATETCImpl,iface);
1443   char    xriid[50];
1444
1445   WINE_StringFromCLSID((LPCLSID)riid,xriid);
1446   TRACE("(%p)->(\n\tIID:\t%s,%p)\n",This,xriid,ppvObj);
1447
1448   /*
1449    * Since enumerators are seperate objects from the parent data object
1450    * we only need to support the IUnknown and IEnumFORMATETC interfaces
1451    */
1452
1453   *ppvObj = NULL;
1454
1455   if(IsEqualIID(riid, &IID_IUnknown))
1456   {
1457     *ppvObj = This;
1458   }
1459   else if(IsEqualIID(riid, &IID_IEnumFORMATETC))
1460   {
1461     *ppvObj = (IDataObject*)This;
1462   }
1463
1464   if(*ppvObj)
1465   {
1466     IEnumFORMATETC_AddRef((IEnumFORMATETC*)*ppvObj);
1467     TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
1468     return S_OK;
1469   }
1470
1471   TRACE("-- Interface: E_NOINTERFACE\n");
1472   return E_NOINTERFACE;
1473 }
1474
1475 /************************************************************************
1476  * OLEClipbrd_IEnumFORMATETC_AddRef (IUnknown)
1477  *
1478  * Since enumerating formats only makes sense when our data object is around,
1479  * we insure that it stays as long as we stay by calling our parents IUnknown
1480  * for AddRef and Release. But since we are not controlled by the lifetime of
1481  * the outer object, we still keep our own reference count in order to
1482  * free ourselves.
1483  */
1484 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef(LPENUMFORMATETC iface)
1485 {
1486   ICOM_THIS(IEnumFORMATETCImpl,iface);
1487   TRACE("(%p)->(count=%lu)\n",This, This->ref);
1488
1489   if (This->pUnkDataObj)
1490     IUnknown_AddRef(This->pUnkDataObj);
1491
1492   return ++(This->ref);
1493 }
1494
1495 /************************************************************************
1496  * OLEClipbrd_IEnumFORMATETC_Release (IUnknown)
1497  *
1498  * See Windows documentation for more details on IUnknown methods.
1499  */
1500 static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release(LPENUMFORMATETC iface)
1501 {
1502   ICOM_THIS(IEnumFORMATETCImpl,iface);
1503   LPMALLOC pIMalloc;
1504
1505   TRACE("(%p)->(count=%lu)\n",This, This->ref);
1506
1507   if (This->pUnkDataObj)
1508     IUnknown_Release(This->pUnkDataObj);  /* Release parent data object */
1509
1510   if (!--(This->ref))
1511   {
1512     TRACE("() - destroying IEnumFORMATETC(%p)\n",This);
1513     if (SUCCEEDED(CoGetMalloc(MEMCTX_TASK, &pIMalloc)))
1514     {
1515       IMalloc_Free(pIMalloc, This->pFmt);
1516       IMalloc_Release(pIMalloc);
1517     }
1518
1519     HeapFree(GetProcessHeap(),0,This);
1520     return 0;
1521   }
1522
1523   return This->ref;
1524 }
1525
1526 /************************************************************************
1527  * OLEClipbrd_IEnumFORMATETC_Next (IEnumFORMATETC)
1528  *
1529  * Standard enumerator members for IEnumFORMATETC
1530  */
1531 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next
1532   (LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
1533 {
1534   ICOM_THIS(IEnumFORMATETCImpl,iface);
1535   UINT cfetch;
1536   HRESULT hres = S_FALSE;
1537
1538   TRACE("(%p)->(pos=%u)\n", This, This->posFmt);
1539
1540   if (This->posFmt < This->countFmt)
1541   {
1542     cfetch = This->countFmt - This->posFmt;
1543     if (cfetch >= celt)
1544     {
1545       cfetch = celt;
1546       hres = S_OK;
1547     }
1548
1549     memcpy(rgelt, &This->pFmt[This->posFmt], cfetch * sizeof(FORMATETC));
1550     This->posFmt += cfetch;
1551   }
1552   else
1553   {
1554     cfetch = 0;
1555   }
1556
1557   if (pceltFethed)
1558   {
1559     *pceltFethed = cfetch;
1560   }
1561
1562   return hres;
1563 }
1564
1565 /************************************************************************
1566  * OLEClipbrd_IEnumFORMATETC_Skip (IEnumFORMATETC)
1567  *
1568  * Standard enumerator members for IEnumFORMATETC
1569  */
1570 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip(LPENUMFORMATETC iface, ULONG celt)
1571 {
1572   ICOM_THIS(IEnumFORMATETCImpl,iface);
1573   TRACE("(%p)->(num=%lu)\n", This, celt);
1574
1575   This->posFmt += celt;
1576   if (This->posFmt > This->countFmt)
1577   {
1578     This->posFmt = This->countFmt;
1579     return S_FALSE;
1580   }
1581   return S_OK;
1582 }
1583
1584 /************************************************************************
1585  * OLEClipbrd_IEnumFORMATETC_Reset (IEnumFORMATETC)
1586  *
1587  * Standard enumerator members for IEnumFORMATETC
1588  */
1589 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset(LPENUMFORMATETC iface)
1590 {
1591   ICOM_THIS(IEnumFORMATETCImpl,iface);
1592   TRACE("(%p)->()\n", This);
1593
1594   This->posFmt = 0;
1595   return S_OK;
1596 }
1597
1598 /************************************************************************
1599  * OLEClipbrd_IEnumFORMATETC_Clone (IEnumFORMATETC)
1600  *
1601  * Standard enumerator members for IEnumFORMATETC
1602  */
1603 static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone
1604   (LPENUMFORMATETC iface, LPENUMFORMATETC* ppenum)
1605 {
1606   ICOM_THIS(IEnumFORMATETCImpl,iface);
1607   HRESULT hr = S_OK;
1608
1609   TRACE("(%p)->(ppenum=%p)\n", This, ppenum);
1610
1611   if ( !ppenum )
1612     return E_INVALIDARG;
1613
1614   *ppenum = OLEClipbrd_IEnumFORMATETC_Construct(This->countFmt,
1615                                                 This->pFmt,
1616                                                 This->pUnkDataObj);
1617
1618   if (FAILED( hr = IEnumFORMATETC_AddRef(*ppenum)))
1619     return ( hr );
1620
1621   return (*ppenum) ? S_OK : E_OUTOFMEMORY;
1622 }
1623