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