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