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