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 FormatName)
217 {
218 return USER_Driver->pRegisterClipboardFormat(FormatName);
219 }
220
221
222 /**************************************************************************
223 * RegisterClipboardFormatA (USER32.@)
224 */
225 UINT WINAPI RegisterClipboardFormatA(LPCSTR formatName)
226 {
227 int len;
228 LPWSTR wFormat;
229 UINT ret;
230
231 len = MultiByteToWideChar(CP_ACP, 0, formatName, -1, NULL, 0);
232 wFormat = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
233 MultiByteToWideChar(CP_ACP, 0, formatName, -1, wFormat, len);
234
235 ret = RegisterClipboardFormatW(wFormat);
236 HeapFree(GetProcessHeap(), 0, wFormat);
237 return ret;
238 }
239
240
241 /**************************************************************************
242 * GetClipboardFormatNameW (USER32.@)
243 */
244 INT WINAPI GetClipboardFormatNameW(UINT wFormat, LPWSTR retStr, INT maxlen)
245 {
246 return USER_Driver->pGetClipboardFormatName(wFormat, retStr, maxlen);
247 }
248
249
250 /**************************************************************************
251 * GetClipboardFormatNameA (USER32.@)
252 */
253 INT WINAPI GetClipboardFormatNameA(UINT wFormat, LPSTR retStr, INT maxlen)
254 {
255 INT ret;
256 LPWSTR p = HeapAlloc( GetProcessHeap(), 0, maxlen*sizeof(WCHAR) );
257 if(p == NULL) return 0; /* FIXME: is this the correct failure value? */
258
259 ret = GetClipboardFormatNameW( wFormat, p, maxlen );
260
261 if (ret && maxlen > 0 && !WideCharToMultiByte( CP_ACP, 0, p, -1, retStr, maxlen, 0, 0))
262 retStr[maxlen-1] = 0;
263 HeapFree( GetProcessHeap(), 0, p );
264 return ret;
265 }
266
267
268 /**************************************************************************
269 * OpenClipboard (USER32.@)
270 *
271 * Note: Netscape uses NULL hWnd to open the clipboard.
272 */
273 BOOL WINAPI OpenClipboard( HWND hWnd )
274 {
275 BOOL bRet;
276
277 TRACE("(%p)...\n", hWnd);
278
279 bRet = CLIPBOARD_OpenClipboard(hWnd);
280
281 TRACE(" returning %i\n", bRet);
282
283 return bRet;
284 }
285
286
287 /**************************************************************************
288 * CloseClipboard (USER32.@)
289 */
290 BOOL WINAPI CloseClipboard(void)
291 {
292 BOOL bRet = FALSE;
293
294 TRACE("(%d)\n", bCBHasChanged);
295
296 if (CLIPBOARD_CloseClipboard())
297 {
298 if (bCBHasChanged)
299 {
300 HWND hWndViewer = GetClipboardViewer();
301
302 USER_Driver->pEndClipboardUpdate();
303
304 if (hWndViewer)
305 SendMessageW(hWndViewer, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
306
307 bCBHasChanged = FALSE;
308 }
309
310 bRet = TRUE;
311 }
312
313 return bRet;
314 }
315
316
317 /**************************************************************************
318 * EmptyClipboard (USER32.@)
319 * Empties and acquires ownership of the clipboard
320 */
321 BOOL WINAPI EmptyClipboard(void)
322 {
323 CLIPBOARDINFO cbinfo;
324
325 TRACE("()\n");
326
327 if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
328 ~cbinfo.flags & CB_OPEN)
329 {
330 WARN("Clipboard not opened by calling task!\n");
331 SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
332 return FALSE;
333 }
334
335 /* Destroy private objects */
336 if (cbinfo.hWndOwner)
337 SendMessageW(cbinfo.hWndOwner, WM_DESTROYCLIPBOARD, 0, 0);
338
339 /* Tell the driver to acquire the selection. The current owner
340 * will be signaled to delete it's own cache. */
341
342 /* Assign ownership of the clipboard to the current client. We do
343 * this before acquiring the selection so that when we do acquire the
344 * selection and the selection loser gets notified, it can check if
345 * it has lost the Wine clipboard ownership. If it did then it knows
346 * that a WM_DESTORYCLIPBOARD has already been sent. Otherwise it
347 * lost the selection to a X app and it should send the
348 * WM_DESTROYCLIPBOARD itself. */
349 CLIPBOARD_SetClipboardOwner(cbinfo.hWndOpen);
350
351 /* Acquire the selection. This will notify the previous owner
352 * to clear it's cache. */
353 USER_Driver->pAcquireClipboard(cbinfo.hWndOpen);
354
355 /* Empty the local cache */
356 USER_Driver->pEmptyClipboard(FALSE);
357
358 bCBHasChanged = TRUE;
359
360 return TRUE;
361 }
362
363
364 /**************************************************************************
365 * GetClipboardOwner (USER32.@)
366 * FIXME: Can't return the owner if the clipboard is owned by an external X-app
367 */
368 HWND WINAPI GetClipboardOwner(void)
369 {
370 HWND hWndOwner = 0;
371
372 SERVER_START_REQ( set_clipboard_info )
373 {
374 req->flags = 0;
375 if (!wine_server_call_err( req )) hWndOwner = wine_server_ptr_handle( reply->old_owner );
376 }
377 SERVER_END_REQ;
378
379 TRACE(" hWndOwner(%p)\n", hWndOwner);
380
381 return hWndOwner;
382 }
383
384
385 /**************************************************************************
386 * GetOpenClipboardWindow (USER32.@)
387 */
388 HWND WINAPI GetOpenClipboardWindow(void)
389 {
390 HWND hWndOpen = 0;
391
392 SERVER_START_REQ( set_clipboard_info )
393 {
394 req->flags = 0;
395 if (!wine_server_call_err( req )) hWndOpen = wine_server_ptr_handle( reply->old_clipboard );
396 }
397 SERVER_END_REQ;
398
399 TRACE(" hWndClipWindow(%p)\n", hWndOpen);
400
401 return hWndOpen;
402 }
403
404
405 /**************************************************************************
406 * SetClipboardViewer (USER32.@)
407 */
408 HWND WINAPI SetClipboardViewer( HWND hWnd )
409 {
410 HWND hwndPrev = CLIPBOARD_SetClipboardViewer(hWnd);
411
412 if (hWnd)
413 SendMessageW(hWnd, WM_DRAWCLIPBOARD, (WPARAM) GetClipboardOwner(), 0);
414 TRACE("(%p): returning %p\n", hWnd, hwndPrev);
415
416 return hwndPrev;
417 }
418
419
420 /**************************************************************************
421 * GetClipboardViewer (USER32.@)
422 */
423 HWND WINAPI GetClipboardViewer(void)
424 {
425 HWND hWndViewer = 0;
426
427 SERVER_START_REQ( set_clipboard_info )
428 {
429 req->flags = 0;
430 if (!wine_server_call_err( req )) hWndViewer = wine_server_ptr_handle( reply->old_viewer );
431 }
432 SERVER_END_REQ;
433
434 TRACE(" hWndViewer=%p\n", hWndViewer);
435
436 return hWndViewer;
437 }
438
439
440 /**************************************************************************
441 * ChangeClipboardChain (USER32.@)
442 */
443 BOOL WINAPI ChangeClipboardChain(HWND hWnd, HWND hWndNext)
444 {
445 BOOL bRet = TRUE;
446 HWND hWndViewer = GetClipboardViewer();
447
448 if (hWndViewer)
449 {
450 if (WIN_GetFullHandle(hWnd) == hWndViewer)
451 CLIPBOARD_SetClipboardViewer(WIN_GetFullHandle(hWndNext));
452 else
453 bRet = !SendMessageW(hWndViewer, WM_CHANGECBCHAIN, (WPARAM)hWnd, (LPARAM)hWndNext);
454 }
455 else
456 ERR("hWndViewer is lost\n");
457
458 return bRet;
459 }
460
461
462 /**************************************************************************
463 * SetClipboardData (USER32.@)
464 */
465 HANDLE WINAPI SetClipboardData(UINT wFormat, HANDLE hData)
466 {
467 CLIPBOARDINFO cbinfo;
468 HANDLE hResult = 0;
469
470 TRACE("(%04X, %p) !\n", wFormat, hData);
471
472 /* If it's not owned, data can only be set if the format isn't
473 available and its rendering is not delayed */
474 if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
475 (!(cbinfo.flags & CB_OWNER) && !hData))
476 {
477 WARN("Clipboard not owned by calling task. Operation failed.\n");
478 return 0;
479 }
480
481 if (USER_Driver->pSetClipboardData(wFormat, hData, cbinfo.flags & CB_OWNER))
482 {
483 hResult = hData;
484 bCBHasChanged = TRUE;
485 }
486
487 return hResult;
488 }
489
490
491 /**************************************************************************
492 * CountClipboardFormats (USER32.@)
493 */
494 INT WINAPI CountClipboardFormats(void)
495 {
496 INT count = USER_Driver->pCountClipboardFormats();
497 TRACE("returning %d\n", count);
498 return count;
499 }
500
501
502 /**************************************************************************
503 * EnumClipboardFormats (USER32.@)
504 */
505 UINT WINAPI EnumClipboardFormats(UINT wFormat)
506 {
507 CLIPBOARDINFO cbinfo;
508
509 TRACE("(%04X)\n", wFormat);
510
511 if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
512 (~cbinfo.flags & CB_OPEN))
513 {
514 WARN("Clipboard not opened by calling task.\n");
515 SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
516 return 0;
517 }
518 return USER_Driver->pEnumClipboardFormats(wFormat);
519 }
520
521
522 /**************************************************************************
523 * IsClipboardFormatAvailable (USER32.@)
524 */
525 BOOL WINAPI IsClipboardFormatAvailable(UINT wFormat)
526 {
527 BOOL bret = USER_Driver->pIsClipboardFormatAvailable(wFormat);
528 TRACE("%04x, returning %d\n", wFormat, bret);
529 return bret;
530 }
531
532
533 /**************************************************************************
534 * GetClipboardData (USER32.@)
535 */
536 HANDLE WINAPI GetClipboardData(UINT wFormat)
537 {
538 HANDLE hData = 0;
539 CLIPBOARDINFO cbinfo;
540
541 TRACE("%04x\n", wFormat);
542
543 if (!CLIPBOARD_GetClipboardInfo(&cbinfo) ||
544 (~cbinfo.flags & CB_OPEN))
545 {
546 WARN("Clipboard not opened by calling task.\n");
547 SetLastError(ERROR_CLIPBOARD_NOT_OPEN);
548 return 0;
549 }
550
551 hData = USER_Driver->pGetClipboardData( wFormat );
552
553 TRACE("returning %p\n", hData);
554 return hData;
555 }
556
557
558 /**************************************************************************
559 * GetPriorityClipboardFormat (USER32.@)
560 */
561 INT WINAPI GetPriorityClipboardFormat(UINT *list, INT nCount)
562 {
563 int i;
564
565 TRACE("()\n");
566
567 if(CountClipboardFormats() == 0)
568 return 0;
569
570 for (i = 0; i < nCount; i++)
571 if (IsClipboardFormatAvailable(list[i]))
572 return list[i];
573
574 return -1;
575 }
576
577
578 /**************************************************************************
579 * GetClipboardSequenceNumber (USER32.@)
580 * Supported on Win2k/Win98
581 * MSDN: Windows clipboard code keeps a serial number for the clipboard
582 * for each window station. The number is incremented whenever the
583 * contents change or are emptied.
584 * If you do not have WINSTA_ACCESSCLIPBOARD then the function returns 0
585 */
586 DWORD WINAPI GetClipboardSequenceNumber(VOID)
587 {
588 DWORD seqno = 0;
589
590 SERVER_START_REQ( set_clipboard_info )
591 {
592 req->flags = 0;
593 if (!wine_server_call_err( req )) seqno = reply->seqno;
594 }
595 SERVER_END_REQ;
596
597 TRACE("returning %x\n", seqno);
598 return seqno;
599 }
600
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.