windows/clipboard.c

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