dlls/user32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "user_private.h"
  50 #include "win.h"
  51
  52 #include "wine/debug.h"
  53 #include "wine/unicode.h"
  54 #include "wine/server.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(clipboard);
  57
  58 #define  CF_REGFORMATBASE  0xC000
  59
  60 typedef struct
  61 {
  62     HWND hWndOpen;
  63     HWND hWndOwner;
  64     UINT flags;
  65 } CLIPBOARDINFO, *LPCLIPBOARDINFO;
  66
  67 /*
  68  * Indicates if data has changed since open.
  69  */
  70 static BOOL bCBHasChanged = FALSE;
  71
  72
  73 /**************************************************************************
  74  *                      CLIPBOARD_SetClipboardOwner
  75  *
  76  * Set the global wineserver clipboard owner. The current process will
  77  * be the owner and <hWnd> will get the render notifications.
  78  */
  79 static BOOL CLIPBOARD_SetClipboardOwner(HWND hWnd)
  80 {
  81     BOOL bRet;
  82
  83     TRACE(" hWnd(%p)\n", hWnd);
  84
  85     SERVER_START_REQ( set_clipboard_info )
  86     {
  87         req->flags = SET_CB_OWNER;
  88         req->owner = wine_server_user_handle( hWnd );
  89         bRet = !wine_server_call_err( req );
  90     }
  91     SERVER_END_REQ;
  92
  93     return bRet;
  94 }
  95
  96
  97 /**************************************************************************
  98  *                      CLIPBOARD_GetClipboardInfo
  99  */
 100 static BOOL CLIPBOARD_GetClipboardInfo(LPCLIPBOARDINFO cbInfo)
 101 {
 102     BOOL bRet;
 103
 104     SERVER_START_REQ( set_clipboard_info )
 105     {
 106         req->flags = 0;
 107
 108         if (((bRet = !wine_server_call_err( req ))))
 109         {
 110             cbInfo->hWndOpen = wine_server_ptr_handle( reply->old_clipboard );
 111             cbInfo->hWndOwner = wine_server_ptr_handle( reply->old_owner );
 112             cbInfo->flags = reply->flags;
 113         }
 114     }
 115     SERVER_END_REQ;
 116
 117     return bRet;
 118 }
 119
 120
 121 /**************************************************************************
 122  *      CLIPBOARD_ReleaseOwner
 123  */
 124 BOOL CLIPBOARD_ReleaseOwner(void)
 125 {
 126     BOOL bRet = FALSE;
 127
 128     SERVER_START_REQ( set_clipboard_info )
 129     {
 130         req->flags = SET_CB_RELOWNER | SET_CB_SEQNO;
 131
 132         if (wine_server_call_err( req ))
 133         {
 134             ERR("Failed to set clipboard.\n");
 135         }
 136         else
 137         {
 138             bRet = TRUE;
 139         }
 140     }
 141     SERVER_END_REQ;
 142
 143     return bRet;
 144 }
 145
 146
 147 /**************************************************************************
 148  *              CLIPBOARD_SetClipboardViewer
 149  */
 150 static HWND CLIPBOARD_SetClipboardViewer( HWND hWnd )
 151 {
 152     HWND hwndPrev = 0;
 153
 154     SERVER_START_REQ( set_clipboard_info )
 155     {
 156         req->flags = SET_CB_VIEWER;
 157         req->viewer = wine_server_user_handle( hWnd );
 158         if (!wine_server_call_err( req ))
 159             hwndPrev = wine_server_ptr_handle( reply->old_viewer );
 160     }
 161     SERVER_END_REQ;
 162
 163     return hwndPrev;
 164 }
 165
 166 /**************************************************************************
 167  *                WIN32 Clipboard implementation
 168  **************************************************************************/
 169
 170 /**************************************************************************
 171  *              RegisterClipboardFormatW (USER32.@)
 172  */
 173 UINT WINAPI RegisterClipboardFormatW( LPCWSTR name )
 174 {
 175     return GlobalAddAtomW( name );
 176 }
 177
 178
 179 /**************************************************************************
 180  *              RegisterClipboardFormatA (USER32.@)
 181  */
 182 UINT WINAPI RegisterClipboardFormatA( LPCSTR name )
 183 {
 184     return GlobalAddAtomA( name );
 185 }
 186
 187
 188 /**************************************************************************
 189  *              GetClipboardFormatNameW (USER32.@)
 190  */
 191 INT WINAPI GetClipboardFormatNameW(UINT wFormat, LPWSTR retStr, INT maxlen)
 192 {
 193     if (wFormat < MAXINTATOM) return 0;
 194     return GlobalGetAtomNameW( wFormat, retStr, maxlen );
 195 }
 196
 197
 198 /**************************************************************************
 199  *              GetClipboardFormatNameA (USER32.@)
 200  */
 201 INT WINAPI GetClipboardFormatNameA(UINT wFormat, LPSTR retStr, INT maxlen)
 202 {
 203     if (wFormat < MAXINTATOM) return 0;
 204     return GlobalGetAtomNameA( wFormat, retStr, maxlen );
 205 }
 206
 207
 208 /**************************************************************************
 209  *              OpenClipboard (USER32.@)
 210  *
 211  * Note: Netscape uses NULL hWnd to open the clipboard.
 212  */
 213 BOOL WINAPI OpenClipboard( HWND hWnd )
 214 {
 215     BOOL bRet;
 216
 217     TRACE("(%p)...\n", hWnd);
 218
 219     SERVER_START_REQ( set_clipboard_info )
 220     {
 221         req->flags = SET_CB_OPEN;
 222         req->clipboard = wine_server_user_handle( hWnd );
 223         bRet = !wine_server_call( req );
 224     }
 225     SERVER_END_REQ;
 226
 227     TRACE(" returning %i\n", bRet);
 228
 229     return bRet;
 230 }
 231
 232
 233 /**************************************************************************
 234  *              CloseClipboard (USER32.@)
 235  */
 236 BOOL WINAPI CloseClipboard(void)
 237 {
 238     HWND viewer = 0;
 239     BOOL ret;
 240
 241     TRACE("() Changed=%d\n", bCBHasChanged);
 242
 243     SERVER_START_REQ( set_clipboard_info )
 244     {
 245         req->flags = SET_CB_CLOSE;
 246         if (bCBHasChanged) req->flags |= SET_CB_SEQNO;
 247         if ((ret = !wine_server_call_err( req )))
 248             viewer = wine_server_ptr_handle( reply->old_viewer );
 249     }
 250     SERVER_END_REQ;
 251
 252     if (!ret) return FALSE;
 253
 254     if (bCBHasChanged)
 255     {
 256         USER_Driver->pEndClipboardUpdate();
 257         bCBHasChanged = FALSE;
 258         if (viewer) SendNotifyMessageW(viewer, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
 259     }
 260     return TRUE;
 261 }
 262
 263
 264 /**************************************************************************
 265  *              EmptyClipboard (USER32.@)
 266  * Empties and acquires ownership of the clipboard
 267  */
 268 BOOL WINAPI EmptyClipboard(void)
 269 {
 270     CLIPBOARDINFO cbinfo;
 271
 272     TRACE("()\n");
 273
 274     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 275         ~cbinfo.flags & CB_OPEN)
 276     {
 277         WARN("Clipboard not opened by calling task!\n");
 278         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 279         return FALSE;
 280     }
 281
 282     /* Destroy private objects */
 283     if (cbinfo.hWndOwner)
 284         SendMessageW(cbinfo.hWndOwner, WM_DESTROYCLIPBOARD, 0, 0);
 285
 286     /* Tell the driver to acquire the selection. The current owner
 287      * will be signaled to delete its own cache. */
 288
 289     /* Assign ownership of the clipboard to the current client. We do
 290      * this before acquiring the selection so that when we do acquire the
 291      * selection and the selection loser gets notified, it can check if
 292      * it has lost the Wine clipboard ownership. If it did then it knows
 293      * that a WM_DESTROYCLIPBOARD has already been sent. Otherwise it
 294      * lost the selection to a X app and it should send the
 295      * WM_DESTROYCLIPBOARD itself. */
 296     CLIPBOARD_SetClipboardOwner(cbinfo.hWndOpen);
 297
 298     /* Acquire the selection. This will notify the previous owner
 299      * to clear its cache. */
 300     USER_Driver->pAcquireClipboard(cbinfo.hWndOpen);
 301
 302     USER_Driver->pEmptyClipboard();
 303
 304     bCBHasChanged = TRUE;
 305
 306     return TRUE;
 307 }
 308
 309
 310 /**************************************************************************
 311  *              GetClipboardOwner (USER32.@)
 312  *  FIXME: Can't return the owner if the clipboard is owned by an external X-app
 313  */
 314 HWND WINAPI GetClipboardOwner(void)
 315 {
 316     HWND hWndOwner = 0;
 317
 318     SERVER_START_REQ( set_clipboard_info )
 319     {
 320         req->flags = 0;
 321         if (!wine_server_call_err( req )) hWndOwner = wine_server_ptr_handle( reply->old_owner );
 322     }
 323     SERVER_END_REQ;
 324
 325     TRACE(" hWndOwner(%p)\n", hWndOwner);
 326
 327     return hWndOwner;
 328 }
 329
 330
 331 /**************************************************************************
 332  *              GetOpenClipboardWindow (USER32.@)
 333  */
 334 HWND WINAPI GetOpenClipboardWindow(void)
 335 {
 336     HWND hWndOpen = 0;
 337
 338     SERVER_START_REQ( set_clipboard_info )
 339     {
 340         req->flags = 0;
 341         if (!wine_server_call_err( req )) hWndOpen = wine_server_ptr_handle( reply->old_clipboard );
 342     }
 343     SERVER_END_REQ;
 344
 345     TRACE(" hWndClipWindow(%p)\n", hWndOpen);
 346
 347     return hWndOpen;
 348 }
 349
 350
 351 /**************************************************************************
 352  *              SetClipboardViewer (USER32.@)
 353  */
 354 HWND WINAPI SetClipboardViewer( HWND hWnd )
 355 {
 356     HWND hwndPrev = CLIPBOARD_SetClipboardViewer(hWnd);
 357
 358     if (hWnd)
 359         SendNotifyMessageW(hWnd, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
 360     TRACE("(%p): returning %p\n", hWnd, hwndPrev);
 361
 362     return hwndPrev;
 363 }
 364
 365
 366 /**************************************************************************
 367  *              GetClipboardViewer (USER32.@)
 368  */
 369 HWND WINAPI GetClipboardViewer(void)
 370 {
 371     HWND hWndViewer = 0;
 372
 373     SERVER_START_REQ( set_clipboard_info )
 374     {
 375         req->flags = 0;
 376         if (!wine_server_call_err( req )) hWndViewer = wine_server_ptr_handle( reply->old_viewer );
 377     }
 378     SERVER_END_REQ;
 379
 380     TRACE(" hWndViewer=%p\n", hWndViewer);
 381
 382     return hWndViewer;
 383 }
 384
 385
 386 /**************************************************************************
 387  *              ChangeClipboardChain (USER32.@)
 388  */
 389 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
 390 {
 391     BOOL bRet = TRUE;
 392     HWND hWndViewer = GetClipboardViewer();
 393
 394     if (hWndViewer)
 395     {
 396         if (WIN_GetFullHandle(hWnd) == hWndViewer)
 397             CLIPBOARD_SetClipboardViewer(WIN_GetFullHandle(hWndNext));
 398         else
 399             bRet = !SendMessageW(hWndViewer, WM_CHANGECBCHAIN, (WPARAM)hWnd, (LPARAM)hWndNext);
 400     }
 401     else
 402         ERR("hWndViewer is lost\n");
 403
 404     return bRet;
 405 }
 406
 407
 408 /**************************************************************************
 409  *              SetClipboardData (USER32.@)
 410  */
 411 HANDLE WINAPI SetClipboardData(UINT wFormat, HANDLE hData)
 412 {
 413     CLIPBOARDINFO cbinfo;
 414     HANDLE hResult = 0;
 415
 416     TRACE("(%04X, %p) !\n", wFormat, hData);
 417
 418     /* If it's not owned, data can only be set if the format isn't
 419        available and its rendering is not delayed */
 420     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 421        (!(cbinfo.flags & CB_OWNER) && !hData))
 422     {
 423         WARN("Clipboard not owned by calling task. Operation failed.\n");
 424         return 0;
 425     }
 426
 427     if (USER_Driver->pSetClipboardData(wFormat, hData, cbinfo.flags & CB_OWNER))
 428     {
 429         hResult = hData;
 430         bCBHasChanged = TRUE;
 431     }
 432
 433     return hResult;
 434 }
 435
 436
 437 /**************************************************************************
 438  *              CountClipboardFormats (USER32.@)
 439  */
 440 INT WINAPI CountClipboardFormats(void)
 441 {
 442     INT count = USER_Driver->pCountClipboardFormats();
 443     TRACE("returning %d\n", count);
 444     return count;
 445 }
 446
 447
 448 /**************************************************************************
 449  *              EnumClipboardFormats (USER32.@)
 450  */
 451 UINT WINAPI EnumClipboardFormats(UINT wFormat)
 452 {
 453     CLIPBOARDINFO cbinfo;
 454
 455     TRACE("(%04X)\n", wFormat);
 456
 457     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 458         (~cbinfo.flags & CB_OPEN))
 459     {
 460         WARN("Clipboard not opened by calling task.\n");
 461         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 462         return 0;
 463     }
 464     return USER_Driver->pEnumClipboardFormats(wFormat);
 465 }
 466
 467
 468 /**************************************************************************
 469  *              IsClipboardFormatAvailable (USER32.@)
 470  */
 471 BOOL WINAPI IsClipboardFormatAvailable(UINT wFormat)
 472 {
 473     BOOL bret = USER_Driver->pIsClipboardFormatAvailable(wFormat);
 474     TRACE("%04x, returning %d\n", wFormat, bret);
 475     return bret;
 476 }
 477
 478
 479 /**************************************************************************
 480  *              GetClipboardData (USER32.@)
 481  */
 482 HANDLE WINAPI GetClipboardData(UINT wFormat)
 483 {
 484     HANDLE hData = 0;
 485     CLIPBOARDINFO cbinfo;
 486
 487     TRACE("%04x\n", wFormat);
 488
 489     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 490         (~cbinfo.flags & CB_OPEN))
 491     {
 492         WARN("Clipboard not opened by calling task.\n");
 493         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 494         return 0;
 495     }
 496
 497     hData = USER_Driver->pGetClipboardData( wFormat );
 498
 499     TRACE("returning %p\n", hData);
 500     return hData;
 501 }
 502
 503
 504 /**************************************************************************
 505  *              GetPriorityClipboardFormat (USER32.@)
 506  */
 507 INT WINAPI GetPriorityClipboardFormat(UINT *list, INT nCount)
 508 {
 509     int i;
 510
 511     TRACE("()\n");
 512
 513     if(CountClipboardFormats() == 0)
 514         return 0;
 515
 516     for (i = 0; i < nCount; i++)
 517         if (IsClipboardFormatAvailable(list[i]))
 518             return list[i];
 519
 520     return -1;
 521 }
 522
 523
 524 /**************************************************************************
 525  *              GetClipboardSequenceNumber (USER32.@)
 526  * Supported on Win2k/Win98
 527  * MSDN: Windows clipboard code keeps a serial number for the clipboard
 528  * for each window station.  The number is incremented whenever the
 529  * contents change or are emptied.
 530  * If you do not have WINSTA_ACCESSCLIPBOARD then the function returns 0
 531  */
 532 DWORD WINAPI GetClipboardSequenceNumber(VOID)
 533 {
 534     DWORD seqno = 0;
 535
 536     SERVER_START_REQ( set_clipboard_info )
 537     {
 538         req->flags = 0;
 539         if (!wine_server_call_err( req )) seqno = reply->seqno;
 540     }
 541     SERVER_END_REQ;
 542
 543     TRACE("returning %x\n", seqno);
 544     return seqno;
 545 }
 546
 547 /**************************************************************************
 548  *              AddClipboardFormatListener (USER32.@)
 549  */
 550 BOOL WINAPI AddClipboardFormatListener(HWND hwnd)
 551 {
 552     FIXME("%p: stub\n", hwnd);
 553     return TRUE;
 554 }
 555
 556 /**************************************************************************
 557  *              RemoveClipboardFormatListener (USER32.@)
 558  */
 559 BOOL WINAPI RemoveClipboardFormatListener(HWND hwnd)
 560 {
 561     FIXME("%p: stub\n", hwnd);
 562     return TRUE;
 563 }