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     UINT flags;
 182
 183     TRACE("(%p)...\n", hWnd);
 184
 185     SERVER_START_REQ( set_clipboard_info )
 186     {
 187         req->flags = SET_CB_OPEN;
 188         req->clipboard = wine_server_user_handle( hWnd );
 189         if ((bRet = !wine_server_call( req )))
 190             flags = reply->flags;
 191     }
 192     SERVER_END_REQ;
 193
 194     if (bRet && !(flags & CB_PROCESS))
 195     {
 196         bCBHasChanged = FALSE;
 197     }
 198
 199     TRACE(" returning %i\n", bRet);
 200
 201     return bRet;
 202 }
 203
 204
 205 /**************************************************************************
 206  *              CloseClipboard (USER32.@)
 207  */
 208 BOOL WINAPI CloseClipboard(void)
 209 {
 210     HWND viewer = 0;
 211     UINT flags;
 212     BOOL ret;
 213
 214     TRACE("() Changed=%d\n", bCBHasChanged);
 215
 216     SERVER_START_REQ( set_clipboard_info )
 217     {
 218         req->flags = SET_CB_CLOSE;
 219         if (bCBHasChanged) req->flags |= SET_CB_SEQNO;
 220         if ((ret = !wine_server_call_err( req )))
 221         {
 222             viewer = wine_server_ptr_handle( reply->old_viewer );
 223             flags = reply->flags;
 224         }
 225     }
 226     SERVER_END_REQ;
 227
 228     if (!ret) return FALSE;
 229
 230     if (bCBHasChanged && (flags & CB_PROCESS))
 231     {
 232         USER_Driver->pEndClipboardUpdate();
 233         if (viewer) SendNotifyMessageW(viewer, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
 234     }
 235     bCBHasChanged = FALSE;
 236     return TRUE;
 237 }
 238
 239
 240 /**************************************************************************
 241  *              EmptyClipboard (USER32.@)
 242  * Empties and acquires ownership of the clipboard
 243  */
 244 BOOL WINAPI EmptyClipboard(void)
 245 {
 246     BOOL ret;
 247     HWND owner = GetClipboardOwner();
 248
 249     TRACE("()\n");
 250
 251     if (owner) SendMessageTimeoutW( owner, WM_DESTROYCLIPBOARD, 0, 0, SMTO_ABORTIFHUNG, 5000, NULL );
 252
 253     SERVER_START_REQ( empty_clipboard )
 254     {
 255         ret = !wine_server_call_err( req );
 256     }
 257     SERVER_END_REQ;
 258
 259     if (ret)
 260     {
 261         USER_Driver->pEmptyClipboard();
 262         bCBHasChanged = TRUE;
 263     }
 264     return ret;
 265 }
 266
 267
 268 /**************************************************************************
 269  *              GetClipboardOwner (USER32.@)
 270  *  FIXME: Can't return the owner if the clipboard is owned by an external X-app
 271  */
 272 HWND WINAPI GetClipboardOwner(void)
 273 {
 274     HWND hWndOwner = 0;
 275
 276     SERVER_START_REQ( set_clipboard_info )
 277     {
 278         req->flags = 0;
 279         if (!wine_server_call_err( req )) hWndOwner = wine_server_ptr_handle( reply->old_owner );
 280     }
 281     SERVER_END_REQ;
 282
 283     TRACE(" hWndOwner(%p)\n", hWndOwner);
 284
 285     return hWndOwner;
 286 }
 287
 288
 289 /**************************************************************************
 290  *              GetOpenClipboardWindow (USER32.@)
 291  */
 292 HWND WINAPI GetOpenClipboardWindow(void)
 293 {
 294     HWND hWndOpen = 0;
 295
 296     SERVER_START_REQ( set_clipboard_info )
 297     {
 298         req->flags = 0;
 299         if (!wine_server_call_err( req )) hWndOpen = wine_server_ptr_handle( reply->old_clipboard );
 300     }
 301     SERVER_END_REQ;
 302
 303     TRACE(" hWndClipWindow(%p)\n", hWndOpen);
 304
 305     return hWndOpen;
 306 }
 307
 308
 309 /**************************************************************************
 310  *              SetClipboardViewer (USER32.@)
 311  */
 312 HWND WINAPI SetClipboardViewer( HWND hWnd )
 313 {
 314     HWND hwndPrev = CLIPBOARD_SetClipboardViewer(hWnd);
 315
 316     if (hWnd)
 317         SendNotifyMessageW(hWnd, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
 318     TRACE("(%p): returning %p\n", hWnd, hwndPrev);
 319
 320     return hwndPrev;
 321 }
 322
 323
 324 /**************************************************************************
 325  *              GetClipboardViewer (USER32.@)
 326  */
 327 HWND WINAPI GetClipboardViewer(void)
 328 {
 329     HWND hWndViewer = 0;
 330
 331     SERVER_START_REQ( set_clipboard_info )
 332     {
 333         req->flags = 0;
 334         if (!wine_server_call_err( req )) hWndViewer = wine_server_ptr_handle( reply->old_viewer );
 335     }
 336     SERVER_END_REQ;
 337
 338     TRACE(" hWndViewer=%p\n", hWndViewer);
 339
 340     return hWndViewer;
 341 }
 342
 343
 344 /**************************************************************************
 345  *              ChangeClipboardChain (USER32.@)
 346  */
 347 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
 348 {
 349     BOOL bRet = TRUE;
 350     HWND hWndViewer = GetClipboardViewer();
 351
 352     if (hWndViewer)
 353     {
 354         if (WIN_GetFullHandle(hWnd) == hWndViewer)
 355             CLIPBOARD_SetClipboardViewer(WIN_GetFullHandle(hWndNext));
 356         else
 357             bRet = !SendMessageW(hWndViewer, WM_CHANGECBCHAIN, (WPARAM)hWnd, (LPARAM)hWndNext);
 358     }
 359     else
 360         ERR("hWndViewer is lost\n");
 361
 362     return bRet;
 363 }
 364
 365
 366 /**************************************************************************
 367  *              SetClipboardData (USER32.@)
 368  */
 369 HANDLE WINAPI SetClipboardData(UINT wFormat, HANDLE hData)
 370 {
 371     CLIPBOARDINFO cbinfo;
 372     HANDLE hResult = 0;
 373
 374     TRACE("(%04X, %p) !\n", wFormat, hData);
 375
 376     if (!wFormat)
 377     {
 378         SetLastError( ERROR_CLIPBOARD_NOT_OPEN );
 379         return 0;
 380     }
 381
 382     /* If it's not owned, data can only be set if the format isn't
 383        available and its rendering is not delayed */
 384     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 385        (!(cbinfo.flags & CB_OWNER) && !hData))
 386     {
 387         WARN("Clipboard not owned by calling task. Operation failed.\n");
 388         return 0;
 389     }
 390
 391     if (USER_Driver->pSetClipboardData(wFormat, hData, cbinfo.flags & CB_OWNER))
 392     {
 393         hResult = hData;
 394         bCBHasChanged = TRUE;
 395     }
 396
 397     return hResult;
 398 }
 399
 400
 401 /**************************************************************************
 402  *              CountClipboardFormats (USER32.@)
 403  */
 404 INT WINAPI CountClipboardFormats(void)
 405 {
 406     INT count = USER_Driver->pCountClipboardFormats();
 407     TRACE("returning %d\n", count);
 408     return count;
 409 }
 410
 411
 412 /**************************************************************************
 413  *              EnumClipboardFormats (USER32.@)
 414  */
 415 UINT WINAPI EnumClipboardFormats(UINT wFormat)
 416 {
 417     CLIPBOARDINFO cbinfo;
 418
 419     TRACE("(%04X)\n", wFormat);
 420
 421     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 422         (~cbinfo.flags & CB_OPEN))
 423     {
 424         WARN("Clipboard not opened by calling task.\n");
 425         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 426         return 0;
 427     }
 428     return USER_Driver->pEnumClipboardFormats(wFormat);
 429 }
 430
 431
 432 /**************************************************************************
 433  *              IsClipboardFormatAvailable (USER32.@)
 434  */
 435 BOOL WINAPI IsClipboardFormatAvailable(UINT wFormat)
 436 {
 437     BOOL bret = USER_Driver->pIsClipboardFormatAvailable(wFormat);
 438     TRACE("%04x, returning %d\n", wFormat, bret);
 439     return bret;
 440 }
 441
 442
 443 /**************************************************************************
 444  *              GetClipboardData (USER32.@)
 445  */
 446 HANDLE WINAPI GetClipboardData(UINT wFormat)
 447 {
 448     HANDLE hData = 0;
 449     CLIPBOARDINFO cbinfo;
 450
 451     TRACE("%04x\n", wFormat);
 452
 453     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
 454         (~cbinfo.flags & CB_OPEN))
 455     {
 456         WARN("Clipboard not opened by calling task.\n");
 457         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
 458         return 0;
 459     }
 460
 461     hData = USER_Driver->pGetClipboardData( wFormat );
 462
 463     TRACE("returning %p\n", hData);
 464     return hData;
 465 }
 466
 467
 468 /**************************************************************************
 469  *              GetPriorityClipboardFormat (USER32.@)
 470  */
 471 INT WINAPI GetPriorityClipboardFormat(UINT *list, INT nCount)
 472 {
 473     int i;
 474
 475     TRACE("()\n");
 476
 477     if(CountClipboardFormats() == 0)
 478         return 0;
 479
 480     for (i = 0; i < nCount; i++)
 481         if (IsClipboardFormatAvailable(list[i]))
 482             return list[i];
 483
 484     return -1;
 485 }
 486
 487
 488 /**************************************************************************
 489  *              GetClipboardSequenceNumber (USER32.@)
 490  * Supported on Win2k/Win98
 491  * MSDN: Windows clipboard code keeps a serial number for the clipboard
 492  * for each window station.  The number is incremented whenever the
 493  * contents change or are emptied.
 494  * If you do not have WINSTA_ACCESSCLIPBOARD then the function returns 0
 495  */
 496 DWORD WINAPI GetClipboardSequenceNumber(VOID)
 497 {
 498     DWORD seqno = 0;
 499
 500     SERVER_START_REQ( set_clipboard_info )
 501     {
 502         req->flags = 0;
 503         if (!wine_server_call_err( req )) seqno = reply->seqno;
 504     }
 505     SERVER_END_REQ;
 506
 507     TRACE("returning %x\n", seqno);
 508     return seqno;
 509 }
 510
 511 /**************************************************************************
 512  *              AddClipboardFormatListener (USER32.@)
 513  */
 514 BOOL WINAPI AddClipboardFormatListener(HWND hwnd)
 515 {
 516     FIXME("%p: stub\n", hwnd);
 517     return TRUE;
 518 }
 519
 520 /**************************************************************************
 521  *              RemoveClipboardFormatListener (USER32.@)
 522  */
 523 BOOL WINAPI RemoveClipboardFormatListener(HWND hwnd)
 524 {
 525     FIXME("%p: stub\n", hwnd);
 526     return TRUE;
 527 }