windows/clipboard.c

   1 /*
   2  * WIN32 clipboard implementation
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1996 Alex Korobka
   6  *           1999 Noel Borthwick
   7  *           2003 Ulrich Czekalla for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * NOTES:
  24  *    This file contains the implementation for the WIN32 Clipboard API
  25  * and Wine's internal clipboard cache.
  26  * The actual contents of the clipboard are held in the clipboard cache.
  27  * The internal implementation talks to a "clipboard driver" to fill or
  28  * expose the cache to the native device. (Currently only the X11 and
  29  * TTY clipboard  driver are available)
  30  */
  31
  32 #include "config.h"
  33 #include "wine/port.h"
  34
  35 #include <stdlib.h>
  36 #include <sys/types.h>
  37 #include <fcntl.h>
  38 #ifdef HAVE_UNISTD_H
  39 # include <unistd.h>
  40 #endif
  41 #include <string.h>
  42
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "wingdi.h"
  46 #include "winuser.h"
  47 #include "winerror.h"
  48 #include "wine/winuser16.h"
  49 #include "wine/winbase16.h"
  50 #include "heap.h"
  51 #include "user.h"
  52 #include "win.h"
  53 #include "clipboard.h"
  54
  55 #include "wine/debug.h"
  56 #include "wine/unicode.h"
  57 #include "wine/server.h"
  58
  59 WINE_DEFAULT_DEBUG_CHANNEL(clipboard);
  60
  61 #define  CF_REGFORMATBASE       0xC000
  62
  63
  64 /*
  65  * Indicates if data has changed since open.
  66  */
  67 static BOOL bCBHasChanged = FALSE;
  68
  69
  70 /**************************************************************************
  71  *                      CLIPBOARD_SetClipboardOwner
  72  */
  73 BOOL CLIPBOARD_SetClipboardOwner(HWND hWnd)
  74 {
  75     BOOL bRet = FALSE;
  76
  77     TRACE(" hWnd(%p)\n", hWnd);
  78
  79     SERVER_START_REQ( set_clipboard_info )
  80     {
  81         req->flags = SET_CB_OWNER;
  82         req->owner = WIN_GetFullHandle( hWnd );
  83
  84         if (wine_server_call_err( req ))
  85         {
  86             ERR("Failed to set clipboard.\n");
  87         }
  88         else
  89         {
  90             bRet = TRUE;
  91         }
  92     }
  93     SERVER_END_REQ;
  94
  95     return bRet;
  96 }
  97
  98
  99 /**************************************************************************
 100  *                      CLIPBOARD_GetClipboardInfo
 101  */
 102 BOOL CLIPBOARD_GetClipboardInfo(LPCLIPBOARDINFO cbInfo)
 103 {
 104     BOOL bRet = FALSE;
 105
 106     SERVER_START_REQ( set_clipboard_info )
 107     {
 108         req->flags = 0;
 109
 110         if (wine_server_call_err( req ))
 111         {
 112             ERR("Failed to get clipboard owner.\n");
 113         }
 114         else
 115         {
 116             cbInfo->hWndOpen = reply->old_clipboard;
 117             cbInfo->hWndOwner = reply->old_owner;
 118             cbInfo->hWndViewer = reply->old_viewer;
 119             cbInfo->seqno = reply->seqno;
 120             cbInfo->flags = reply->flags;
 121
 122             bRet = TRUE;
 123         }
 124     }
 125     SERVER_END_REQ;
 126
 127     return bRet;
 128 }
 129
 130
 131 /**************************************************************************
 132  *      CLIPBOARD_ReleaseOwner
 133  */
 134 BOOL CLIPBOARD_ReleaseOwner(void)
 135 {
 136     BOOL bRet = FALSE;
 137
 138     SERVER_START_REQ( set_clipboard_info )
 139     {
 140         req->flags = SET_CB_RELOWNER | SET_CB_SEQNO;
 141
 142         if (wine_server_call_err( req ))
 143         {
 144             ERR("Failed to set clipboard.\n");
 145         }
 146         else
 147         {
 148             bRet = TRUE;
 149         }
 150     }
 151     SERVER_END_REQ;
 152
 153     return bRet;
 154 }
 155
 156
 157 /**************************************************************************
 158  *              CLIPBOARD_OpenClipboard
 159  */
 160 static BOOL CLIPBOARD_OpenClipboard(HWND hWnd)
 161 {
 162     BOOL bRet = FALSE;
 163
 164     SERVER_START_REQ( set_clipboard_info )
 165     {
 166         req->flags = SET_CB_OPEN;
 167         req->clipboard = WIN_GetFullHandle( hWnd );
 168
 169         if (wine_server_call_err( req ))
 170         {
 171             ERR("Failed to set clipboard.\n");
 172         }
 173         else
 174         {
 175             bRet = TRUE;
 176         }
 177     }
 178     SERVER_END_REQ;
 179
 180     return bRet;
 181 }
 182
 183
 184 /**************************************************************************
 185  *              CLIPBOARD_CloseClipboard
 186  */
 187 static BOOL CLIPBOARD_CloseClipboard(void)
 188 {
 189     BOOL bRet = FALSE;
 190
 191     TRACE(" Changed=%d\n", bCBHasChanged);
 192
 193     SERVER_START_REQ( set_clipboard_info )
 194     {
 195         req->flags = SET_CB_CLOSE;
 196
 197         if (bCBHasChanged)
 198         {
 199             req->flags |= SET_CB_SEQNO;
 200             TRACE("Clipboard data changed\n");
 201         }
 202
 203         if (wine_server_call_err( req ))
 204         {
 205             ERR("Failed to set clipboard.\n");
 206         }
 207         else
 208         {
 209             bRet = TRUE;
 210         }
 211     }
 212     SERVER_END_REQ;
 213
 214     return bRet;
 215 }
 216
 217
 218 /**************************************************************************
 219  *                WIN32 Clipboard implementation
 220  **************************************************************************/
 221
 222 /**************************************************************************
 223  *              RegisterClipboardFormatA (USER32.@)
 224  */
 225 UINT WINAPI RegisterClipboardFormatA(LPCSTR FormatName)
 226 {
 227     UINT wFormatID = 0;
 228
 229     TRACE("%s\n", debugstr_a(FormatName));
 230
 231     if (USER_Driver.pRegisterClipboardFormat)
 232         wFormatID = USER_Driver.pRegisterClipboardFormat(FormatName);
 233
 234     return wFormatID;
 235 }
 236
 237
 238 /**************************************************************************
 239  *              RegisterClipboardFormat (USER.145)
 240  */
 241 UINT16 WINAPI RegisterClipboardFormat16(LPCSTR FormatName)
 242 {
 243     UINT wFormatID = 0;
 244
 245     TRACE("%s\n", debugstr_a(FormatName));
 246
 247     if (USER_Driver.pRegisterClipboardFormat)
 248         wFormatID = USER_Driver.pRegisterClipboardFormat(FormatName);
 249
 250     return wFormatID;
 251 }
 252
 253
 254 /**************************************************************************
 255  *              RegisterClipboardFormatW (USER32.@)
 256  */
 257 UINT WINAPI RegisterClipboardFormatW(LPCWSTR formatName)
 258 {
 259     LPSTR aFormat = HEAP_strdupWtoA( GetProcessHeap(), 0, formatName );
 260     UINT ret = RegisterClipboardFormatA( aFormat );
 261     HeapFree( GetProcessHeap(), 0, aFormat );
 262     return ret;
 263 }
 264
 265
 266 /**************************************************************************
 267  *              GetClipboardFormatName (USER.146)
 268  */
 269 INT16 WINAPI GetClipboardFormatName16(UINT16 wFormat, LPSTR retStr, INT16 maxlen)
 270 {
 271     TRACE("%04x,%p,%d\n", wFormat, retStr, maxlen);
 272
 273     return GetClipboardFormatNameA(wFormat, retStr, maxlen);
 274 }
 275
 276
 277 /**************************************************************************
 278  *              GetClipboardFormatNameA (USER32.@)
 279  */
 280 INT WINAPI GetClipboardFormatNameA(UINT wFormat, LPSTR retStr, INT maxlen)
 281 {
 282     INT len = 0;
 283
 284     TRACE("%04x,%p,%d\n", wFormat, retStr, maxlen);
 285
 286     if (USER_Driver.pGetClipboardFormatName)
 287         len = USER_Driver.pGetClipboardFormatName(wFormat, retStr, maxlen);
 288
 289     return len;
 290 }
 291
 292
 293 /**************************************************************************
 294  *              GetClipboardFormatNameW (USER32.@)
 295  */
 296 INT WINAPI GetClipboardFormatNameW(UINT wFormat, LPWSTR retStr, INT maxlen)
 297 {
 298     INT ret;
 299     LPSTR p = HeapAlloc( GetProcessHeap(), 0, maxlen );
 300     if(p == NULL) return 0; /* FIXME: is this the correct failure value? */
 301
 302     ret = GetClipboardFormatNameA( wFormat, p, maxlen );
 303
 304     if (maxlen > 0 && !MultiByteToWideChar( CP_ACP, 0, p, -1, retStr, maxlen ))
 305         retStr[maxlen-1] = 0;
 306     HeapFree( GetProcessHeap(), 0, p );
 307     return ret;
 308 }
 309
 310
 311 /**************************************************************************
 312  *              OpenClipboard (USER32.@)
 313  *
 314  * Note: Netscape uses NULL hWnd to open the clipboard.
 315  */
 316 BOOL WINAPI OpenClipboard( HWND hWnd )
 317 {
 318     BOOL bRet;
 319
 320     TRACE("(%p)...\n", hWnd);
 321
 322     bRet = CLIPBOARD_OpenClipboard(hWnd);
 323
 324     TRACE(" returning %i\n", bRet);
 325
 326     return bRet;
 327 }
 328
 329
 330 /**************************************************************************
 331  *              CloseClipboard (USER.138)
 332  */
 333 BOOL16 WINAPI CloseClipboard16(void)
 334 {
 335     return CloseClipboard();
 336 }
 337
 338
 339 /**************************************************************************
 340  *              CloseClipboard (USER32.@)
 341  */
 342 BOOL WINAPI CloseClipboard(void)
 343 {
 344     BOOL bRet = FALSE;
 345
 346     TRACE("(%d)\n", bCBHasChanged);
 347
 348     if (CLIPBOARD_CloseClipboard())
 349     {
 350         if (bCBHasChanged)
 351         {
 352             HWND hWndViewer = GetClipboardViewer();
 353
 354             if (USER_Driver.pEndClipboardUpdate)
 355                 USER_Driver.pEndClipboardUpdate();
 356
 357             if (hWndViewer)
 358                 SendMessageW(hWndViewer, WM_DRAWCLIPBOARD, 0, 0);
 359
 360             bCBHasChanged = FALSE;
 361         }
 362
 363         bRet = TRUE;
 364     }
 365
 366     return bRet;
 367 }
 368
 369
 370 /**************************************************************************
 371  *              EmptyClipboard (USER.139)
 372  */
 373 BOOL16 WINAPI EmptyClipboard16(void)
 374 {
 375     return EmptyClipboard();
 376 }
 377
 378
 379 /**************************************************************************
 380  *              EmptyClipboard (USER32.@)
 381  * Empties and acquires ownership of the clipboard
 382  */
 383 BOOL WINAPI EmptyClipboard(void)
 384 {
 385     CLIPBOARDINFO cbinfo;
 386
 387     TRACE("()\n");
 388
 389     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 390         ~cbinfo.flags & CB_OPEN)
 391     {
 392         WARN("Clipboard not opened by calling task!\n");
 393         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 394         return FALSE;
 395     }
 396
 397     /* Destroy private objects */
 398     if (cbinfo.hWndOwner)
 399         SendMessageW(cbinfo.hWndOwner, WM_DESTROYCLIPBOARD, 0, 0);
 400
 401     /* Tell the driver to acquire the selection. The current owner
 402      * will be signaled to delete it's own cache. */
 403     if (~cbinfo.flags & CB_OWNER)
 404     {
 405         /* Assign ownership of the clipboard to the current client. We do
 406          * this before acquiring the selection so that when we do acquire the
 407          * selection and the selection loser gets notified, it can check if
 408          * it has lost the Wine clipboard ownership. If it did then it knows
 409          * that a WM_DESTORYCLIPBOARD has already been sent. Otherwise it
 410          * lost the selection to a X app and it should send the
 411          * WM_DESTROYCLIPBOARD itself. */
 412         CLIPBOARD_SetClipboardOwner(cbinfo.hWndOpen);
 413
 414         /* Acquire the selection. This will notify the previous owner
 415          * to clear it's cache. */
 416         if (USER_Driver.pAcquireClipboard)
 417             USER_Driver.pAcquireClipboard(cbinfo.hWndOpen);
 418     }
 419
 420     /* Empty the local cache */
 421     if (USER_Driver.pEmptyClipboard)
 422         USER_Driver.pEmptyClipboard();
 423
 424     bCBHasChanged = TRUE;
 425
 426     return TRUE;
 427 }
 428
 429
 430 /**************************************************************************
 431  *              GetClipboardOwner (USER32.@)
 432  *  FIXME: Can't return the owner if the clipboard is owned by an external X-app
 433  */
 434 HWND WINAPI GetClipboardOwner(void)
 435 {
 436     HWND hWndOwner = 0;
 437     CLIPBOARDINFO cbinfo;
 438
 439     if (CLIPBOARD_GetClipboardInfo(&cbinfo))
 440         hWndOwner = cbinfo.hWndOwner;
 441
 442     TRACE(" hWndOwner(%p)\n", hWndOwner);
 443
 444     return hWndOwner;
 445 }
 446
 447
 448 /**************************************************************************
 449  *              GetOpenClipboardWindow (USER32.@)
 450  */
 451 HWND WINAPI GetOpenClipboardWindow(void)
 452 {
 453     HWND hWndOpen = 0;
 454     CLIPBOARDINFO cbinfo;
 455
 456     if (CLIPBOARD_GetClipboardInfo(&cbinfo))
 457         hWndOpen = cbinfo.hWndOpen;
 458
 459     TRACE(" hWndClipWindow(%p)\n", hWndOpen);
 460
 461     return hWndOpen;
 462 }
 463
 464
 465 /**************************************************************************
 466  *              SetClipboardViewer (USER32.@)
 467  */
 468 HWND WINAPI SetClipboardViewer( HWND hWnd )
 469 {
 470     HWND hwndPrev = 0;
 471
 472     SERVER_START_REQ( set_clipboard_info )
 473     {
 474         req->flags = SET_CB_VIEWER;
 475         req->viewer = WIN_GetFullHandle(hWnd);
 476
 477         if (wine_server_call_err( req ))
 478         {
 479             ERR("Failed to set clipboard.\n");
 480         }
 481         else
 482         {
 483             hwndPrev = reply->old_viewer;
 484         }
 485     }
 486     SERVER_END_REQ;
 487
 488     TRACE("(%p): returning %p\n", hWnd, hwndPrev);
 489
 490     return hwndPrev;
 491 }
 492
 493
 494 /**************************************************************************
 495  *              GetClipboardViewer (USER32.@)
 496  */
 497 HWND WINAPI GetClipboardViewer(void)
 498 {
 499     HWND hWndViewer = 0;
 500     CLIPBOARDINFO cbinfo;
 501
 502     if (CLIPBOARD_GetClipboardInfo(&cbinfo))
 503         hWndViewer = cbinfo.hWndViewer;
 504
 505     TRACE(" hWndViewer=%p\n", hWndViewer);
 506
 507     return hWndViewer;
 508 }
 509
 510
 511 /**************************************************************************
 512  *              ChangeClipboardChain (USER32.@)
 513  */
 514 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
 515 {
 516     BOOL bRet = TRUE;
 517     HWND hWndViewer = GetClipboardViewer();
 518
 519     if (hWndViewer)
 520     {
 521         if (WIN_GetFullHandle(hWnd) == hWndViewer)
 522             SetClipboardViewer(WIN_GetFullHandle(hWndNext));
 523         else
 524             bRet = !SendMessageW(hWndViewer, WM_CHANGECBCHAIN, (WPARAM)hWnd, (LPARAM)hWndNext);
 525     }
 526     else
 527         ERR("hWndViewer is lost\n");
 528
 529     return bRet;
 530 }
 531
 532
 533 /**************************************************************************
 534  *              SetClipboardData (USER.141)
 535  */
 536 HANDLE16 WINAPI SetClipboardData16(UINT16 wFormat, HANDLE16 hData)
 537 {
 538     CLIPBOARDINFO cbinfo;
 539     HANDLE16 hResult = 0;
 540
 541     TRACE("(%04X, %04x) !\n", wFormat, hData);
 542
 543     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 544         (~cbinfo.flags & CB_OPEN) ||
 545         (~cbinfo.flags & CB_OWNER))
 546     {
 547         WARN("Clipboard not opened by calling task!\n");
 548     }
 549     else if (USER_Driver.pSetClipboardData &&
 550         USER_Driver.pSetClipboardData(wFormat, hData, 0))
 551     {
 552         hResult = hData;
 553         bCBHasChanged = TRUE;
 554     }
 555
 556     return hResult;
 557 }
 558
 559
 560 /**************************************************************************
 561  *              SetClipboardData (USER32.@)
 562  */
 563 HANDLE WINAPI SetClipboardData(UINT wFormat, HANDLE hData)
 564 {
 565     CLIPBOARDINFO cbinfo;
 566     HANDLE hResult = 0;
 567
 568     TRACE("(%04X, %p) !\n", wFormat, hData);
 569
 570     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 571         (~cbinfo.flags & CB_OWNER))
 572     {
 573         WARN("Clipboard not owned by calling task!\n");
 574     }
 575     else if (USER_Driver.pSetClipboardData &&
 576         USER_Driver.pSetClipboardData(wFormat, 0, hData))
 577     {
 578         hResult = hData;
 579         bCBHasChanged = TRUE;
 580     }
 581
 582     return hResult;
 583 }
 584
 585
 586 /**************************************************************************
 587  *              CountClipboardFormats (USER.143)
 588  */
 589 INT16 WINAPI CountClipboardFormats16(void)
 590 {
 591     return CountClipboardFormats();
 592 }
 593
 594
 595 /**************************************************************************
 596  *              CountClipboardFormats (USER32.@)
 597  */
 598 INT WINAPI CountClipboardFormats(void)
 599 {
 600     INT count = 0;
 601
 602     if (USER_Driver.pCountClipboardFormats)
 603         count = USER_Driver.pCountClipboardFormats();
 604
 605     TRACE("returning %d\n", count);
 606     return count;
 607 }
 608
 609
 610 /**************************************************************************
 611  *              EnumClipboardFormats (USER.144)
 612  */
 613 UINT16 WINAPI EnumClipboardFormats16(UINT16 wFormat)
 614 {
 615     return EnumClipboardFormats(wFormat);
 616 }
 617
 618
 619 /**************************************************************************
 620  *              EnumClipboardFormats (USER32.@)
 621  */
 622 UINT WINAPI EnumClipboardFormats(UINT wFormat)
 623 {
 624     UINT wFmt = 0;
 625     CLIPBOARDINFO cbinfo;
 626
 627     TRACE("(%04X)\n", wFormat);
 628
 629     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 630         (~cbinfo.flags & CB_OPEN))
 631     {
 632         WARN("Clipboard not opened by calling task.\n");
 633         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 634         return 0;
 635     }
 636
 637     if (USER_Driver.pEnumClipboardFormats)
 638         wFmt = USER_Driver.pEnumClipboardFormats(wFormat);
 639
 640     return wFmt;
 641 }
 642
 643
 644 /**************************************************************************
 645  *              IsClipboardFormatAvailable (USER.193)
 646  */
 647 BOOL16 WINAPI IsClipboardFormatAvailable16(UINT16 wFormat)
 648 {
 649     return IsClipboardFormatAvailable(wFormat);
 650 }
 651
 652
 653 /**************************************************************************
 654  *              IsClipboardFormatAvailable (USER32.@)
 655  */
 656 BOOL WINAPI IsClipboardFormatAvailable(UINT wFormat)
 657 {
 658     BOOL bret = FALSE;
 659
 660     if (USER_Driver.pIsClipboardFormatAvailable)
 661         bret = USER_Driver.pIsClipboardFormatAvailable(wFormat);
 662
 663     TRACE("%04x, returning %d\n", wFormat, bret);
 664     return bret;
 665 }
 666
 667
 668 /**************************************************************************
 669  *              GetClipboardData (USER.142)
 670  */
 671 HANDLE16 WINAPI GetClipboardData16(UINT16 wFormat)
 672 {
 673     HANDLE16 hData = 0;
 674     CLIPBOARDINFO cbinfo;
 675
 676     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 677         (~cbinfo.flags & CB_OPEN))
 678     {
 679         WARN("Clipboard not opened by calling task.\n");
 680         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 681         return 0;
 682     }
 683
 684     if (USER_Driver.pGetClipboardData)
 685         USER_Driver.pGetClipboardData(wFormat, &hData, NULL);
 686
 687     return hData;
 688 }
 689
 690
 691 /**************************************************************************
 692  *              GetClipboardData (USER32.@)
 693  */
 694 HANDLE WINAPI GetClipboardData(UINT wFormat)
 695 {
 696     HANDLE hData = 0;
 697     CLIPBOARDINFO cbinfo;
 698
 699     TRACE("%04x\n", wFormat);
 700
 701     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 702         (~cbinfo.flags & CB_OPEN))
 703     {
 704         WARN("Clipboard not opened by calling task.\n");
 705         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 706         return 0;
 707     }
 708
 709     if (USER_Driver.pGetClipboardData)
 710         USER_Driver.pGetClipboardData(wFormat, NULL, &hData);
 711
 712     TRACE("returning %p\n", hData);
 713     return hData;
 714 }
 715
 716
 717 /**************************************************************************
 718  *              GetPriorityClipboardFormat (USER32.@)
 719  */
 720 INT WINAPI GetPriorityClipboardFormat(UINT *list, INT nCount)
 721 {
 722     int i;
 723
 724     TRACE("()\n");
 725
 726     if(CountClipboardFormats() == 0)
 727         return 0;
 728
 729     for (i = 0; i < nCount; i++)
 730         if (IsClipboardFormatAvailable(list[i]))
 731             return list[i];
 732
 733     return -1;
 734 }
 735
 736
 737 /**************************************************************************
 738  *              GetClipboardSequenceNumber (USER32.@)
 739  * Supported on Win2k/Win98
 740  * MSDN: Windows clipboard code keeps a serial number for the clipboard
 741  * for each window station.  The number is incremented whenever the
 742  * contents change or are emptied.
 743  * If you do not have WINSTA_ACCESSCLIPBOARD then the function returns 0
 744  */
 745 DWORD WINAPI GetClipboardSequenceNumber(VOID)
 746 {
 747     CLIPBOARDINFO cbinfo;
 748
 749     if (!CLIPBOARD_GetClipboardInfo(&cbinfo))
 750     {
 751         ERR("Failed to get clipboard information.\n");
 752         return 0;
 753     }
 754
 755     TRACE("returning %x\n", cbinfo.seqno);
 756     return cbinfo.seqno;
 757 }