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