windows/clipboard.c

   1 /*
   2  * WIN32 clipboard implementation
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1996 Alex Korobka
   6  *           1999 Noel Borthwick
   7  *
   8  * NOTES:
   9  *    This file contains the implementation for the WIN32 Clipboard API
  10  * and Wine's internal clipboard cache.
  11  * The actual contents of the clipboard are held in the clipboard cache.
  12  * The internal implementation talks to a "clipboard driver" to fill or
  13  * expose the cache to the native device. (Currently only the X11 and
  14  * TTY clipboard  driver are available)
  15  *
  16  * TODO:
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <fcntl.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include "winuser.h"
  27 #include "wine/winuser16.h"
  28 #include "wine/winbase16.h"
  29 #include "heap.h"
  30 #include "message.h"
  31 #include "task.h"
  32 #include "queue.h"
  33 #include "clipboard.h"
  34 #include "xmalloc.h"
  35 #include "debugtools.h"
  36
  37 DEFAULT_DEBUG_CHANNEL(clipboard)
  38
  39 #define  CF_REGFORMATBASE       0xC000
  40
  41 /**************************************************************************
  42  *        Clipboard context global variables
  43  */
  44
  45 CLIPBOARD_DRIVER *CLIPBOARD_Driver = NULL;
  46
  47 static HANDLE hClipLock   = 0;
  48 static BOOL bCBHasChanged  = FALSE;
  49
  50 HWND hWndClipWindow = 0;          /* window that last opened clipboard */
  51 HWND hWndClipOwner  = 0;          /* current clipboard owner */
  52 HANDLE16 hTaskClipOwner = 0;      /* clipboard owner's task  */
  53 static HWND hWndViewer     = 0;   /* start of viewers chain */
  54
  55 static WORD LastRegFormat = CF_REGFORMATBASE;
  56
  57 /* Clipboard cache initial data.
  58  * WARNING: This data ordering is dependendent on the WINE_CLIPFORMAT structure
  59  * declared in clipboard.h
  60  */
  61 WINE_CLIPFORMAT ClipFormats[16]  = {
  62     { CF_TEXT, 1, 0, "Text",  (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, NULL, &ClipFormats[1]},
  63     { CF_BITMAP, 1, 0, "Bitmap", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[0], &ClipFormats[2]},
  64     { CF_METAFILEPICT, 1, 0, "MetaFile Picture", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[1], &ClipFormats[3]},
  65     { CF_SYLK, 1, 0, "Sylk", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[2], &ClipFormats[4]},
  66     { CF_DIF, 1, 0, "DIF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[3], &ClipFormats[5]},
  67     { CF_TIFF, 1, 0, "TIFF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[4], &ClipFormats[6]},
  68     { CF_OEMTEXT, 1, 0, "OEM Text", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[5], &ClipFormats[7]},
  69     { CF_DIB, 1, 0, "DIB", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[6], &ClipFormats[8]},
  70     { CF_PALETTE, 1, 0, "Palette", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[7], &ClipFormats[9]},
  71     { CF_PENDATA, 1, 0, "PenData", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[8], &ClipFormats[10]},
  72     { CF_RIFF, 1, 0, "RIFF", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[9], &ClipFormats[11]},
  73     { CF_WAVE, 1, 0, "Wave", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[10], &ClipFormats[12]},
  74     { CF_OWNERDISPLAY, 1, 0, "Owner Display", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[11], &ClipFormats[13]},
  75     { CF_DSPTEXT, 1, 0, "DSPText", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[12], &ClipFormats[14]},
  76     { CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[13], &ClipFormats[15]},
  77     { CF_DSPBITMAP, 1, 0, "DSPBitmap", (HANDLE16)NULL, (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[14], NULL}
  78     };
  79
  80
  81 /**************************************************************************
  82  *                Internal Clipboard implementation methods
  83  **************************************************************************/
  84
  85
  86 /**************************************************************************
  87  *                      CLIPBOARD_LookupFormat
  88  */
  89 static LPWINE_CLIPFORMAT __lookup_format( LPWINE_CLIPFORMAT lpFormat, WORD wID )
  90 {
  91     while(TRUE)
  92     {
  93         if (lpFormat == NULL ||
  94             lpFormat->wFormatID == wID) break;
  95         lpFormat = lpFormat->NextFormat;
  96     }
  97     return lpFormat;
  98 }
  99
 100 LPWINE_CLIPFORMAT CLIPBOARD_LookupFormat( WORD wID )
 101 {
 102   return __lookup_format( ClipFormats, wID );
 103 }
 104
 105 /**************************************************************************
 106  *                      CLIPBOARD_IsLocked
 107  *  Check if the clipboard cache is available to the caller
 108  */
 109 BOOL CLIPBOARD_IsLocked()
 110 {
 111   BOOL bIsLocked = TRUE;
 112   HANDLE16 hTaskCur = GetCurrentTask();
 113
 114   /*
 115    * The clipboard is available:
 116    * 1. if the caller's task has opened the clipboard,
 117    * or
 118    * 2. if the caller is the clipboard owners task, AND is responding to a
 119    *    WM_RENDERFORMAT message.
 120    */
 121   if ( hClipLock == hTaskCur )
 122       bIsLocked = FALSE;
 123
 124   else if ( hTaskCur == hTaskClipOwner )
 125   {
 126       /* Check if we're currently executing inside a window procedure
 127        * called in response to a WM_RENDERFORMAT message. A WM_RENDERFORMAT
 128        * handler is not permitted to open the clipboard since it has been opened
 129        * by another client. However the handler must have access to the
 130        * clipboard in order to update data in response to this message.
 131        */
 132       MESSAGEQUEUE *queue = QUEUE_Lock( GetFastQueue16() );
 133
 134       if ( queue
 135            && queue->smWaiting
 136            && queue->smWaiting->msg == WM_RENDERFORMAT
 137            && queue->smWaiting->hSrcQueue
 138          )
 139         bIsLocked = FALSE;
 140
 141       QUEUE_Unlock( queue );
 142   }
 143
 144   return bIsLocked;
 145 }
 146
 147 /**************************************************************************
 148  *                      CLIPBOARD_ReleaseOwner
 149  *   Gives up ownership of the clipboard
 150  */
 151 void CLIPBOARD_ReleaseOwner()
 152 {
 153    hWndClipOwner = 0;
 154    hTaskClipOwner = 0;
 155 }
 156
 157 /**************************************************************************
 158  *                      CLIPBOARD_GlobalFreeProc
 159  *
 160  * This is a callback mechanism to allow HGLOBAL data to be released in
 161  * the context of the process which allocated it. We post a WM_TIMER message
 162  * to the owner window(in CLIPBOARD_DeleteRecord) and destroy the data(in idEvent)
 163  * in this WndProc, which is invoked when the apps message loop calls DispatchMessage.
 164  * This technique is discussed in Matt Pietrek's "Under the Hood".
 165  * An article describing the same may be found in MSDN by searching for WM_TIMER.
 166  * Note that this mechanism will probably stop working when WINE supports
 167  * address space separation. When "queue events" are implemented in Wine we
 168  * should switch to using that mechanism, since it is more robust and does not
 169  * require a procedure address to be passed. See the SetWinEventHook API for
 170  * more info on this.
 171  */
 172 VOID CALLBACK CLIPBOARD_GlobalFreeProc( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime )
 173 {
 174     /* idEvent is the HGLOBAL to be deleted */
 175     GlobalFree( (HGLOBAL)idEvent );
 176 }
 177
 178 /**************************************************************************
 179  *                      CLIPBOARD_DeleteRecord
 180  */
 181 void CLIPBOARD_DeleteRecord(LPWINE_CLIPFORMAT lpFormat, BOOL bChange)
 182 {
 183     if( (lpFormat->wFormatID >= CF_GDIOBJFIRST &&
 184          lpFormat->wFormatID <= CF_GDIOBJLAST) || lpFormat->wFormatID == CF_BITMAP )
 185     {
 186       if (lpFormat->hData32)
 187         DeleteObject(lpFormat->hData32);
 188       if (lpFormat->hData16)
 189         DeleteObject16(lpFormat->hData16);
 190     }
 191     else if( lpFormat->wFormatID == CF_METAFILEPICT )
 192     {
 193       if (lpFormat->hData32)
 194       {
 195         DeleteMetaFile( ((METAFILEPICT *)GlobalLock( lpFormat->hData32 ))->hMF );
 196         PostMessageA(hWndClipOwner, WM_TIMER,
 197                      (WPARAM)lpFormat->hData32, (LPARAM)CLIPBOARD_GlobalFreeProc);
 198         if (lpFormat->hDataSrc32)
 199         {
 200           /* Release lpFormat->hData32 in the context of the process which created it.
 201            * See CLIPBOARD_GlobalFreeProc for more details about this technique.
 202            * GlobalFree(lpFormat->hDataSrc32);
 203            */
 204           PostMessageA(hWndClipOwner, WM_TIMER,
 205                        (WPARAM)lpFormat->hDataSrc32, (LPARAM)CLIPBOARD_GlobalFreeProc);
 206         }
 207
 208         if (lpFormat->hData16)
 209           /* HMETAFILE16 and HMETAFILE32 are apparently the same thing,
 210              and a shallow copy is enough to share a METAFILEPICT
 211              structure between 16bit and 32bit clipboards.  The MetaFile
 212              should of course only be deleted once. */
 213           GlobalFree16(lpFormat->hData16);
 214       }
 215       if (lpFormat->hData16)
 216       {
 217         DeleteMetaFile16( ((METAFILEPICT16 *)GlobalLock16( lpFormat->hData16 ))->hMF );
 218         GlobalFree16(lpFormat->hData16);
 219       }
 220     }
 221     else
 222     {
 223       if (lpFormat->hData32)
 224       {
 225         /* Release lpFormat->hData32 in the context of the process which created it.
 226          * See CLIPBOARD_GlobalFreeProc for more details about this technique.
 227          * GlobalFree( lpFormat->hData32 );
 228          */
 229         PostMessageA(hWndClipOwner, WM_TIMER,
 230                      (WPARAM)lpFormat->hData32, (LPARAM)CLIPBOARD_GlobalFreeProc);
 231       }
 232       if (lpFormat->hDataSrc32)
 233       {
 234         /* Release lpFormat->hData32 in the context of the process which created it.
 235          * See CLIPBOARD_GlobalFreeProc for more details about this technique.
 236          * GlobalFree(lpFormat->hDataSrc32);
 237          */
 238         PostMessageA(hWndClipOwner, WM_TIMER,
 239                      (WPARAM)lpFormat->hDataSrc32, (LPARAM)CLIPBOARD_GlobalFreeProc);
 240       }
 241       if (lpFormat->hData16)
 242         GlobalFree16(lpFormat->hData16);
 243     }
 244
 245     lpFormat->wDataPresent = 0;
 246     lpFormat->hData16 = 0;
 247     lpFormat->hData32 = 0;
 248     lpFormat->hDataSrc32 = 0;
 249     lpFormat->drvData = 0;
 250
 251     if( bChange ) bCBHasChanged = TRUE;
 252 }
 253
 254 /**************************************************************************
 255  *                      CLIPBOARD_EmptyCache
 256  */
 257 void CLIPBOARD_EmptyCache( BOOL bChange )
 258 {
 259     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 260
 261     while(lpFormat)
 262     {
 263         if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
 264              CLIPBOARD_DeleteRecord( lpFormat, bChange );
 265
 266         lpFormat = lpFormat->NextFormat;
 267     }
 268 }
 269
 270 /**************************************************************************
 271  *                      CLIPBOARD_IsPresent
 272  */
 273 BOOL CLIPBOARD_IsPresent(WORD wFormat)
 274 {
 275     /* special case */
 276
 277     if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
 278         return ClipFormats[CF_TEXT-1].wDataPresent ||
 279                ClipFormats[CF_OEMTEXT-1].wDataPresent;
 280     else
 281     {
 282         LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 283         if( lpFormat ) return (lpFormat->wDataPresent);
 284     }
 285     return FALSE;
 286 }
 287
 288 /**************************************************************************
 289  *                      CLIPBOARD_IsCacheRendered
 290  *  Checks if any data needs to be rendered to the clipboard cache
 291  *  RETURNS:
 292  *    TRUE  - All clipboard data is available in the cache
 293  *    FALSE - Some data is marked for delayed render and needs rendering
 294  */
 295 BOOL CLIPBOARD_IsCacheRendered()
 296 {
 297     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 298
 299     /* check if all formats were rendered */
 300     while(lpFormat)
 301     {
 302         if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
 303             return FALSE;
 304
 305         lpFormat = lpFormat->NextFormat;
 306     }
 307
 308     return TRUE;
 309 }
 310
 311
 312 /**************************************************************************
 313  *                      CLIPBOARD_IsMemoryObject
 314  *  Tests if the clipboard format specifies a memory object
 315  */
 316 BOOL CLIPBOARD_IsMemoryObject( WORD wFormat )
 317 {
 318     switch(wFormat)
 319     {
 320         case CF_BITMAP:
 321         case CF_METAFILEPICT:
 322         case CF_DSPTEXT:
 323         case CF_ENHMETAFILE:
 324         case CF_HDROP:
 325         case CF_PALETTE:
 326         case CF_PENDATA:
 327             return FALSE;
 328         default:
 329             return TRUE;
 330      }
 331 }
 332
 333 /***********************************************************************
 334  * CLIPBOARD_GlobalDupMem( HGLOBAL )
 335  * Helper method to duplicate an HGLOBAL chunk of memory into shared memory
 336  */
 337 HGLOBAL CLIPBOARD_GlobalDupMem( HGLOBAL hGlobalSrc )
 338 {
 339     HGLOBAL hGlobalDest;
 340     PVOID pGlobalSrc, pGlobalDest;
 341     DWORD cBytes;
 342
 343     if ( !hGlobalSrc )
 344       return 0;
 345
 346     cBytes = GlobalSize(hGlobalSrc);
 347     if ( 0 == cBytes )
 348       return 0;
 349
 350     /* Turn on the DDESHARE and _MOVEABLE flags explicitly */
 351     hGlobalDest = GlobalAlloc( GlobalFlags(hGlobalSrc) | GMEM_DDESHARE | GMEM_MOVEABLE,
 352                                cBytes );
 353     if ( !hGlobalDest )
 354       return 0;
 355
 356     pGlobalSrc = GlobalLock(hGlobalSrc);
 357     pGlobalDest = GlobalLock(hGlobalDest);
 358     if ( !pGlobalSrc || !pGlobalDest )
 359       return 0;
 360
 361     memcpy(pGlobalDest, pGlobalSrc, cBytes);
 362
 363     GlobalUnlock(hGlobalSrc);
 364     GlobalUnlock(hGlobalDest);
 365
 366     return hGlobalDest;
 367 }
 368
 369 /**************************************************************************
 370  *                      CLIPBOARD_GetFormatName
 371  *  Gets the format name associated with an ID
 372  */
 373 char * CLIPBOARD_GetFormatName(UINT wFormat)
 374 {
 375     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 376     return (lpFormat) ? lpFormat->Name : NULL;
 377 }
 378
 379
 380 /**************************************************************************
 381  *                      CLIPBOARD_RenderFormat
 382  */
 383 static BOOL CLIPBOARD_RenderFormat(LPWINE_CLIPFORMAT lpFormat)
 384 {
 385   /*
 386    * If WINE is not the selection owner, and the format is available
 387    * we must ask the the driver to render the data to the clipboard cache.
 388    */
 389   if ( !CLIPBOARD_Driver->pIsSelectionOwner()
 390        && CLIPBOARD_Driver->pIsFormatAvailable( lpFormat->wFormatID ) )
 391   {
 392     if ( !CLIPBOARD_Driver->pGetData( lpFormat->wFormatID ) )
 393       return FALSE;
 394   }
 395   /*
 396    * If Wine owns the clipboard, and the data is marked for delayed render,
 397    * render it now.
 398    */
 399   else if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
 400   {
 401     if( IsWindow(hWndClipOwner) )
 402     {
 403       /* Send a WM_RENDERFORMAT message to notify the owner to render the
 404        * data requested into the clipboard.
 405        */
 406       TRACE("Sending WM_RENDERFORMAT message\n");
 407       SendMessage16(hWndClipOwner,WM_RENDERFORMAT,
 408                     (WPARAM16)lpFormat->wFormatID,0L);
 409     }
 410     else
 411     {
 412       WARN("\thWndClipOwner (%04x) is lost!\n",
 413            hWndClipOwner);
 414       CLIPBOARD_ReleaseOwner();
 415       lpFormat->wDataPresent = 0;
 416       return FALSE;
 417     }
 418   }
 419
 420   return (lpFormat->hData16 || lpFormat->hData32) ? TRUE : FALSE;
 421 }
 422
 423
 424 /**************************************************************************
 425  *                      CLIPBOARD_RenderText
 426  *
 427  * Renders text to the clipboard buffer converting between UNIX and DOS formats.
 428  *
 429  * RETURNS: pointer to the WINE_CLIPFORMAT if successful, NULL otherwise
 430  *
 431  * FIXME: Should be a pair of driver functions that convert between OEM text and Windows.
 432  *
 433  */
 434 static LPWINE_CLIPFORMAT CLIPBOARD_RenderText( UINT wFormat )
 435 {
 436     LPWINE_CLIPFORMAT lpSource = ClipFormats;
 437     LPWINE_CLIPFORMAT lpTarget;
 438
 439     /* Asked for CF_TEXT and not available - always attempt to convert from CF_OEM_TEXT */
 440     if( wFormat == CF_TEXT && !ClipFormats[CF_TEXT-1].wDataPresent )
 441     {
 442         /* Convert OEMTEXT -> TEXT */
 443         lpSource = &ClipFormats[CF_OEMTEXT-1];
 444         lpTarget = &ClipFormats[CF_TEXT-1];
 445
 446         TRACE("\tOEMTEXT -> TEXT\n");
 447     }
 448     /* Asked for CF_OEM_TEXT, and CF_TEXT available */
 449     else if( wFormat == CF_OEMTEXT && !ClipFormats[CF_OEMTEXT-1].wDataPresent
 450                                    &&  ClipFormats[CF_TEXT-1].wDataPresent )
 451     {
 452         /* Convert TEXT -> OEMTEXT */
 453         lpSource = &ClipFormats[CF_TEXT-1];
 454         lpTarget = &ClipFormats[CF_OEMTEXT-1];
 455
 456         TRACE("\tTEXT -> OEMTEXT\n");
 457     }
 458     /* Text format requested is available - no conversion necessary */
 459     else
 460     {
 461         lpSource = __lookup_format( ClipFormats, wFormat );
 462         lpTarget = lpSource;
 463     }
 464
 465     /* First render the source text format */
 466     if ( !lpSource || !CLIPBOARD_RenderFormat(lpSource) ) return NULL;
 467
 468     /* Convert to the desired target text format, if necessary */
 469     if( lpTarget != lpSource && !lpTarget->hData16 && !lpTarget->hData32 )
 470     {
 471         UINT16 size;
 472         LPCSTR lpstrS;
 473         LPSTR  lpstrT;
 474
 475         if (lpSource->hData32)
 476         {
 477           size = GlobalSize( lpSource->hData32 );
 478           lpstrS = (LPSTR)GlobalLock(lpSource->hData32);
 479         }
 480         else
 481         {
 482           size = GlobalSize16( lpSource->hData16 );
 483           lpstrS = (LPSTR)GlobalLock16(lpSource->hData16);
 484         }
 485
 486         if( !lpstrS ) return NULL;
 487         TRACE("\tconverting from '%s' to '%s', %i chars\n",
 488                                           lpSource->Name, lpTarget->Name, size);
 489
 490         lpTarget->hData32 = GlobalAlloc(GMEM_ZEROINIT, size);
 491         lpstrT = (LPSTR)GlobalLock(lpTarget->hData32);
 492
 493         if( lpstrT )
 494         {
 495             if( lpSource->wFormatID == CF_TEXT )
 496                 CharToOemBuffA(lpstrS, lpstrT, size);
 497             else
 498                 OemToCharBuffA(lpstrS, lpstrT, size);
 499             TRACE("\tgot %s\n", lpstrT);
 500             GlobalUnlock(lpTarget->hData32);
 501         }
 502         else
 503             lpTarget->hData32 = 0;
 504
 505         /* Unlock source */
 506         if (lpSource->hData32)
 507           GlobalUnlock(lpSource->hData32);
 508         else
 509           GlobalUnlock16(lpSource->hData16);
 510     }
 511
 512     return (lpTarget->hData16 || lpTarget->hData32) ? lpTarget : NULL;
 513 }
 514
 515 /**************************************************************************
 516  *                WIN32 Clipboard implementation
 517  **************************************************************************/
 518
 519 /**************************************************************************
 520  *            OpenClipboard16   (USER.137)
 521  */
 522 BOOL16 WINAPI OpenClipboard16( HWND16 hWnd )
 523 {
 524     return OpenClipboard( hWnd );
 525 }
 526
 527
 528 /**************************************************************************
 529  *            OpenClipboard32   (USER32.407)
 530  *
 531  * Note: Netscape uses NULL hWnd to open the clipboard.
 532  */
 533 BOOL WINAPI OpenClipboard( HWND hWnd )
 534 {
 535     BOOL bRet;
 536
 537     TRACE("(%04x)...\n", hWnd);
 538
 539     if (!hClipLock)
 540     {
 541         hClipLock = GetCurrentTask();
 542
 543         /* Save current user of the clipboard */
 544         hWndClipWindow = hWnd;
 545         bCBHasChanged = FALSE;
 546         bRet = TRUE;
 547     }
 548     else bRet = FALSE;
 549
 550     TRACE("   returning %i\n", bRet);
 551     return bRet;
 552 }
 553
 554
 555 /**************************************************************************
 556  *            CloseClipboard16   (USER.138)
 557  */
 558 BOOL16 WINAPI CloseClipboard16(void)
 559 {
 560     return CloseClipboard();
 561 }
 562
 563
 564 /**************************************************************************
 565  *            CloseClipboard32   (USER32.54)
 566  */
 567 BOOL WINAPI CloseClipboard(void)
 568 {
 569     TRACE("()\n");
 570
 571     if (hClipLock == GetCurrentTask())
 572     {
 573         hWndClipWindow = 0;
 574
 575         if (bCBHasChanged && hWndViewer)
 576             SendMessage16(hWndViewer, WM_DRAWCLIPBOARD, 0, 0L);
 577         hClipLock = 0;
 578     }
 579     return TRUE;
 580 }
 581
 582
 583 /**************************************************************************
 584  *            EmptyClipboard16   (USER.139)
 585  */
 586 BOOL16 WINAPI EmptyClipboard16(void)
 587 {
 588     return EmptyClipboard();
 589 }
 590
 591
 592 /**************************************************************************
 593  *            EmptyClipboard32   (USER32.169)
 594  *  Empties and acquires ownership of the clipboard
 595  */
 596 BOOL WINAPI EmptyClipboard(void)
 597 {
 598     TRACE("()\n");
 599
 600     if (hClipLock != GetCurrentTask())
 601     {
 602         WARN("Clipboard not opened by calling task!");
 603         return FALSE;
 604     }
 605
 606     /* destroy private objects */
 607
 608     if (hWndClipOwner)
 609         SendMessage16(hWndClipOwner, WM_DESTROYCLIPBOARD, 0, 0L);
 610
 611     /* empty the cache */
 612     CLIPBOARD_EmptyCache(TRUE);
 613
 614     /* Assign ownership of the clipboard to the current client */
 615     hWndClipOwner = hWndClipWindow;
 616
 617     /* Save the current task */
 618     hTaskClipOwner = GetCurrentTask();
 619
 620     /* Tell the driver to acquire the selection */
 621     CLIPBOARD_Driver->pAcquire();
 622
 623     return TRUE;
 624 }
 625
 626
 627 /**************************************************************************
 628  *            GetClipboardOwner16   (USER.140)
 629  *  FIXME: Can't return the owner if the clipbard is owned by an external app
 630  */
 631 HWND16 WINAPI GetClipboardOwner16(void)
 632 {
 633     TRACE("()\n");
 634     return hWndClipOwner;
 635 }
 636
 637
 638 /**************************************************************************
 639  *            GetClipboardOwner32   (USER32.225)
 640  *  FIXME: Can't return the owner if the clipbard is owned by an external app
 641  */
 642 HWND WINAPI GetClipboardOwner(void)
 643 {
 644     TRACE("()\n");
 645     return hWndClipOwner;
 646 }
 647
 648
 649 /**************************************************************************
 650  *            SetClipboardData16   (USER.141)
 651  */
 652 HANDLE16 WINAPI SetClipboardData16( UINT16 wFormat, HANDLE16 hData )
 653 {
 654     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 655
 656     TRACE("(%04X, %04x) !\n", wFormat, hData);
 657
 658     /* NOTE: If the hData is zero and current owner doesn't match
 659      * the window that opened the clipboard then this application
 660      * is screwed because WM_RENDERFORMAT will go to the owner.
 661      * (to become the owner it must call EmptyClipboard() before
 662      *  adding new data).
 663      */
 664
 665     if( CLIPBOARD_IsLocked() || !lpFormat ||
 666         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) )
 667     {
 668         WARN("Invalid hData or clipboard not opened by calling task!");
 669         return 0;
 670     }
 671
 672     /* Pass on the request to the driver */
 673     CLIPBOARD_Driver->pSetData(wFormat);
 674
 675     if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
 676     {
 677         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
 678
 679         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
 680
 681         if( wFormat == CF_TEXT
 682             && ( ClipFormats[CF_OEMTEXT-1].hData16
 683                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 684             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
 685             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
 686         if( wFormat == CF_OEMTEXT
 687             && ( ClipFormats[CF_OEMTEXT-1].hData16
 688                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 689             && !ClipFormats[CF_TEXT-1].wDataPresent )
 690             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
 691     }
 692
 693     bCBHasChanged = TRUE;
 694     lpFormat->wDataPresent = 1;
 695     lpFormat->hData16 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
 696     lpFormat->hData32 = 0;
 697
 698     return lpFormat->hData16;
 699 }
 700
 701
 702 /**************************************************************************
 703  *            SetClipboardData   (USER32.470)
 704  */
 705 HANDLE WINAPI SetClipboardData( UINT wFormat, HANDLE hData )
 706 {
 707     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 708
 709     TRACE("(%08X, %08x) !\n", wFormat, hData);
 710
 711     /* NOTE: If the hData is zero and current owner doesn't match
 712      * the window that opened the clipboard then this application
 713      * is screwed because WM_RENDERFORMAT will go to the owner.
 714      * (to become the owner it must call EmptyClipboard() before
 715      *  adding new data).
 716      */
 717
 718     if( CLIPBOARD_IsLocked() || !lpFormat ||
 719         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) )
 720     {
 721         WARN("Invalid hData or clipboard not opened by calling task!");
 722         return 0;
 723     }
 724
 725     /* Tell the driver to acquire the selection */
 726     CLIPBOARD_Driver->pAcquire();
 727
 728     if ( lpFormat->wDataPresent &&
 729          (lpFormat->hData16 || lpFormat->hData32) )
 730     {
 731         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
 732
 733         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
 734
 735         if( wFormat == CF_TEXT
 736             && ( ClipFormats[CF_OEMTEXT-1].hData16
 737                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 738             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
 739             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
 740         if( wFormat == CF_OEMTEXT
 741             && ( ClipFormats[CF_OEMTEXT-1].hData16
 742                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 743             && !ClipFormats[CF_TEXT-1].wDataPresent )
 744             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
 745     }
 746
 747     bCBHasChanged = TRUE;
 748     lpFormat->wDataPresent = 1;
 749     lpFormat->hDataSrc32 = hData;  /* Save the source handle */
 750
 751     /*
 752      * Make a shared duplicate if the memory is not shared
 753      * TODO: What should be done for non-memory objects
 754      */
 755     if ( CLIPBOARD_IsMemoryObject(wFormat) && hData && !(GlobalFlags(hData) & GMEM_DDESHARE) )
 756         lpFormat->hData32 = CLIPBOARD_GlobalDupMem( hData );
 757     else
 758         lpFormat->hData32 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
 759
 760     lpFormat->hData16 = 0;
 761
 762     return lpFormat->hData32;   /* Should we return lpFormat->hDataSrc32 */
 763 }
 764
 765
 766 /**************************************************************************
 767  *             GetClipboardData16   (USER.142)
 768  */
 769 HANDLE16 WINAPI GetClipboardData16( UINT16 wFormat )
 770 {
 771     LPWINE_CLIPFORMAT lpRender = ClipFormats;
 772
 773     TRACE("(%04X)\n", wFormat);
 774
 775     if (CLIPBOARD_IsLocked())
 776     {
 777         WARN("Clipboard not opened by calling task!");
 778         return 0;
 779     }
 780
 781     if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
 782     {
 783         lpRender = CLIPBOARD_RenderText(wFormat);
 784         if ( !lpRender ) return 0;
 785     }
 786     else
 787     {
 788         lpRender = __lookup_format( ClipFormats, wFormat );
 789         if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0;
 790     }
 791
 792     /* Convert between 32 -> 16 bit data, if necessary */
 793     if( lpRender->hData32 && !lpRender->hData16 )
 794     {
 795       int size;
 796       if( lpRender->wFormatID == CF_METAFILEPICT )
 797         size = sizeof( METAFILEPICT16 );
 798       else
 799           size = GlobalSize(lpRender->hData32);
 800
 801       lpRender->hData16 = GlobalAlloc16(GMEM_ZEROINIT, size);
 802       if( !lpRender->hData16 )
 803         ERR("(%04X) -- not enough memory in 16b heap\n", wFormat);
 804       else
 805       {
 806         if( lpRender->wFormatID == CF_METAFILEPICT )
 807         {
 808           FIXME("\timplement function CopyMetaFilePict32to16\n");
 809           FIXME("\tin the appropriate file.\n");
 810   #ifdef SOMEONE_IMPLEMENTED_ME
 811           CopyMetaFilePict32to16( GlobalLock16(lpRender->hData16),
 812                                   GlobalLock(lpRender->hData32) );
 813   #endif
 814         }
 815         else
 816         {
 817           memcpy( GlobalLock16(lpRender->hData16),
 818                   GlobalLock(lpRender->hData32),
 819                   size );
 820         }
 821         GlobalUnlock16(lpRender->hData16);
 822         GlobalUnlock(lpRender->hData32);
 823       }
 824     }
 825
 826     TRACE("\treturning %04x (type %i)\n",
 827                               lpRender->hData16, lpRender->wFormatID);
 828     return lpRender->hData16;
 829 }
 830
 831
 832 /**************************************************************************
 833  *             GetClipboardData32   (USER32.222)
 834  */
 835 HANDLE WINAPI GetClipboardData( UINT wFormat )
 836 {
 837     LPWINE_CLIPFORMAT lpRender = ClipFormats;
 838
 839     TRACE("(%08X)\n", wFormat);
 840
 841     if (CLIPBOARD_IsLocked())
 842     {
 843         WARN("Clipboard not opened by calling task!");
 844         return 0;
 845     }
 846
 847     if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
 848     {
 849         lpRender = CLIPBOARD_RenderText(wFormat);
 850         if ( !lpRender ) return 0;
 851     }
 852     else
 853     {
 854         lpRender = __lookup_format( ClipFormats, wFormat );
 855         if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0;
 856     }
 857
 858     /* Convert between 16 -> 32 bit data, if necessary */
 859     if( lpRender->hData16 && !lpRender->hData32 )
 860     {
 861       int size;
 862       if( lpRender->wFormatID == CF_METAFILEPICT )
 863         size = sizeof( METAFILEPICT );
 864       else
 865         size = GlobalSize16(lpRender->hData16);
 866       lpRender->hData32 = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE,
 867                                       size);
 868       if( lpRender->wFormatID == CF_METAFILEPICT )
 869       {
 870         FIXME("\timplement function CopyMetaFilePict16to32\n");
 871         FIXME("\tin the appropriate file.\n");
 872 #ifdef SOMEONE_IMPLEMENTED_ME
 873         CopyMetaFilePict16to32( GlobalLock16(lpRender->hData32),
 874                                 GlobalLock(lpRender->hData16) );
 875 #endif
 876       }
 877       else
 878       {
 879         memcpy( GlobalLock(lpRender->hData32),
 880                 GlobalLock16(lpRender->hData16),
 881                 size );
 882       }
 883       GlobalUnlock(lpRender->hData32);
 884       GlobalUnlock16(lpRender->hData16);
 885     }
 886
 887     TRACE("\treturning %04x (type %i)\n",
 888                               lpRender->hData32, lpRender->wFormatID);
 889     return lpRender->hData32;
 890 }
 891
 892
 893 /**************************************************************************
 894  *           CountClipboardFormats16   (USER.143)
 895  */
 896 INT16 WINAPI CountClipboardFormats16(void)
 897 {
 898     return CountClipboardFormats();
 899 }
 900
 901
 902 /**************************************************************************
 903  *           CountClipboardFormats32   (USER32.63)
 904  */
 905 INT WINAPI CountClipboardFormats(void)
 906 {
 907     INT FormatCount = 0;
 908     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 909
 910     TRACE("()\n");
 911
 912     while(TRUE)
 913     {
 914         if (lpFormat == NULL) break;
 915
 916         if( lpFormat->wFormatID != CF_TEXT ) /* Don't count CF_TEXT */
 917         {
 918           /*
 919            * The format is available if either:
 920            * 1. The data is already in the cache.
 921            * 2. The selection is not owned by us(WINE) and the data is
 922            *    available to the clipboard driver.
 923            */
 924           if ( lpFormat->wDataPresent ||
 925                ( !CLIPBOARD_Driver->pIsSelectionOwner()
 926                  && CLIPBOARD_Driver->pIsFormatAvailable( lpFormat->wFormatID ) ) )
 927           {
 928               TRACE("\tdata found for format %i(%s)\n",
 929                     lpFormat->wFormatID, CLIPBOARD_GetFormatName(lpFormat->wFormatID));
 930               FormatCount++;
 931           }
 932         }
 933
 934         lpFormat = lpFormat->NextFormat;
 935     }
 936
 937     /* these two are equivalent, adjust the total */
 938
 939     FormatCount += abs(ClipFormats[CF_TEXT-1].wDataPresent -
 940                        ClipFormats[CF_OEMTEXT-1].wDataPresent);
 941
 942     TRACE("\ttotal %d\n", FormatCount);
 943     return FormatCount;
 944 }
 945
 946
 947 /**************************************************************************
 948  *            EnumClipboardFormats16   (USER.144)
 949  */
 950 UINT16 WINAPI EnumClipboardFormats16( UINT16 wFormat )
 951 {
 952     return EnumClipboardFormats( wFormat );
 953 }
 954
 955
 956 /**************************************************************************
 957  *            EnumClipboardFormats32   (USER32.179)
 958  */
 959 UINT WINAPI EnumClipboardFormats( UINT wFormat )
 960 {
 961     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 962     BOOL bFormatPresent;
 963
 964     TRACE("(%04X)\n", wFormat);
 965
 966     if (CLIPBOARD_IsLocked())
 967     {
 968         WARN("Clipboard not opened by calling task!");
 969         return 0;
 970     }
 971
 972     if (wFormat == 0) /* start from the beginning */
 973         lpFormat = ClipFormats;
 974     else
 975     {
 976         /* walk up to the specified format record */
 977
 978         if( !(lpFormat = __lookup_format( lpFormat, wFormat )) )
 979             return 0;
 980         lpFormat = lpFormat->NextFormat; /* right */
 981     }
 982
 983     while(TRUE)
 984     {
 985         if (lpFormat == NULL) return 0;
 986
 987         /* Synthesize CF_TEXT from CF_OEMTEXT and vice versa */
 988         bFormatPresent = (lpFormat->wDataPresent ||
 989            (lpFormat->wFormatID == CF_OEMTEXT && ClipFormats[CF_TEXT-1].wDataPresent) ||
 990            (lpFormat->wFormatID == CF_TEXT && ClipFormats[CF_OEMTEXT-1].wDataPresent) );
 991
 992         /* Query the driver if not yet in the cache */
 993         if (!bFormatPresent && !CLIPBOARD_Driver->pIsSelectionOwner())
 994         {
 995             bFormatPresent =
 996                CLIPBOARD_Driver->pIsFormatAvailable( (lpFormat->wFormatID == CF_TEXT) ?
 997                                                       CF_OEMTEXT : lpFormat->wFormatID );
 998         }
 999
1000         if (bFormatPresent)
1001             break;
1002
1003         lpFormat = lpFormat->NextFormat;
1004     }
1005
1006     return lpFormat->wFormatID;
1007 }
1008
1009
1010 /**************************************************************************
1011  *            RegisterClipboardFormat16  (USER.145)
1012  */
1013 UINT16 WINAPI RegisterClipboardFormat16( LPCSTR FormatName )
1014 {
1015     LPWINE_CLIPFORMAT lpNewFormat;
1016     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
1017
1018     if (FormatName == NULL) return 0;
1019
1020     TRACE("('%s') !\n", FormatName);
1021
1022     /* walk format chain to see if it's already registered */
1023
1024     while(TRUE)
1025     {
1026         if ( !strcmp(lpFormat->Name,FormatName) )
1027         {
1028              lpFormat->wRefCount++;
1029              return lpFormat->wFormatID;
1030         }
1031
1032         if ( lpFormat->NextFormat == NULL ) break;
1033
1034         lpFormat = lpFormat->NextFormat;
1035     }
1036
1037     /* allocate storage for new format entry */
1038
1039     lpNewFormat = (LPWINE_CLIPFORMAT)xmalloc(sizeof(WINE_CLIPFORMAT));
1040     lpFormat->NextFormat = lpNewFormat;
1041     lpNewFormat->wFormatID = LastRegFormat;
1042     lpNewFormat->wRefCount = 1;
1043
1044     lpNewFormat->Name = (LPSTR)xmalloc(strlen(FormatName) + 1);
1045     strcpy(lpNewFormat->Name, FormatName);
1046
1047     lpNewFormat->wDataPresent = 0;
1048     lpNewFormat->hData16 = 0;
1049     lpNewFormat->hDataSrc32 = 0;
1050     lpNewFormat->hData32 = 0;
1051     lpNewFormat->drvData = 0;
1052     lpNewFormat->PrevFormat = lpFormat;
1053     lpNewFormat->NextFormat = NULL;
1054
1055     /* Pass on the registration request to the driver */
1056     CLIPBOARD_Driver->pRegisterFormat( FormatName );
1057
1058     return LastRegFormat++;
1059 }
1060
1061
1062 /**************************************************************************
1063  *            RegisterClipboardFormat32A   (USER32.431)
1064  */
1065 UINT WINAPI RegisterClipboardFormatA( LPCSTR formatName )
1066 {
1067     return RegisterClipboardFormat16( formatName );
1068 }
1069
1070
1071 /**************************************************************************
1072  *            RegisterClipboardFormat32W   (USER32.432)
1073  */
1074 UINT WINAPI RegisterClipboardFormatW( LPCWSTR formatName )
1075 {
1076     LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
1077     UINT ret = RegisterClipboardFormatA( aFormat );
1078     HeapFree( GetProcessHeap(), 0, aFormat );
1079     return ret;
1080 }
1081
1082
1083 /**************************************************************************
1084  *            GetClipboardFormatName16   (USER.146)
1085  */
1086 INT16 WINAPI GetClipboardFormatName16( UINT16 wFormat, LPSTR retStr, INT16 maxlen )
1087 {
1088     return GetClipboardFormatNameA( wFormat, retStr, maxlen );
1089 }
1090
1091
1092 /**************************************************************************
1093  *            GetClipboardFormatName32A   (USER32.223)
1094  */
1095 INT WINAPI GetClipboardFormatNameA( UINT wFormat, LPSTR retStr, INT maxlen )
1096 {
1097     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
1098
1099     TRACE("(%04X, %p, %d) !\n", wFormat, retStr, maxlen);
1100
1101     if (lpFormat == NULL || lpFormat->Name == NULL ||
1102         lpFormat->wFormatID < CF_REGFORMATBASE) return 0;
1103
1104     TRACE("Name='%s' !\n", lpFormat->Name);
1105
1106     lstrcpynA( retStr, lpFormat->Name, maxlen );
1107     return strlen(retStr);
1108 }
1109
1110
1111 /**************************************************************************
1112  *            GetClipboardFormatName32W   (USER32.224)
1113  */
1114 INT WINAPI GetClipboardFormatNameW( UINT wFormat, LPWSTR retStr, INT maxlen )
1115 {
1116     LPSTR p = HEAP_xalloc( GetProcessHeap(), 0, maxlen );
1117     INT ret = GetClipboardFormatNameA( wFormat, p, maxlen );
1118     lstrcpynAtoW( retStr, p, maxlen );
1119     HeapFree( GetProcessHeap(), 0, p );
1120     return ret;
1121 }
1122
1123
1124 /**************************************************************************
1125  *            SetClipboardViewer16   (USER.147)
1126  */
1127 HWND16 WINAPI SetClipboardViewer16( HWND16 hWnd )
1128 {
1129     TRACE("(%04x)\n", hWnd);
1130     return SetClipboardViewer( hWnd );
1131 }
1132
1133
1134 /**************************************************************************
1135  *            SetClipboardViewer32   (USER32.471)
1136  */
1137 HWND WINAPI SetClipboardViewer( HWND hWnd )
1138 {
1139     HWND hwndPrev = hWndViewer;
1140
1141     TRACE("(%04x): returning %04x\n", hWnd, hwndPrev);
1142
1143     hWndViewer = hWnd;
1144     return hwndPrev;
1145 }
1146
1147
1148 /**************************************************************************
1149  *           GetClipboardViewer16   (USER.148)
1150  */
1151 HWND16 WINAPI GetClipboardViewer16(void)
1152 {
1153     TRACE("()\n");
1154     return hWndViewer;
1155 }
1156
1157
1158 /**************************************************************************
1159  *           GetClipboardViewer32   (USER32.226)
1160  */
1161 HWND WINAPI GetClipboardViewer(void)
1162 {
1163     TRACE("()\n");
1164     return hWndViewer;
1165 }
1166
1167
1168 /**************************************************************************
1169  *           ChangeClipboardChain16   (USER.149)
1170  */
1171 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hWnd, HWND16 hWndNext)
1172 {
1173     return ChangeClipboardChain(hWnd, hWndNext);
1174 }
1175
1176
1177 /**************************************************************************
1178  *           ChangeClipboardChain32   (USER32.22)
1179  */
1180 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
1181 {
1182     BOOL bRet = 0;
1183
1184     FIXME("(0x%04x, 0x%04x): stub?\n", hWnd, hWndNext);
1185
1186     if( hWndViewer )
1187         bRet = !SendMessage16( hWndViewer, WM_CHANGECBCHAIN,
1188                              (WPARAM16)hWnd, (LPARAM)hWndNext);
1189     else
1190         WARN("hWndViewer is lost\n");
1191
1192     if( hWnd == hWndViewer ) hWndViewer = hWndNext;
1193
1194     return bRet;
1195 }
1196
1197
1198 /**************************************************************************
1199  *           IsClipboardFormatAvailable16   (USER.193)
1200  */
1201 BOOL16 WINAPI IsClipboardFormatAvailable16( UINT16 wFormat )
1202 {
1203     return IsClipboardFormatAvailable( wFormat );
1204 }
1205
1206
1207 /**************************************************************************
1208  *           IsClipboardFormatAvailable32   (USER32.340)
1209  */
1210 BOOL WINAPI IsClipboardFormatAvailable( UINT wFormat )
1211 {
1212     BOOL bRet;
1213
1214     if (wFormat == 0)  /* Reject this case quickly */
1215         bRet = FALSE;
1216
1217     /* If WINE is not the clipboard selection owner ask the clipboard driver */
1218     else if ( !CLIPBOARD_Driver->pIsSelectionOwner() )
1219         bRet = CLIPBOARD_Driver->pIsFormatAvailable( (wFormat == CF_TEXT) ?
1220                                                      CF_OEMTEXT : wFormat );
1221     /* Check if the format is in the local cache */
1222     else
1223         bRet = CLIPBOARD_IsPresent(wFormat);
1224
1225     TRACE("(%04X)- ret(%d)\n", wFormat, bRet);
1226     return bRet;
1227 }
1228
1229
1230 /**************************************************************************
1231  *             GetOpenClipboardWindow16   (USER.248)
1232  *  FIXME: This wont work if an external app owns the selection
1233  */
1234 HWND16 WINAPI GetOpenClipboardWindow16(void)
1235 {
1236     TRACE("()\n");
1237     return hWndClipWindow;
1238 }
1239
1240
1241 /**************************************************************************
1242  *             GetOpenClipboardWindow32   (USER32.277)
1243  *  FIXME: This wont work if an external app owns the selection
1244  */
1245 HWND WINAPI GetOpenClipboardWindow(void)
1246 {
1247     TRACE("()\n");
1248     return hWndClipWindow;
1249 }
1250
1251
1252 /**************************************************************************
1253  *             GetPriorityClipboardFormat16   (USER.402)
1254  */
1255 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *lpPriorityList, INT16 nCount)
1256 {
1257     FIXME("(%p,%d): stub\n", lpPriorityList, nCount );
1258     return 0;
1259 }
1260
1261
1262 /**************************************************************************
1263  *             GetPriorityClipboardFormat32   (USER32.279)
1264  */
1265 INT WINAPI GetPriorityClipboardFormat( UINT *lpPriorityList, INT nCount )
1266 {
1267     int Counter;
1268     TRACE("()\n");
1269
1270     if(CountClipboardFormats() == 0)
1271     {
1272         return 0;
1273     }
1274
1275     for(Counter = 0; Counter <= nCount; Counter++)
1276     {
1277         if(IsClipboardFormatAvailable(*(lpPriorityList+sizeof(INT)*Counter)))
1278             return *(lpPriorityList+sizeof(INT)*Counter);
1279     }
1280
1281     return -1;
1282 }
1283