Sort entry points in the same order as Windows.
[wine] / dlls / user / 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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     UINT wFormatID = 0;
232
233     TRACE("%s\n", debugstr_w(FormatName));
234
235     if (USER_Driver.pRegisterClipboardFormat)
236         wFormatID = USER_Driver.pRegisterClipboardFormat(FormatName);
237
238     return wFormatID;
239 }
240
241
242 /**************************************************************************
243  *              RegisterClipboardFormatA (USER32.@)
244  */
245 UINT WINAPI RegisterClipboardFormatA(LPCSTR formatName)
246 {
247     int len;
248     LPWSTR wFormat;
249     UINT ret;
250
251     len = MultiByteToWideChar(CP_ACP, 0, formatName, -1, NULL, 0);
252     wFormat = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
253     MultiByteToWideChar(CP_ACP, 0, formatName, -1, wFormat, len);
254
255     ret = RegisterClipboardFormatW(wFormat);
256     HeapFree(GetProcessHeap(), 0, wFormat);
257     return ret;
258 }
259
260
261 /**************************************************************************
262  *              GetClipboardFormatNameW (USER32.@)
263  */
264 INT WINAPI GetClipboardFormatNameW(UINT wFormat, LPWSTR retStr, INT maxlen)
265 {
266     INT len = 0;
267
268     TRACE("%04x,%p,%d\n", wFormat, retStr, maxlen);
269
270     if (USER_Driver.pGetClipboardFormatName)
271         len = USER_Driver.pGetClipboardFormatName(wFormat, retStr, maxlen);
272
273     return len;
274 }
275
276
277 /**************************************************************************
278  *              GetClipboardFormatNameA (USER32.@)
279  */
280 INT WINAPI GetClipboardFormatNameA(UINT wFormat, LPSTR retStr, INT maxlen)
281 {
282     INT ret;
283     LPWSTR p = HeapAlloc( GetProcessHeap(), 0, maxlen*sizeof(WCHAR) );
284     if(p == NULL) return 0; /* FIXME: is this the correct failure value? */
285
286     ret = GetClipboardFormatNameW( wFormat, p, maxlen );
287
288     if (maxlen > 0 && !WideCharToMultiByte( CP_ACP, 0, p, -1, retStr, maxlen, 0, 0))
289         retStr[maxlen-1] = 0;
290     HeapFree( GetProcessHeap(), 0, p );
291     return ret;
292 }
293
294
295 /**************************************************************************
296  *              OpenClipboard (USER32.@)
297  *
298  * Note: Netscape uses NULL hWnd to open the clipboard.
299  */
300 BOOL WINAPI OpenClipboard( HWND hWnd )
301 {
302     BOOL bRet;
303
304     TRACE("(%p)...\n", hWnd);
305
306     bRet = CLIPBOARD_OpenClipboard(hWnd);
307
308     TRACE(" returning %i\n", bRet);
309
310     return bRet;
311 }
312
313
314 /**************************************************************************
315  *              CloseClipboard (USER32.@)
316  */
317 BOOL WINAPI CloseClipboard(void)
318 {
319     BOOL bRet = FALSE;
320
321     TRACE("(%d)\n", bCBHasChanged);
322
323     if (CLIPBOARD_CloseClipboard())
324     {
325         if (bCBHasChanged)
326         {
327             HWND hWndViewer = GetClipboardViewer();
328
329             if (USER_Driver.pEndClipboardUpdate)
330                 USER_Driver.pEndClipboardUpdate();
331
332             if (hWndViewer)
333                 SendMessageW(hWndViewer, WM_DRAWCLIPBOARD, 0, 0);
334
335             bCBHasChanged = FALSE;
336         }
337
338         bRet = TRUE;
339     }
340
341     return bRet;
342 }
343
344
345 /**************************************************************************
346  *              EmptyClipboard (USER32.@)
347  * Empties and acquires ownership of the clipboard
348  */
349 BOOL WINAPI EmptyClipboard(void)
350 {
351     CLIPBOARDINFO cbinfo;
352
353     TRACE("()\n");
354
355     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
356         ~cbinfo.flags & CB_OPEN)
357     {
358         WARN("Clipboard not opened by calling task!\n");
359         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
360         return FALSE;
361     }
362
363     /* Destroy private objects */
364     if (cbinfo.hWndOwner)
365         SendMessageW(cbinfo.hWndOwner, WM_DESTROYCLIPBOARD, 0, 0);
366
367     /* Tell the driver to acquire the selection. The current owner
368      * will be signaled to delete it's own cache. */
369
370     /* Assign ownership of the clipboard to the current client. We do
371      * this before acquiring the selection so that when we do acquire the
372      * selection and the selection loser gets notified, it can check if
373      * it has lost the Wine clipboard ownership. If it did then it knows
374      * that a WM_DESTORYCLIPBOARD has already been sent. Otherwise it
375      * lost the selection to a X app and it should send the
376      * WM_DESTROYCLIPBOARD itself. */
377     CLIPBOARD_SetClipboardOwner(cbinfo.hWndOpen);
378
379     /* Acquire the selection. This will notify the previous owner
380      * to clear it's cache. */
381     if (USER_Driver.pAcquireClipboard)
382         USER_Driver.pAcquireClipboard(cbinfo.hWndOpen);
383
384     /* Empty the local cache */
385     if (USER_Driver.pEmptyClipboard)
386         USER_Driver.pEmptyClipboard(FALSE);
387
388     bCBHasChanged = TRUE;
389
390     return TRUE;
391 }
392
393
394 /**************************************************************************
395  *              GetClipboardOwner (USER32.@)
396  *  FIXME: Can't return the owner if the clipboard is owned by an external X-app
397  */
398 HWND WINAPI GetClipboardOwner(void)
399 {
400     HWND hWndOwner = 0;
401
402     SERVER_START_REQ( set_clipboard_info )
403     {
404         req->flags = 0;
405         if (!wine_server_call_err( req )) hWndOwner = reply->old_owner;
406     }
407     SERVER_END_REQ;
408
409     TRACE(" hWndOwner(%p)\n", hWndOwner);
410
411     return hWndOwner;
412 }
413
414
415 /**************************************************************************
416  *              GetOpenClipboardWindow (USER32.@)
417  */
418 HWND WINAPI GetOpenClipboardWindow(void)
419 {
420     HWND hWndOpen = 0;
421
422     SERVER_START_REQ( set_clipboard_info )
423     {
424         req->flags = 0;
425         if (!wine_server_call_err( req )) hWndOpen = reply->old_clipboard;
426     }
427     SERVER_END_REQ;
428
429     TRACE(" hWndClipWindow(%p)\n", hWndOpen);
430
431     return hWndOpen;
432 }
433
434
435 /**************************************************************************
436  *              SetClipboardViewer (USER32.@)
437  */
438 HWND WINAPI SetClipboardViewer( HWND hWnd )
439 {
440     HWND hwndPrev = 0;
441
442     SERVER_START_REQ( set_clipboard_info )
443     {
444         req->flags = SET_CB_VIEWER;
445         req->viewer = WIN_GetFullHandle(hWnd);
446
447         if (wine_server_call_err( req ))
448         {
449             ERR("Failed to set clipboard.\n");
450         }
451         else
452         {
453             hwndPrev = reply->old_viewer;
454         }
455     }
456     SERVER_END_REQ;
457
458     TRACE("(%p): returning %p\n", hWnd, hwndPrev);
459
460     return hwndPrev;
461 }
462
463
464 /**************************************************************************
465  *              GetClipboardViewer (USER32.@)
466  */
467 HWND WINAPI GetClipboardViewer(void)
468 {
469     HWND hWndViewer = 0;
470
471     SERVER_START_REQ( set_clipboard_info )
472     {
473         req->flags = 0;
474         if (!wine_server_call_err( req )) hWndViewer = reply->old_viewer;
475     }
476     SERVER_END_REQ;
477
478     TRACE(" hWndViewer=%p\n", hWndViewer);
479
480     return hWndViewer;
481 }
482
483
484 /**************************************************************************
485  *              ChangeClipboardChain (USER32.@)
486  */
487 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
488 {
489     BOOL bRet = TRUE;
490     HWND hWndViewer = GetClipboardViewer();
491
492     if (hWndViewer)
493     {
494         if (WIN_GetFullHandle(hWnd) == hWndViewer)
495             SetClipboardViewer(WIN_GetFullHandle(hWndNext));
496         else
497             bRet = !SendMessageW(hWndViewer, WM_CHANGECBCHAIN, (WPARAM)hWnd, (LPARAM)hWndNext);
498     }
499     else
500         ERR("hWndViewer is lost\n");
501
502     return bRet;
503 }
504
505
506 /**************************************************************************
507  *              SetClipboardData (USER.141)
508  */
509 HANDLE16 WINAPI SetClipboardData16(UINT16 wFormat, HANDLE16 hData)
510 {
511     CLIPBOARDINFO cbinfo;
512     HANDLE16 hResult = 0;
513
514     TRACE("(%04X, %04x) !\n", wFormat, hData);
515
516     /* If it's not owned, data can only be set if the format doesn't exists
517        and its rendering is not delayed */
518     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
519         (!(cbinfo.flags & CB_OWNER) && !hData))
520     {
521         WARN("Clipboard not owned by calling task. Operation failed.\n");
522         return 0;
523     }
524
525     if (USER_Driver.pSetClipboardData &&
526         USER_Driver.pSetClipboardData(wFormat, hData, 0, cbinfo.flags & CB_OWNER))
527     {
528         hResult = hData;
529         bCBHasChanged = TRUE;
530     }
531
532     return hResult;
533 }
534
535
536 /**************************************************************************
537  *              SetClipboardData (USER32.@)
538  */
539 HANDLE WINAPI SetClipboardData(UINT wFormat, HANDLE hData)
540 {
541     CLIPBOARDINFO cbinfo;
542     HANDLE hResult = 0;
543
544     TRACE("(%04X, %p) !\n", wFormat, hData);
545
546     /* If it's not owned, data can only be set if the format isn't
547        available and its rendering is not delayed */
548     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
549        (!(cbinfo.flags & CB_OWNER) && !hData))
550     {
551         WARN("Clipboard not owned by calling task. Operation failed.\n");
552         return 0;
553     }
554
555     if (USER_Driver.pSetClipboardData &&
556         USER_Driver.pSetClipboardData(wFormat, 0, hData, cbinfo.flags & CB_OWNER))
557     {
558         hResult = hData;
559         bCBHasChanged = TRUE;
560     }
561
562     return hResult;
563 }
564
565
566 /**************************************************************************
567  *              CountClipboardFormats (USER32.@)
568  */
569 INT WINAPI CountClipboardFormats(void)
570 {
571     INT count = 0;
572
573     if (USER_Driver.pCountClipboardFormats)
574         count = USER_Driver.pCountClipboardFormats();
575
576     TRACE("returning %d\n", count);
577     return count;
578 }
579
580
581 /**************************************************************************
582  *              EnumClipboardFormats (USER32.@)
583  */
584 UINT WINAPI EnumClipboardFormats(UINT wFormat)
585 {
586     UINT wFmt = 0;
587     CLIPBOARDINFO cbinfo;
588
589     TRACE("(%04X)\n", wFormat);
590
591     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
592         (~cbinfo.flags & CB_OPEN))
593     {
594         WARN("Clipboard not opened by calling task.\n");
595         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
596         return 0;
597     }
598
599     if (USER_Driver.pEnumClipboardFormats)
600         wFmt = USER_Driver.pEnumClipboardFormats(wFormat);
601
602     return wFmt;
603 }
604
605
606 /**************************************************************************
607  *              IsClipboardFormatAvailable (USER32.@)
608  */
609 BOOL WINAPI IsClipboardFormatAvailable(UINT wFormat)
610 {
611     BOOL bret = FALSE;
612
613     if (USER_Driver.pIsClipboardFormatAvailable)
614         bret = USER_Driver.pIsClipboardFormatAvailable(wFormat);
615
616     TRACE("%04x, returning %d\n", wFormat, bret);
617     return bret;
618 }
619
620
621 /**************************************************************************
622  *              GetClipboardData (USER.142)
623  */
624 HANDLE16 WINAPI GetClipboardData16(UINT16 wFormat)
625 {
626     HANDLE16 hData = 0;
627     CLIPBOARDINFO cbinfo;
628
629     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
630         (~cbinfo.flags & CB_OPEN))
631     {
632         WARN("Clipboard not opened by calling task.\n");
633         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
634         return 0;
635     }
636
637     if (USER_Driver.pGetClipboardData)
638         USER_Driver.pGetClipboardData(wFormat, &hData, NULL);
639
640     return hData;
641 }
642
643
644 /**************************************************************************
645  *              GetClipboardData (USER32.@)
646  */
647 HANDLE WINAPI GetClipboardData(UINT wFormat)
648 {
649     HANDLE hData = 0;
650     CLIPBOARDINFO cbinfo;
651
652     TRACE("%04x\n", wFormat);
653
654     if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
655         (~cbinfo.flags & CB_OPEN))
656     {
657         WARN("Clipboard not opened by calling task.\n");
658         SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
659         return 0;
660     }
661
662     if (USER_Driver.pGetClipboardData)
663         USER_Driver.pGetClipboardData(wFormat, NULL, &hData);
664
665     TRACE("returning %p\n", hData);
666     return hData;
667 }
668
669
670 /**************************************************************************
671  *              GetPriorityClipboardFormat (USER32.@)
672  */
673 INT WINAPI GetPriorityClipboardFormat(UINT *list, INT nCount)
674 {
675     int i;
676
677     TRACE("()\n");
678
679     if(CountClipboardFormats() == 0)
680         return 0;
681
682     for (i = 0; i < nCount; i++)
683         if (IsClipboardFormatAvailable(list[i]))
684             return list[i];
685
686     return -1;
687 }
688
689
690 /**************************************************************************
691  *              GetClipboardSequenceNumber (USER32.@)
692  * Supported on Win2k/Win98
693  * MSDN: Windows clipboard code keeps a serial number for the clipboard
694  * for each window station.  The number is incremented whenever the
695  * contents change or are emptied.
696  * If you do not have WINSTA_ACCESSCLIPBOARD then the function returns 0
697  */
698 DWORD WINAPI GetClipboardSequenceNumber(VOID)
699 {
700     DWORD seqno = 0;
701
702     SERVER_START_REQ( set_clipboard_info )
703     {
704         req->flags = 0;
705         if (!wine_server_call_err( req )) seqno = reply->seqno;
706     }
707     SERVER_END_REQ;
708
709     TRACE("returning %lx\n", seqno);
710     return seqno;
711 }