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