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