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