windows/clipboard.c

   1 /*
   2  * WINE clipboard function handling
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1996 Alex Korobka
   6  *
   7  */
   8
   9 #include <stdlib.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <fcntl.h>
  13 #include <unistd.h>
  14 #include <string.h>
  15 #include "winuser.h"
  16 #include "wine/winuser16.h"
  17 #include "heap.h"
  18 #include "task.h"
  19 #include "message.h"
  20 #include "clipboard.h"
  21 #include "xmalloc.h"
  22 #include "debugtools.h"
  23
  24 DEFAULT_DEBUG_CHANNEL(clipboard)
  25
  26 #define  CF_REGFORMATBASE       0xC000
  27
  28 /**************************************************************************
  29  *                      internal variables
  30  */
  31
  32 CLIPBOARD_DRIVER *CLIPBOARD_Driver = NULL;
  33
  34 static HQUEUE16 hqClipLock   = 0;
  35 static BOOL bCBHasChanged  = FALSE;
  36
  37 HWND hWndClipOwner  = 0;   /* current clipboard owner */
  38 HWND hWndClipWindow = 0;   /* window that opened clipboard */
  39 static HWND hWndViewer     = 0;   /* start of viewers chain */
  40
  41 static WORD LastRegFormat = CF_REGFORMATBASE;
  42
  43 WINE_CLIPFORMAT ClipFormats[16]  = {
  44     { CF_TEXT, 1, 0, "Text", (HANDLE)NULL, (HANDLE)NULL, 0, NULL, &ClipFormats[1] , (HANDLE16)NULL},
  45     { CF_BITMAP, 1, 0, "Bitmap", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[0], &ClipFormats[2] , (HANDLE16)NULL},
  46     { CF_METAFILEPICT, 1, 0, "MetaFile Picture", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[1], &ClipFormats[3] , (HANDLE16)NULL},
  47     { CF_SYLK, 1, 0, "Sylk", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[2], &ClipFormats[4] , (HANDLE16)NULL},
  48     { CF_DIF, 1, 0, "DIF", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[3], &ClipFormats[5] , (HANDLE16)NULL},
  49     { CF_TIFF, 1, 0, "TIFF", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[4], &ClipFormats[6] , (HANDLE16)NULL},
  50     { CF_OEMTEXT, 1, 0, "OEM Text", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[5], &ClipFormats[7] , (HANDLE16)NULL},
  51     { CF_DIB, 1, 0, "DIB", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[6], &ClipFormats[8] , (HANDLE16)NULL},
  52     { CF_PALETTE, 1, 0, "Palette", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[7], &ClipFormats[9] , (HANDLE16)NULL},
  53     { CF_PENDATA, 1, 0, "PenData", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[8], &ClipFormats[10] , (HANDLE16)NULL},
  54     { CF_RIFF, 1, 0, "RIFF", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[9], &ClipFormats[11] , (HANDLE16)NULL},
  55     { CF_WAVE, 1, 0, "Wave", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[10], &ClipFormats[12] , (HANDLE16)NULL},
  56     { CF_OWNERDISPLAY, 1, 0, "Owner Display", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[11], &ClipFormats[13] , (HANDLE16)NULL},
  57     { CF_DSPTEXT, 1, 0, "DSPText", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[12], &ClipFormats[14] , (HANDLE16)NULL},
  58     { CF_DSPMETAFILEPICT, 1, 0, "DSPMetaFile Picture", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[13], &ClipFormats[15] , (HANDLE16)NULL},
  59     { CF_DSPBITMAP, 1, 0, "DSPBitmap", (HANDLE)NULL, (HANDLE)NULL, 0, &ClipFormats[14], NULL , (HANDLE16)NULL}
  60     };
  61
  62 static LPWINE_CLIPFORMAT __lookup_format( LPWINE_CLIPFORMAT lpFormat, WORD wID )
  63 {
  64     while(TRUE)
  65     {
  66         if (lpFormat == NULL ||
  67             lpFormat->wFormatID == wID) break;
  68         lpFormat = lpFormat->NextFormat;
  69     }
  70     return lpFormat;
  71 }
  72
  73 /**************************************************************************
  74  *                      CLIPBOARD_ResetLock
  75  */
  76 void CLIPBOARD_ResetLock( HQUEUE16 hqCurrent, HQUEUE16 hqNew )
  77 {
  78     if( hqClipLock == hqCurrent )
  79     {
  80         if( hqNew )
  81             hqClipLock = hqNew;
  82         else
  83         {
  84             hWndClipOwner = 0;
  85             hWndClipWindow = 0;
  86             EmptyClipboard();
  87             hqClipLock = 0;
  88         }
  89     }
  90 }
  91
  92
  93 /**************************************************************************
  94  *                      CLIPBOARD_DeleteRecord
  95  */
  96 void CLIPBOARD_DeleteRecord(LPWINE_CLIPFORMAT lpFormat, BOOL bChange)
  97 {
  98     if( (lpFormat->wFormatID >= CF_GDIOBJFIRST &&
  99          lpFormat->wFormatID <= CF_GDIOBJLAST) || lpFormat->wFormatID == CF_BITMAP )
 100     {
 101       if (lpFormat->hData32)
 102         DeleteObject(lpFormat->hData32);
 103       if (lpFormat->hData16)
 104         DeleteObject16(lpFormat->hData16);
 105     }
 106     else if( lpFormat->wFormatID == CF_METAFILEPICT )
 107     {
 108       if (lpFormat->hData32)
 109       {
 110         DeleteMetaFile( ((METAFILEPICT *)GlobalLock( lpFormat->hData32 ))->hMF );
 111         GlobalFree(lpFormat->hData32);
 112         if (lpFormat->hDataSrc32)
 113           GlobalFree(lpFormat->hDataSrc32);
 114         if (lpFormat->hData16)
 115           /* HMETAFILE16 and HMETAFILE32 are apparently the same thing,
 116              and a shallow copy is enough to share a METAFILEPICT
 117              structure between 16bit and 32bit clipboards.  The MetaFile
 118              should of course only be deleted once. */
 119           GlobalFree16(lpFormat->hData16);
 120       }
 121       if (lpFormat->hData16)
 122       {
 123         DeleteMetaFile16( ((METAFILEPICT16 *)GlobalLock16( lpFormat->hData16 ))->hMF );
 124         GlobalFree16(lpFormat->hData16);
 125       }
 126     }
 127     else
 128     {
 129       if (lpFormat->hData32)
 130         GlobalFree(lpFormat->hData32);
 131       if (lpFormat->hDataSrc32)
 132         GlobalFree(lpFormat->hDataSrc32);
 133       if (lpFormat->hData16)
 134         GlobalFree16(lpFormat->hData16);
 135     }
 136
 137     lpFormat->wDataPresent = 0;
 138     lpFormat->hData16 = 0;
 139     lpFormat->hData32 = 0;
 140
 141     if( bChange ) bCBHasChanged = TRUE;
 142 }
 143
 144 /**************************************************************************
 145  *                      CLIPBOARD_IsPresent
 146  */
 147 BOOL CLIPBOARD_IsPresent(WORD wFormat)
 148 {
 149     /* special case */
 150
 151     if( wFormat == CF_TEXT || wFormat == CF_OEMTEXT )
 152         return ClipFormats[CF_TEXT-1].wDataPresent ||
 153                ClipFormats[CF_OEMTEXT-1].wDataPresent;
 154     else
 155     {
 156         LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 157         if( lpFormat ) return (lpFormat->wDataPresent);
 158     }
 159     return FALSE;
 160 }
 161
 162 /**************************************************************************
 163  *                      CLIPBOARD_IsMemoryObject
 164  *  Tests if the clipboard format specifies a memory object
 165  */
 166 BOOL CLIPBOARD_IsMemoryObject( WORD wFormat )
 167 {
 168     switch(wFormat)
 169     {
 170         case CF_BITMAP:
 171         case CF_METAFILEPICT:
 172         case CF_DSPTEXT:
 173         case CF_ENHMETAFILE:
 174         case CF_HDROP:
 175         case CF_PALETTE:
 176         case CF_PENDATA:
 177             return FALSE;
 178         default:
 179             return TRUE;
 180      }
 181 }
 182
 183 /***********************************************************************
 184  * CLIPBOARD_GlobalDupMem( HGLOBAL )
 185  * Helper method to duplicate an HGLOBAL chunk of memory into shared memory
 186  */
 187 HGLOBAL CLIPBOARD_GlobalDupMem( HGLOBAL hGlobalSrc )
 188 {
 189     HGLOBAL hGlobalDest;
 190     PVOID pGlobalSrc, pGlobalDest;
 191     DWORD cBytes;
 192
 193     if ( !hGlobalSrc )
 194       return 0;
 195
 196     cBytes = GlobalSize(hGlobalSrc);
 197     if ( 0 == cBytes )
 198       return 0;
 199
 200     /* Turn on the DDESHARE and _MOVEABLE flags explicitly */
 201     hGlobalDest = GlobalAlloc( GlobalFlags(hGlobalSrc) | GMEM_DDESHARE | GMEM_MOVEABLE,
 202                                cBytes );
 203     if ( !hGlobalDest )
 204       return 0;
 205
 206     pGlobalSrc = GlobalLock(hGlobalSrc);
 207     pGlobalDest = GlobalLock(hGlobalDest);
 208     if ( !pGlobalSrc || !pGlobalDest )
 209       return 0;
 210
 211     memcpy(pGlobalDest, pGlobalSrc, cBytes);
 212
 213     GlobalUnlock(hGlobalSrc);
 214     GlobalUnlock(hGlobalDest);
 215
 216     return hGlobalDest;
 217 }
 218
 219 /**************************************************************************
 220  *            OpenClipboard16   (USER.137)
 221  */
 222 BOOL16 WINAPI OpenClipboard16( HWND16 hWnd )
 223 {
 224     return OpenClipboard( hWnd );
 225 }
 226
 227
 228 /**************************************************************************
 229  *            OpenClipboard32   (USER32.407)
 230  *
 231  * Note: Netscape uses NULL hWnd to open the clipboard.
 232  */
 233 BOOL WINAPI OpenClipboard( HWND hWnd )
 234 {
 235     BOOL bRet;
 236
 237     TRACE("(%04x)...\n", hWnd);
 238
 239     if (!hqClipLock)
 240     {
 241          hqClipLock = GetFastQueue16();
 242          hWndClipWindow = hWnd;
 243          bCBHasChanged = FALSE;
 244          bRet = TRUE;
 245     }
 246     else bRet = FALSE;
 247
 248     TRACE("   returning %i\n", bRet);
 249     return bRet;
 250 }
 251
 252
 253 /**************************************************************************
 254  *            CloseClipboard16   (USER.138)
 255  */
 256 BOOL16 WINAPI CloseClipboard16(void)
 257 {
 258     return CloseClipboard();
 259 }
 260
 261
 262 /**************************************************************************
 263  *            CloseClipboard32   (USER32.54)
 264  */
 265 BOOL WINAPI CloseClipboard(void)
 266 {
 267     TRACE("!\n");
 268
 269     if (hqClipLock == GetFastQueue16())
 270     {
 271         hWndClipWindow = 0;
 272
 273         if (bCBHasChanged && hWndViewer)
 274             SendMessage16(hWndViewer, WM_DRAWCLIPBOARD, 0, 0L);
 275         hqClipLock = 0;
 276     }
 277     return TRUE;
 278 }
 279
 280
 281 /**************************************************************************
 282  *            EmptyClipboard16   (USER.139)
 283  */
 284 BOOL16 WINAPI EmptyClipboard16(void)
 285 {
 286     return EmptyClipboard();
 287 }
 288
 289
 290 /**************************************************************************
 291  *            EmptyClipboard32   (USER32.169)
 292  */
 293 BOOL WINAPI EmptyClipboard(void)
 294 {
 295     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 296
 297     TRACE("(void)\n");
 298
 299     if (hqClipLock != GetFastQueue16()) return FALSE;
 300
 301     /* destroy private objects */
 302
 303     if (hWndClipOwner)
 304         SendMessage16(hWndClipOwner, WM_DESTROYCLIPBOARD, 0, 0L);
 305
 306     while(lpFormat)
 307     {
 308         if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
 309              CLIPBOARD_DeleteRecord( lpFormat, TRUE );
 310
 311         lpFormat = lpFormat->NextFormat;
 312     }
 313
 314     hWndClipOwner = hWndClipWindow;
 315
 316     CLIPBOARD_Driver->pEmpty();
 317
 318     return TRUE;
 319 }
 320
 321
 322 /**************************************************************************
 323  *            GetClipboardOwner16   (USER.140)
 324  */
 325 HWND16 WINAPI GetClipboardOwner16(void)
 326 {
 327     return hWndClipOwner;
 328 }
 329
 330
 331 /**************************************************************************
 332  *            GetClipboardOwner32   (USER32.225)
 333  */
 334 HWND WINAPI GetClipboardOwner(void)
 335 {
 336     return hWndClipOwner;
 337 }
 338
 339
 340 /**************************************************************************
 341  *            SetClipboardData16   (USER.141)
 342  */
 343 HANDLE16 WINAPI SetClipboardData16( UINT16 wFormat, HANDLE16 hData )
 344 {
 345     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 346
 347     TRACE("(%04X, %04x) !\n", wFormat, hData);
 348
 349     /* NOTE: If the hData is zero and current owner doesn't match
 350      * the window that opened the clipboard then this application
 351      * is screwed because WM_RENDERFORMAT will go to the owner
 352      * (to become the owner it must call EmptyClipboard() before
 353      *  adding new data).
 354      */
 355
 356     if( (hqClipLock != GetFastQueue16()) || !lpFormat ||
 357         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0;
 358
 359     CLIPBOARD_Driver->pSetData(wFormat);
 360
 361     if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
 362     {
 363         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
 364
 365         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
 366
 367         if( wFormat == CF_TEXT
 368             && ( ClipFormats[CF_OEMTEXT-1].hData16
 369                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 370             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
 371             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
 372         if( wFormat == CF_OEMTEXT
 373             && ( ClipFormats[CF_OEMTEXT-1].hData16
 374                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 375             && !ClipFormats[CF_TEXT-1].wDataPresent )
 376             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
 377     }
 378
 379     bCBHasChanged = TRUE;
 380     lpFormat->wDataPresent = 1;
 381     lpFormat->hData16 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
 382     lpFormat->hData32 = 0;
 383
 384     return lpFormat->hData16;
 385 }
 386
 387
 388 /**************************************************************************
 389  *            SetClipboardData   (USER32.470)
 390  */
 391 HANDLE WINAPI SetClipboardData( UINT wFormat, HANDLE hData )
 392 {
 393     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 394
 395     TRACE("(%08X, %08x) !\n", wFormat, hData);
 396
 397     /* NOTE: If the hData is zero and current owner doesn't match
 398      * the window that opened the clipboard then this application
 399      * is screwed because WM_RENDERFORMAT will go to the owner
 400      * (to become the owner it must call EmptyClipboard() before
 401      *  adding new data).
 402      */
 403
 404     if( (hqClipLock != GetFastQueue16()) || !lpFormat ||
 405         (!hData && (!hWndClipOwner || (hWndClipOwner != hWndClipWindow))) ) return 0;
 406
 407     CLIPBOARD_Driver->pSetData(wFormat);
 408
 409     if ( lpFormat->wDataPresent || lpFormat->hData16 || lpFormat->hData32 )
 410     {
 411         CLIPBOARD_DeleteRecord(lpFormat, TRUE);
 412
 413         /* delete existing CF_TEXT/CF_OEMTEXT aliases */
 414
 415         if( wFormat == CF_TEXT
 416             && ( ClipFormats[CF_OEMTEXT-1].hData16
 417                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 418             && !ClipFormats[CF_OEMTEXT-1].wDataPresent )
 419             CLIPBOARD_DeleteRecord(&ClipFormats[CF_OEMTEXT-1], TRUE);
 420         if( wFormat == CF_OEMTEXT
 421             && ( ClipFormats[CF_OEMTEXT-1].hData16
 422                  ||  ClipFormats[CF_OEMTEXT-1].hData32 )
 423             && !ClipFormats[CF_TEXT-1].wDataPresent )
 424             CLIPBOARD_DeleteRecord(&ClipFormats[CF_TEXT-1], TRUE);
 425     }
 426
 427     bCBHasChanged = TRUE;
 428     lpFormat->wDataPresent = 1;
 429     lpFormat->hDataSrc32 = hData;  /* Save the source handle */
 430
 431     /*
 432      * Make a shared duplicate if the memory is not shared
 433      * TODO: What should be done for non-memory objects
 434      */
 435     if ( CLIPBOARD_IsMemoryObject(wFormat) && hData && !(GlobalFlags(hData) & GMEM_DDESHARE) )
 436         lpFormat->hData32 = CLIPBOARD_GlobalDupMem( hData );
 437     else
 438     lpFormat->hData32 = hData;          /* 0 is legal, see WM_RENDERFORMAT */
 439
 440     lpFormat->hData16 = 0;
 441
 442     return lpFormat->hData32;
 443 }
 444
 445
 446 /**************************************************************************
 447  *                      CLIPBOARD_RenderFormat
 448  */
 449 static BOOL CLIPBOARD_RenderFormat(LPWINE_CLIPFORMAT lpFormat)
 450 {
 451   if( lpFormat->wDataPresent && !lpFormat->hData16 && !lpFormat->hData32 )
 452   {
 453     if( IsWindow(hWndClipOwner) )
 454       SendMessage16(hWndClipOwner,WM_RENDERFORMAT,
 455                     (WPARAM16)lpFormat->wFormatID,0L);
 456     else
 457     {
 458       WARN("\thWndClipOwner (%04x) is lost!\n",
 459            hWndClipOwner);
 460       hWndClipOwner = 0; lpFormat->wDataPresent = 0;
 461       return FALSE;
 462     }
 463   }
 464   return (lpFormat->hData16 || lpFormat->hData32) ? TRUE : FALSE;
 465 }
 466
 467 /**************************************************************************
 468  *                      CLIPBOARD_RenderText
 469  *
 470  * Convert text between UNIX and DOS formats.
 471  *
 472  * FIXME: Should be a pair of driver functions that convert between OEM text and Windows.
 473  *
 474  */
 475 static BOOL CLIPBOARD_RenderText(LPWINE_CLIPFORMAT lpTarget, LPWINE_CLIPFORMAT lpSource)
 476 {
 477     UINT16 size;
 478     LPCSTR lpstrS;
 479     LPSTR  lpstrT;
 480
 481     if (lpSource->hData32)
 482     {
 483       size = GlobalSize( lpSource->hData32 );
 484       lpstrS = (LPSTR)GlobalLock(lpSource->hData32);
 485     }
 486     else
 487     {
 488       size = GlobalSize16( lpSource->hData16 );
 489       lpstrS = (LPSTR)GlobalLock16(lpSource->hData16);
 490     }
 491
 492     if( !lpstrS ) return FALSE;
 493     TRACE("\tconverting from '%s' to '%s', %i chars\n",
 494                                       lpSource->Name, lpTarget->Name, size);
 495
 496     lpTarget->hData32 = GlobalAlloc(GMEM_ZEROINIT, size);
 497     lpstrT = (LPSTR)GlobalLock(lpTarget->hData32);
 498
 499     if( lpstrT )
 500     {
 501         if( lpSource->wFormatID == CF_TEXT )
 502             CharToOemBuffA(lpstrS, lpstrT, size);
 503         else
 504             OemToCharBuffA(lpstrS, lpstrT, size);
 505         TRACE("\tgot %s\n", lpstrT);
 506         GlobalUnlock(lpTarget->hData32);
 507         if (lpSource->hData32)
 508           GlobalUnlock(lpSource->hData32);
 509         else
 510           GlobalUnlock16(lpSource->hData16);
 511         return TRUE;
 512     }
 513
 514     lpTarget->hData32 = 0;
 515     if (lpSource->hData32)
 516       GlobalUnlock(lpSource->hData32);
 517     else
 518       GlobalUnlock16(lpSource->hData16);
 519     return FALSE;
 520 }
 521
 522 /**************************************************************************
 523  *             GetClipboardData16   (USER.142)
 524  */
 525 HANDLE16 WINAPI GetClipboardData16( UINT16 wFormat )
 526 {
 527     LPWINE_CLIPFORMAT lpRender = ClipFormats;
 528     LPWINE_CLIPFORMAT lpUpdate = NULL;
 529
 530     if (hqClipLock != GetFastQueue16()) return 0;
 531
 532     TRACE("(%04X)\n", wFormat);
 533
 534     if( wFormat == CF_TEXT && !lpRender[CF_TEXT-1].wDataPresent
 535                            &&  lpRender[CF_OEMTEXT-1].wDataPresent )
 536     {
 537         lpRender = &ClipFormats[CF_OEMTEXT-1];
 538         lpUpdate = &ClipFormats[CF_TEXT-1];
 539
 540         TRACE("\tOEMTEXT -> TEXT\n");
 541     }
 542     else if( wFormat == CF_OEMTEXT && !lpRender[CF_OEMTEXT-1].wDataPresent
 543                                    &&  lpRender[CF_TEXT-1].wDataPresent )
 544     {
 545         lpRender = &ClipFormats[CF_TEXT-1];
 546         lpUpdate = &ClipFormats[CF_OEMTEXT-1];
 547
 548         TRACE("\tTEXT -> OEMTEXT\n");
 549     }
 550     else
 551     {
 552         lpRender = __lookup_format( ClipFormats, wFormat );
 553         lpUpdate = lpRender;
 554     }
 555
 556     if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0;
 557     if( lpUpdate != lpRender && !lpUpdate->hData16 && !lpUpdate->hData32 )
 558         CLIPBOARD_RenderText(lpUpdate, lpRender);
 559
 560     if( lpUpdate->hData32 && !lpUpdate->hData16 )
 561     {
 562       int size;
 563       if( lpUpdate->wFormatID == CF_METAFILEPICT )
 564         size = sizeof( METAFILEPICT16 );
 565       else
 566         size = GlobalSize(lpUpdate->hData32);
 567       lpUpdate->hData16 = GlobalAlloc16(GMEM_ZEROINIT, size);
 568       if( !lpUpdate->hData16 )
 569         ERR("(%04X) -- not enough memory in 16b heap\n", wFormat);
 570       else
 571       {
 572       if( lpUpdate->wFormatID == CF_METAFILEPICT )
 573       {
 574         FIXME("\timplement function CopyMetaFilePict32to16\n");
 575         FIXME("\tin the appropriate file.\n");
 576 #ifdef SOMEONE_IMPLEMENTED_ME
 577         CopyMetaFilePict32to16( GlobalLock16(lpUpdate->hData16),
 578                                 GlobalLock(lpUpdate->hData32) );
 579 #endif
 580       }
 581       else
 582       {
 583         memcpy( GlobalLock16(lpUpdate->hData16),
 584                 GlobalLock(lpUpdate->hData32),
 585                 size );
 586       }
 587         GlobalUnlock16(lpUpdate->hData16);
 588         GlobalUnlock(lpUpdate->hData32);
 589       }
 590     }
 591
 592     TRACE("\treturning %04x (type %i)\n",
 593                               lpUpdate->hData16, lpUpdate->wFormatID);
 594     return lpUpdate->hData16;
 595 }
 596
 597
 598 /**************************************************************************
 599  *             GetClipboardData32   (USER32.222)
 600  */
 601 HANDLE WINAPI GetClipboardData( UINT wFormat )
 602 {
 603     LPWINE_CLIPFORMAT lpRender = ClipFormats;
 604     LPWINE_CLIPFORMAT lpUpdate = NULL;
 605
 606     if (hqClipLock != GetFastQueue16()) return 0;
 607
 608     TRACE("(%08X)\n", wFormat);
 609
 610     if( wFormat == CF_TEXT && !lpRender[CF_TEXT-1].wDataPresent
 611                            &&  lpRender[CF_OEMTEXT-1].wDataPresent )
 612     {
 613         lpRender = &ClipFormats[CF_OEMTEXT-1];
 614         lpUpdate = &ClipFormats[CF_TEXT-1];
 615
 616         TRACE("\tOEMTEXT -> TEXT\n");
 617     }
 618     else if( wFormat == CF_OEMTEXT && !lpRender[CF_OEMTEXT-1].wDataPresent
 619                                    &&  lpRender[CF_TEXT-1].wDataPresent )
 620     {
 621         lpRender = &ClipFormats[CF_TEXT-1];
 622         lpUpdate = &ClipFormats[CF_OEMTEXT-1];
 623
 624         TRACE("\tTEXT -> OEMTEXT\n");
 625     }
 626     else
 627     {
 628         lpRender = __lookup_format( ClipFormats, wFormat );
 629         lpUpdate = lpRender;
 630     }
 631
 632     if( !lpRender || !CLIPBOARD_RenderFormat(lpRender) ) return 0;
 633     if( lpUpdate != lpRender && !lpUpdate->hData16 && !lpUpdate->hData32 )
 634         CLIPBOARD_RenderText(lpUpdate, lpRender);
 635
 636     if( lpUpdate->hData16 && !lpUpdate->hData32 )
 637     {
 638       int size;
 639       if( lpUpdate->wFormatID == CF_METAFILEPICT )
 640         size = sizeof( METAFILEPICT );
 641       else
 642         size = GlobalSize16(lpUpdate->hData16);
 643       lpUpdate->hData32 = GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE,
 644                                       size);
 645       if( lpUpdate->wFormatID == CF_METAFILEPICT )
 646       {
 647         FIXME("\timplement function CopyMetaFilePict16to32\n");
 648         FIXME("\tin the appropriate file.\n");
 649 #ifdef SOMEONE_IMPLEMENTED_ME
 650         CopyMetaFilePict16to32( GlobalLock16(lpUpdate->hData32),
 651                                 GlobalLock(lpUpdate->hData16) );
 652 #endif
 653       }
 654       else
 655       {
 656         memcpy( GlobalLock(lpUpdate->hData32),
 657                 GlobalLock16(lpUpdate->hData16),
 658                 size );
 659       }
 660       GlobalUnlock(lpUpdate->hData32);
 661       GlobalUnlock16(lpUpdate->hData16);
 662     }
 663
 664     TRACE("\treturning %04x (type %i)\n",
 665                               lpUpdate->hData32, lpUpdate->wFormatID);
 666     return lpUpdate->hData32;
 667 }
 668
 669 /**************************************************************************
 670  *           CountClipboardFormats16   (USER.143)
 671  */
 672 INT16 WINAPI CountClipboardFormats16(void)
 673 {
 674     return CountClipboardFormats();
 675 }
 676
 677
 678 /**************************************************************************
 679  *           CountClipboardFormats32   (USER32.63)
 680  */
 681 INT WINAPI CountClipboardFormats(void)
 682 {
 683     INT FormatCount = 0;
 684     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 685
 686     TRACE("(void)\n");
 687
 688     while(TRUE)
 689     {
 690         if (lpFormat == NULL) break;
 691
 692         if( lpFormat->wFormatID != CF_TEXT )
 693             CLIPBOARD_Driver->pGetData( lpFormat->wFormatID );
 694
 695         if (lpFormat->wDataPresent)
 696         {
 697             TRACE("\tdata found for format %i\n", lpFormat->wFormatID);
 698             FormatCount++;
 699         }
 700         lpFormat = lpFormat->NextFormat;
 701     }
 702
 703     /* these two are equivalent, adjust the total */
 704
 705     FormatCount += abs(ClipFormats[CF_TEXT-1].wDataPresent -
 706                        ClipFormats[CF_OEMTEXT-1].wDataPresent);
 707
 708     TRACE("\ttotal %d\n", FormatCount);
 709     return FormatCount;
 710 }
 711
 712
 713 /**************************************************************************
 714  *            EnumClipboardFormats16   (USER.144)
 715  */
 716 UINT16 WINAPI EnumClipboardFormats16( UINT16 wFormat )
 717 {
 718     return EnumClipboardFormats( wFormat );
 719 }
 720
 721
 722 /**************************************************************************
 723  *            EnumClipboardFormats32   (USER32.179)
 724  */
 725 UINT WINAPI EnumClipboardFormats( UINT wFormat )
 726 {
 727     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 728
 729     TRACE("(%04X)\n", wFormat);
 730
 731     if( hqClipLock != GetFastQueue16() ) return 0;
 732
 733     if( wFormat < CF_OEMTEXT )
 734         CLIPBOARD_Driver->pGetData( CF_OEMTEXT );
 735
 736     if (wFormat == 0) /* start from the beginning */
 737         lpFormat = ClipFormats;
 738     else
 739     {
 740         /* walk up to the specified format record */
 741
 742         if( !(lpFormat = __lookup_format( lpFormat, wFormat )) )
 743             return 0;
 744         lpFormat = lpFormat->NextFormat; /* right */
 745     }
 746
 747     while(TRUE)
 748     {
 749         if (lpFormat == NULL) return 0;
 750
 751         if( lpFormat->wFormatID != CF_OEMTEXT && lpFormat->wFormatID != CF_TEXT )
 752             CLIPBOARD_Driver->pGetData( lpFormat->wFormatID );
 753
 754         if (lpFormat->wDataPresent ||
 755            (lpFormat->wFormatID == CF_OEMTEXT && ClipFormats[CF_TEXT-1].wDataPresent) ||
 756            (lpFormat->wFormatID == CF_TEXT && ClipFormats[CF_OEMTEXT-1].wDataPresent) )
 757             break;
 758         lpFormat = lpFormat->NextFormat;
 759     }
 760
 761     return lpFormat->wFormatID;
 762 }
 763
 764
 765 /**************************************************************************
 766  *            RegisterClipboardFormat16  (USER.145)
 767  */
 768 UINT16 WINAPI RegisterClipboardFormat16( LPCSTR FormatName )
 769 {
 770     LPWINE_CLIPFORMAT lpNewFormat;
 771     LPWINE_CLIPFORMAT lpFormat = ClipFormats;
 772
 773     if (FormatName == NULL) return 0;
 774
 775     TRACE("('%s') !\n", FormatName);
 776
 777     /* walk format chain to see if it's already registered */
 778
 779     while(TRUE)
 780     {
 781         if ( !strcmp(lpFormat->Name,FormatName) )
 782         {
 783              lpFormat->wRefCount++;
 784              return lpFormat->wFormatID;
 785         }
 786
 787         if ( lpFormat->NextFormat == NULL ) break;
 788
 789         lpFormat = lpFormat->NextFormat;
 790     }
 791
 792     /* allocate storage for new format entry */
 793
 794     lpNewFormat = (LPWINE_CLIPFORMAT)xmalloc(sizeof(WINE_CLIPFORMAT));
 795     lpFormat->NextFormat = lpNewFormat;
 796     lpNewFormat->wFormatID = LastRegFormat;
 797     lpNewFormat->wRefCount = 1;
 798
 799     lpNewFormat->Name = (LPSTR)xmalloc(strlen(FormatName) + 1);
 800     strcpy(lpNewFormat->Name, FormatName);
 801
 802     lpNewFormat->wDataPresent = 0;
 803     lpNewFormat->hData16 = 0;
 804     lpNewFormat->hDataSrc32 = 0;
 805     lpNewFormat->hData32 = 0;
 806     lpNewFormat->BufSize = 0;
 807     lpNewFormat->PrevFormat = lpFormat;
 808     lpNewFormat->NextFormat = NULL;
 809
 810     return LastRegFormat++;
 811 }
 812
 813
 814 /**************************************************************************
 815  *            RegisterClipboardFormat32A   (USER32.431)
 816  */
 817 UINT WINAPI RegisterClipboardFormatA( LPCSTR formatName )
 818 {
 819     return RegisterClipboardFormat16( formatName );
 820 }
 821
 822
 823 /**************************************************************************
 824  *            RegisterClipboardFormat32W   (USER32.432)
 825  */
 826 UINT WINAPI RegisterClipboardFormatW( LPCWSTR formatName )
 827 {
 828     LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
 829     UINT ret = RegisterClipboardFormatA( aFormat );
 830     HeapFree( GetProcessHeap(), 0, aFormat );
 831     return ret;
 832 }
 833
 834 /**************************************************************************
 835  *            GetClipboardFormatName16   (USER.146)
 836  */
 837 INT16 WINAPI GetClipboardFormatName16( UINT16 wFormat, LPSTR retStr, INT16 maxlen )
 838 {
 839     return GetClipboardFormatNameA( wFormat, retStr, maxlen );
 840 }
 841
 842
 843 /**************************************************************************
 844  *            GetClipboardFormatName32A   (USER32.223)
 845  */
 846 INT WINAPI GetClipboardFormatNameA( UINT wFormat, LPSTR retStr, INT maxlen )
 847 {
 848     LPWINE_CLIPFORMAT lpFormat = __lookup_format( ClipFormats, wFormat );
 849
 850     TRACE("(%04X, %p, %d) !\n", wFormat, retStr, maxlen);
 851
 852     if (lpFormat == NULL || lpFormat->Name == NULL ||
 853         lpFormat->wFormatID < CF_REGFORMATBASE) return 0;
 854
 855     TRACE("Name='%s' !\n", lpFormat->Name);
 856
 857     lstrcpynA( retStr, lpFormat->Name, maxlen );
 858     return strlen(retStr);
 859 }
 860
 861
 862 /**************************************************************************
 863  *            GetClipboardFormatName32W   (USER32.224)
 864  */
 865 INT WINAPI GetClipboardFormatNameW( UINT wFormat, LPWSTR retStr, INT maxlen )
 866 {
 867     LPSTR p = HEAP_xalloc( GetProcessHeap(), 0, maxlen );
 868     INT ret = GetClipboardFormatNameA( wFormat, p, maxlen );
 869     lstrcpynAtoW( retStr, p, maxlen );
 870     HeapFree( GetProcessHeap(), 0, p );
 871     return ret;
 872 }
 873
 874
 875 /**************************************************************************
 876  *            SetClipboardViewer16   (USER.147)
 877  */
 878 HWND16 WINAPI SetClipboardViewer16( HWND16 hWnd )
 879 {
 880     return SetClipboardViewer( hWnd );
 881 }
 882
 883
 884 /**************************************************************************
 885  *            SetClipboardViewer32   (USER32.471)
 886  */
 887 HWND WINAPI SetClipboardViewer( HWND hWnd )
 888 {
 889     HWND hwndPrev = hWndViewer;
 890
 891     TRACE("(%04x): returning %04x\n", hWnd, hwndPrev);
 892
 893     hWndViewer = hWnd;
 894     return hwndPrev;
 895 }
 896
 897
 898 /**************************************************************************
 899  *           GetClipboardViewer16   (USER.148)
 900  */
 901 HWND16 WINAPI GetClipboardViewer16(void)
 902 {
 903     return hWndViewer;
 904 }
 905
 906
 907 /**************************************************************************
 908  *           GetClipboardViewer32   (USER32.226)
 909  */
 910 HWND WINAPI GetClipboardViewer(void)
 911 {
 912     return hWndViewer;
 913 }
 914
 915
 916 /**************************************************************************
 917  *           ChangeClipboardChain16   (USER.149)
 918  */
 919 BOOL16 WINAPI ChangeClipboardChain16(HWND16 hWnd, HWND16 hWndNext)
 920 {
 921     return ChangeClipboardChain(hWnd, hWndNext);
 922 }
 923
 924 /**************************************************************************
 925  *           ChangeClipboardChain32   (USER32.22)
 926  */
 927 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
 928 {
 929     BOOL bRet = 0;
 930
 931     FIXME("(0x%04x, 0x%04x): stub?\n", hWnd, hWndNext);
 932
 933     if( hWndViewer )
 934         bRet = !SendMessage16( hWndViewer, WM_CHANGECBCHAIN,
 935                              (WPARAM16)hWnd, (LPARAM)hWndNext);
 936     else
 937         WARN("hWndViewer is lost\n");
 938
 939     if( hWnd == hWndViewer ) hWndViewer = hWndNext;
 940
 941     return bRet;
 942 }
 943
 944
 945
 946 /**************************************************************************
 947  *           IsClipboardFormatAvailable16   (USER.193)
 948  */
 949 BOOL16 WINAPI IsClipboardFormatAvailable16( UINT16 wFormat )
 950 {
 951     return IsClipboardFormatAvailable( wFormat );
 952 }
 953
 954
 955 /**************************************************************************
 956  *           IsClipboardFormatAvailable32   (USER32.340)
 957  */
 958 BOOL WINAPI IsClipboardFormatAvailable( UINT wFormat )
 959 {
 960     TRACE("(%04X) !\n", wFormat);
 961
 962     CLIPBOARD_Driver->pGetData( (wFormat == CF_TEXT) ? CF_OEMTEXT : wFormat );
 963
 964     return CLIPBOARD_IsPresent(wFormat);
 965 }
 966
 967
 968 /**************************************************************************
 969  *             GetOpenClipboardWindow16   (USER.248)
 970  */
 971 HWND16 WINAPI GetOpenClipboardWindow16(void)
 972 {
 973     return hWndClipWindow;
 974 }
 975
 976
 977 /**************************************************************************
 978  *             GetOpenClipboardWindow32   (USER32.277)
 979  */
 980 HWND WINAPI GetOpenClipboardWindow(void)
 981 {
 982     return hWndClipWindow;
 983 }
 984
 985
 986 /**************************************************************************
 987  *             GetPriorityClipboardFormat16   (USER.402)
 988  */
 989 INT16 WINAPI GetPriorityClipboardFormat16( UINT16 *lpPriorityList, INT16 nCount)
 990 {
 991     FIXME("(%p,%d): stub\n", lpPriorityList, nCount );
 992     return 0;
 993 }
 994
 995
 996 /**************************************************************************
 997  *             GetPriorityClipboardFormat32   (USER32.279)
 998  */
 999 INT WINAPI GetPriorityClipboardFormat( UINT *lpPriorityList, INT nCount )
1000 {
1001     int Counter;
1002
1003     if(CountClipboardFormats() == 0)
1004     {
1005         return 0;
1006     }
1007
1008     for(Counter = 0; Counter <= nCount; Counter++)
1009     {
1010         if(IsClipboardFormatAvailable(*(lpPriorityList+sizeof(INT)*Counter)))
1011             return *(lpPriorityList+sizeof(INT)*Counter);
1012     }
1013
1014     return -1;
1015 }
1016
1017
1018