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