?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
include: Make sure __int64 is correctly defined on PPC64.
[wine.git] / dlls / winex11.drv / clipboard.c
blob8a0617cfede43f562053bf9542344e792beb152b
1 /*
2 * X11 clipboard windows driver
3 *
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1996 Alex Korobka
6 * Copyright 1999 Noel Borthwick
7 * Copyright 2003 Ulrich Czekalla for CodeWeavers
8 * Copyright 2014 Damjan Jovanovic
9 * Copyright 2016 Alexandre Julliard
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 * NOTES:
26 * This file contains the X specific implementation for the windows
27 * Clipboard API.
28 *
29 * Wine's internal clipboard is exposed to external apps via the X
30 * selection mechanism.
31 * Currently the driver asserts ownership via two selection atoms:
32 * 1. PRIMARY(XA_PRIMARY)
33 * 2. CLIPBOARD
34 *
35 * In our implementation, the CLIPBOARD selection takes precedence over PRIMARY,
36 * i.e. if a CLIPBOARD selection is available, it is used instead of PRIMARY.
37 * When Wine takes ownership of the clipboard, it takes ownership of BOTH selections.
38 * While giving up selection ownership, if the CLIPBOARD selection is lost,
39 * it will lose both PRIMARY and CLIPBOARD and empty the clipboard.
40 * However if only PRIMARY is lost, it will continue to hold the CLIPBOARD selection
41 * (leaving the clipboard cache content unaffected).
42 *
43 * Every format exposed via a windows clipboard format is also exposed through
44 * a corresponding X selection target. A selection target atom is synthesized
45 * whenever a new Windows clipboard format is registered via RegisterClipboardFormat,
46 * or when a built-in format is used for the first time.
47 * Windows native format are exposed by prefixing the format name with "<WCF>"
48 * This allows us to uniquely identify windows native formats exposed by other
49 * running WINE apps.
50 *
51 * In order to allow external applications to query WINE for supported formats,
52 * we respond to the "TARGETS" selection target. (See EVENT_SelectionRequest
53 * for implementation) We use the same mechanism to query external clients for
54 * availability of a particular format, by caching the list of available targets
55 * by using the clipboard cache's "delayed render" mechanism. If a selection client
56 * does not support the "TARGETS" selection target, we actually attempt to retrieve
57 * the format requested as a fallback mechanism.
58 *
59 * Certain Windows native formats are automatically converted to X native formats
60 * and vice versa. If a native format is available in the selection, it takes
61 * precedence, in order to avoid unnecessary conversions.
62 *
63 * FIXME: global format list needs a critical section
64 */
65
66 #include "config.h"
67 #include "wine/port.h"
68
69 #include <string.h>
70 #include <stdarg.h>
71 #include <stdio.h>
72 #include <stdlib.h>
73 #ifdef HAVE_UNISTD_H
74 # include <unistd.h>
75 #endif
76 #include <fcntl.h>
77 #include <limits.h>
78 #include <time.h>
79 #include <assert.h>
80
81 #include "x11drv.h"
82
83 #ifdef HAVE_X11_EXTENSIONS_XFIXES_H
84 #include <X11/extensions/Xfixes.h>
85 #endif
86
87 #include "shlobj.h"
88 #include "shellapi.h"
89 #include "shlwapi.h"
90 #include "wine/list.h"
91 #include "wine/debug.h"
92 #include "wine/unicode.h"
93
94 WINE_DEFAULT_DEBUG_CHANNEL(clipboard);
95
96 /* Maximum wait time for selection notify */
97 #define SELECTION_RETRIES 500 /* wait for .5 seconds */
98 #define SELECTION_WAIT 1 /* ms */
99
100 #define SELECTION_UPDATE_DELAY 2000 /* delay between checks of the X11 selection */
101
102 typedef BOOL (*EXPORTFUNC)( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
103 typedef HANDLE (*IMPORTFUNC)( Atom type, const void *data, size_t size );
104
105 struct clipboard_format
106 {
107 struct list entry;
108 UINT id;
109 Atom atom;
110 IMPORTFUNC import;
111 EXPORTFUNC export;
112 };
113
114 static HANDLE import_data( Atom type, const void *data, size_t size );
115 static HANDLE import_enhmetafile( Atom type, const void *data, size_t size );
116 static HANDLE import_pixmap( Atom type, const void *data, size_t size );
117 static HANDLE import_image_bmp( Atom type, const void *data, size_t size );
118 static HANDLE import_string( Atom type, const void *data, size_t size );
119 static HANDLE import_utf8_string( Atom type, const void *data, size_t size );
120 static HANDLE import_compound_text( Atom type, const void *data, size_t size );
121 static HANDLE import_text( Atom type, const void *data, size_t size );
122 static HANDLE import_text_html( Atom type, const void *data, size_t size );
123 static HANDLE import_text_uri_list( Atom type, const void *data, size_t size );
124 static HANDLE import_targets( Atom type, const void *data, size_t size );
125
126 static BOOL export_data( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
127 static BOOL export_string( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
128 static BOOL export_utf8_string( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
129 static BOOL export_text( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
130 static BOOL export_compound_text( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
131 static BOOL export_pixmap( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
132 static BOOL export_image_bmp( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
133 static BOOL export_enhmetafile( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
134 static BOOL export_text_html( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
135 static BOOL export_hdrop( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
136 static BOOL export_targets( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
137 static BOOL export_multiple( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
138 static BOOL export_timestamp( Display *display, Window win, Atom prop, Atom target, HANDLE handle );
139
140 static BOOL read_property( Display *display, Window w, Atom prop,
141 Atom *type, unsigned char **data, unsigned long *datasize );
142
143 /* Clipboard formats */
144
145 static const WCHAR RichTextFormatW[] = {'R','i','c','h',' ','T','e','x','t',' ','F','o','r','m','a','t',0};
146 static const WCHAR GIFW[] = {'G','I','F',0};
147 static const WCHAR JFIFW[] = {'J','F','I','F',0};
148 static const WCHAR PNGW[] = {'P','N','G',0};
149 static const WCHAR HTMLFormatW[] = {'H','T','M','L',' ','F','o','r','m','a','t',0};
150
151 static const struct
152 {
153 const WCHAR *name;
154 UINT id;
155 UINT data;
156 IMPORTFUNC import;
157 EXPORTFUNC export;
158 } builtin_formats[] =
159 {
160 { 0, CF_UNICODETEXT, XATOM_UTF8_STRING, import_utf8_string, export_utf8_string },
161 { 0, CF_UNICODETEXT, XATOM_COMPOUND_TEXT, import_compound_text, export_compound_text },
162 { 0, CF_UNICODETEXT, XA_STRING, import_string, export_string },
163 { 0, CF_UNICODETEXT, XATOM_text_plain, import_string, export_string },
164 { 0, CF_UNICODETEXT, XATOM_TEXT, import_text, export_text },
165 { 0, CF_SYLK, XATOM_WCF_SYLK, import_data, export_data },
166 { 0, CF_DIF, XATOM_WCF_DIF, import_data, export_data },
167 { 0, CF_TIFF, XATOM_WCF_TIFF, import_data, export_data },
168 { 0, CF_DIB, XA_PIXMAP, import_pixmap, export_pixmap },
169 { 0, CF_PENDATA, XATOM_WCF_PENDATA, import_data, export_data },
170 { 0, CF_RIFF, XATOM_WCF_RIFF, import_data, export_data },
171 { 0, CF_WAVE, XATOM_WCF_WAVE, import_data, export_data },
172 { 0, CF_ENHMETAFILE, XATOM_WCF_ENHMETAFILE, import_enhmetafile, export_enhmetafile },
173 { 0, CF_HDROP, XATOM_text_uri_list, import_text_uri_list, export_hdrop },
174 { 0, CF_DIB, XATOM_image_bmp, import_image_bmp, export_image_bmp },
175 { RichTextFormatW, 0, XATOM_text_rtf, import_data, export_data },
176 { RichTextFormatW, 0, XATOM_text_richtext, import_data, export_data },
177 { GIFW, 0, XATOM_image_gif, import_data, export_data },
178 { JFIFW, 0, XATOM_image_jpeg, import_data, export_data },
179 { PNGW, 0, XATOM_image_png, import_data, export_data },
180 { HTMLFormatW, 0, XATOM_HTML_Format, import_data, export_data },
181 { HTMLFormatW, 0, XATOM_text_html, import_text_html, export_text_html },
182 { 0, 0, XATOM_TARGETS, import_targets, export_targets },
183 { 0, 0, XATOM_MULTIPLE, NULL, export_multiple },
184 { 0, 0, XATOM_TIMESTAMP, NULL, export_timestamp },
185 };
186
187 static struct list format_list = LIST_INIT( format_list );
188
189 #define GET_ATOM(prop) (((prop) < FIRST_XATOM) ? (Atom)(prop) : X11DRV_Atoms[(prop) - FIRST_XATOM])
190
191 static DWORD clipboard_thread_id;
192 static HWND clipboard_hwnd;
193 static BOOL is_clipboard_owner;
194 static Window selection_window;
195 static Window import_window;
196 static Atom current_selection;
197 static UINT rendered_formats;
198 static ULONG64 last_clipboard_update;
199 static struct clipboard_format **current_x11_formats;
200 static unsigned int nb_current_x11_formats;
201 static BOOL use_xfixes;
202
203 Display *clipboard_display = NULL;
204
205 static const char *debugstr_format( UINT id )
206 {
207 WCHAR buffer[256];
208
209 if (GetClipboardFormatNameW( id, buffer, 256 ))
210 return wine_dbg_sprintf( "%04x %s", id, debugstr_w(buffer) );
211
212 switch (id)
213 {
214 case 0: return "(none)";
215 #define BUILTIN(id) case id: return #id;
216 BUILTIN(CF_TEXT)
217 BUILTIN(CF_BITMAP)
218 BUILTIN(CF_METAFILEPICT)
219 BUILTIN(CF_SYLK)
220 BUILTIN(CF_DIF)
221 BUILTIN(CF_TIFF)
222 BUILTIN(CF_OEMTEXT)
223 BUILTIN(CF_DIB)
224 BUILTIN(CF_PALETTE)
225 BUILTIN(CF_PENDATA)
226 BUILTIN(CF_RIFF)
227 BUILTIN(CF_WAVE)
228 BUILTIN(CF_UNICODETEXT)
229 BUILTIN(CF_ENHMETAFILE)
230 BUILTIN(CF_HDROP)
231 BUILTIN(CF_LOCALE)
232 BUILTIN(CF_DIBV5)
233 BUILTIN(CF_OWNERDISPLAY)
234 BUILTIN(CF_DSPTEXT)
235 BUILTIN(CF_DSPBITMAP)
236 BUILTIN(CF_DSPMETAFILEPICT)
237 BUILTIN(CF_DSPENHMETAFILE)
238 #undef BUILTIN
239 default: return wine_dbg_sprintf( "%04x", id );
240 }
241 }
242
243 static const char *debugstr_xatom( Atom atom )
244 {
245 const char *ret;
246 char *name;
247
248 if (!atom) return "(None)";
249 name = XGetAtomName( thread_display(), atom );
250 ret = debugstr_a( name );
251 XFree( name );
252 return ret;
253 }
254
255
256 static int is_atom_error( Display *display, XErrorEvent *event, void *arg )
257 {
258 return (event->error_code == BadAtom);
259 }
260
261
262 /**************************************************************************
263 * find_win32_format
264 */
265 static struct clipboard_format *find_win32_format( UINT id )
266 {
267 struct clipboard_format *format;
268
269 LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
270 if (format->id == id) return format;
271 return NULL;
272 }
273
274
275 /**************************************************************************
276 * find_x11_format
277 */
278 static struct clipboard_format *find_x11_format( Atom atom )
279 {
280 struct clipboard_format *format;
281
282 LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
283 if (format->atom == atom) return format;
284 return NULL;
285 }
286
287
288 /**************************************************************************
289 * register_builtin_formats
290 */
291 static void register_builtin_formats(void)
292 {
293 struct clipboard_format *formats;
294 unsigned int i;
295
296 if (!(formats = HeapAlloc( GetProcessHeap(), 0, ARRAY_SIZE(builtin_formats) * sizeof(*formats)))) return;
297
298 for (i = 0; i < ARRAY_SIZE(builtin_formats); i++)
299 {
300 if (builtin_formats[i].name)
301 formats[i].id = RegisterClipboardFormatW( builtin_formats[i].name );
302 else
303 formats[i].id = builtin_formats[i].id;
304
305 formats[i].atom = GET_ATOM(builtin_formats[i].data);
306 formats[i].import = builtin_formats[i].import;
307 formats[i].export = builtin_formats[i].export;
308 list_add_tail( &format_list, &formats[i].entry );
309 }
310 }
311
312
313 /**************************************************************************
314 * register_formats
315 */
316 static void register_formats( const UINT *ids, const Atom *atoms, unsigned int count )
317 {
318 struct clipboard_format *formats;
319 unsigned int i;
320
321 if (!(formats = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*formats)))) return;
322
323 for (i = 0; i < count; i++)
324 {
325 formats[i].id = ids[i];
326 formats[i].atom = atoms[i];
327 formats[i].import = import_data;
328 formats[i].export = export_data;
329 list_add_tail( &format_list, &formats[i].entry );
330 TRACE( "registered %s atom %s\n", debugstr_format( ids[i] ), debugstr_xatom( atoms[i] ));
331 }
332 }
333
334
335 /**************************************************************************
336 * register_win32_formats
337 *
338 * Register Win32 clipboard formats the first time we encounter them.
339 */
340 static void register_win32_formats( const UINT *ids, UINT size )
341 {
342 unsigned int count, len;
343 UINT new_ids[256];
344 char *names[256];
345 Atom atoms[256];
346 WCHAR buffer[256];
347
348 if (list_empty( &format_list)) register_builtin_formats();
349
350 while (size)
351 {
352 for (count = 0; count < 256 && size; ids++, size--)
353 {
354 if (find_win32_format( *ids )) continue; /* it already exists */
355 if (!GetClipboardFormatNameW( *ids, buffer, 256 )) continue; /* not a named format */
356 if (!(len = WideCharToMultiByte( CP_UNIXCP, 0, buffer, -1, NULL, 0, NULL, NULL ))) continue;
357 if (!(names[count] = HeapAlloc( GetProcessHeap(), 0, len ))) continue;
358 WideCharToMultiByte( CP_UNIXCP, 0, buffer, -1, names[count], len, NULL, NULL );
359 new_ids[count++] = *ids;
360 }
361 if (!count) return;
362
363 XInternAtoms( thread_display(), names, count, False, atoms );
364 register_formats( new_ids, atoms, count );
365 while (count) HeapFree( GetProcessHeap(), 0, names[--count] );
366 }
367 }
368
369
370 /**************************************************************************
371 * register_x11_formats
372 *
373 * Register X11 atom formats the first time we encounter them.
374 */
375 static void register_x11_formats( const Atom *atoms, UINT size )
376 {
377 Display *display = thread_display();
378 unsigned int i, pos, count;
379 char *names[256];
380 UINT ids[256];
381 Atom new_atoms[256];
382 WCHAR buffer[256];
383
384 if (list_empty( &format_list)) register_builtin_formats();
385
386 while (size)
387 {
388 for (count = 0; count < 256 && size; atoms++, size--)
389 if (!find_x11_format( *atoms )) new_atoms[count++] = *atoms;
390
391 if (!count) return;
392
393 X11DRV_expect_error( display, is_atom_error, NULL );
394 if (!XGetAtomNames( display, new_atoms, count, names )) count = 0;
395 if (X11DRV_check_error())
396 {
397 WARN( "got some bad atoms, ignoring\n" );
398 count = 0;
399 }
400
401 for (i = pos = 0; i < count; i++)
402 {
403 if (MultiByteToWideChar( CP_UNIXCP, 0, names[i], -1, buffer, 256 ) &&
404 (ids[pos] = RegisterClipboardFormatW( buffer )))
405 new_atoms[pos++] = new_atoms[i];
406 XFree( names[i] );
407 }
408 register_formats( ids, new_atoms, pos );
409 }
410 }
411
412
413 /**************************************************************************
414 * put_property
415 *
416 * Put data as a property on the specified window.
417 */
418 static void put_property( Display *display, Window win, Atom prop, Atom type, int format,
419 const void *ptr, size_t size )
420 {
421 const unsigned char *data = ptr;
422 int mode = PropModeReplace;
423 size_t width = (format == 32) ? sizeof(long) : format / 8;
424 size_t max_size = XExtendedMaxRequestSize( display ) * 4;
425
426 if (!max_size) max_size = XMaxRequestSize( display ) * 4;
427 max_size -= 64; /* request overhead */
428
429 do
430 {
431 size_t count = min( size, max_size / width );
432 XChangeProperty( display, win, prop, type, format, mode, data, count );
433 mode = PropModeAppend;
434 size -= count;
435 data += count * width;
436 } while (size > 0);
437 }
438
439
440 /**************************************************************************
441 * convert_selection
442 */
443 static BOOL convert_selection( Display *display, Window win, Atom selection,
444 struct clipboard_format *format, Atom *type,
445 unsigned char **data, unsigned long *size )
446 {
447 int i;
448 XEvent event;
449
450 TRACE( "import %s from %s win %lx to format %s\n",
451 debugstr_xatom( format->atom ), debugstr_xatom( selection ),
452 win, debugstr_format( format->id ) );
453
454 XConvertSelection( display, selection, format->atom, x11drv_atom(SELECTION_DATA), win, CurrentTime );
455
456 for (i = 0; i < SELECTION_RETRIES; i++)
457 {
458 Bool res = XCheckTypedWindowEvent( display, win, SelectionNotify, &event );
459 if (res && event.xselection.selection == selection && event.xselection.target == format->atom)
460 return read_property( display, win, event.xselection.property, type, data, size );
461 Sleep( SELECTION_WAIT );
462 }
463 ERR( "Timed out waiting for SelectionNotify event\n" );
464 return FALSE;
465 }
466
467
468 /***********************************************************************
469 * bitmap_info_size
470 *
471 * Return the size of the bitmap info structure including color table.
472 */
473 static int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
474 {
475 unsigned int colors, size, masks = 0;
476
477 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
478 {
479 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
480 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
481 return sizeof(BITMAPCOREHEADER) + colors *
482 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
483 }
484 else /* assume BITMAPINFOHEADER */
485 {
486 colors = info->bmiHeader.biClrUsed;
487 if (!colors && (info->bmiHeader.biBitCount <= 8))
488 colors = 1 << info->bmiHeader.biBitCount;
489 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
490 size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
491 return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
492 }
493 }
494
495
496 /***********************************************************************
497 * create_dib_from_bitmap
498 *
499 * Allocates a packed DIB and copies the bitmap data into it.
500 */
501 static HGLOBAL create_dib_from_bitmap(HBITMAP hBmp)
502 {
503 BITMAP bmp;
504 HDC hdc;
505 HGLOBAL hPackedDIB;
506 LPBYTE pPackedDIB;
507 LPBITMAPINFOHEADER pbmiHeader;
508 unsigned int cDataSize, cPackedSize, OffsetBits;
509 int nLinesCopied;
510
511 if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
512
513 /*
514 * A packed DIB contains a BITMAPINFO structure followed immediately by
515 * an optional color palette and the pixel data.
516 */
517
518 /* Calculate the size of the packed DIB */
519 cDataSize = abs( bmp.bmHeight ) * (((bmp.bmWidth * bmp.bmBitsPixel + 31) / 8) & ~3);
520 cPackedSize = sizeof(BITMAPINFOHEADER)
521 + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
522 + cDataSize;
523 /* Get the offset to the bits */
524 OffsetBits = cPackedSize - cDataSize;
525
526 /* Allocate the packed DIB */
527 TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
528 hPackedDIB = GlobalAlloc( GMEM_FIXED, cPackedSize );
529 if ( !hPackedDIB )
530 {
531 WARN("Could not allocate packed DIB!\n");
532 return 0;
533 }
534
535 /* A packed DIB starts with a BITMAPINFOHEADER */
536 pPackedDIB = GlobalLock(hPackedDIB);
537 pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
538
539 /* Init the BITMAPINFOHEADER */
540 pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
541 pbmiHeader->biWidth = bmp.bmWidth;
542 pbmiHeader->biHeight = bmp.bmHeight;
543 pbmiHeader->biPlanes = 1;
544 pbmiHeader->biBitCount = bmp.bmBitsPixel;
545 pbmiHeader->biCompression = BI_RGB;
546 pbmiHeader->biSizeImage = 0;
547 pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
548 pbmiHeader->biClrUsed = 0;
549 pbmiHeader->biClrImportant = 0;
550
551 /* Retrieve the DIB bits from the bitmap and fill in the
552 * DIB color table if present */
553 hdc = GetDC( 0 );
554 nLinesCopied = GetDIBits(hdc, /* Handle to device context */
555 hBmp, /* Handle to bitmap */
556 0, /* First scan line to set in dest bitmap */
557 bmp.bmHeight, /* Number of scan lines to copy */
558 pPackedDIB + OffsetBits, /* [out] Address of array for bitmap bits */
559 (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
560 0); /* RGB or palette index */
561 GlobalUnlock(hPackedDIB);
562 ReleaseDC( 0, hdc );
563
564 /* Cleanup if GetDIBits failed */
565 if (nLinesCopied != bmp.bmHeight)
566 {
567 TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
568 GlobalFree(hPackedDIB);
569 hPackedDIB = 0;
570 }
571 return hPackedDIB;
572 }
573
574
575 /***********************************************************************
576 * uri_to_dos
577 *
578 * Converts a text/uri-list URI to DOS filename.
579 */
580 static WCHAR* uri_to_dos(char *encodedURI)
581 {
582 WCHAR *ret = NULL;
583 int i;
584 int j = 0;
585 char *uri = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlen(encodedURI) + 1);
586 if (uri == NULL)
587 return NULL;
588 for (i = 0; encodedURI[i]; ++i)
589 {
590 if (encodedURI[i] == '%')
591 {
592 if (encodedURI[i+1] && encodedURI[i+2])
593 {
594 char buffer[3];
595 int number;
596 buffer[0] = encodedURI[i+1];
597 buffer[1] = encodedURI[i+2];
598 buffer[2] = '\0';
599 sscanf(buffer, "%x", &number);
600 uri[j++] = number;
601 i += 2;
602 }
603 else
604 {
605 WARN("invalid URI encoding in %s\n", debugstr_a(encodedURI));
606 HeapFree(GetProcessHeap(), 0, uri);
607 return NULL;
608 }
609 }
610 else
611 uri[j++] = encodedURI[i];
612 }
613
614 /* Read http://www.freedesktop.org/wiki/Draganddropwarts and cry... */
615 if (strncmp(uri, "file:/", 6) == 0)
616 {
617 if (uri[6] == '/')
618 {
619 if (uri[7] == '/')
620 {
621 /* file:///path/to/file (nautilus, thunar) */
622 ret = wine_get_dos_file_name(&uri[7]);
623 }
624 else if (uri[7])
625 {
626 /* file://hostname/path/to/file (X file drag spec) */
627 char hostname[256];
628 char *path = strchr(&uri[7], '/');
629 if (path)
630 {
631 *path = '\0';
632 if (strcmp(&uri[7], "localhost") == 0)
633 {
634 *path = '/';
635 ret = wine_get_dos_file_name(path);
636 }
637 else if (gethostname(hostname, sizeof(hostname)) == 0)
638 {
639 if (strcmp(hostname, &uri[7]) == 0)
640 {
641 *path = '/';
642 ret = wine_get_dos_file_name(path);
643 }
644 }
645 }
646 }
647 }
648 else if (uri[6])
649 {
650 /* file:/path/to/file (konqueror) */
651 ret = wine_get_dos_file_name(&uri[5]);
652 }
653 }
654 HeapFree(GetProcessHeap(), 0, uri);
655 return ret;
656 }
657
658
659 /**************************************************************************
660 * unicode_text_from_string
661 *
662 * Convert a string in the specified encoding to CF_UNICODETEXT format.
663 */
664 static HANDLE unicode_text_from_string( UINT codepage, const void *data, size_t size )
665 {
666 DWORD i, j, count;
667 WCHAR *strW;
668
669 count = MultiByteToWideChar( codepage, 0, data, size, NULL, 0);
670
671 if (!(strW = GlobalAlloc( GMEM_FIXED, (count * 2 + 1) * sizeof(WCHAR) ))) return 0;
672
673 MultiByteToWideChar( codepage, 0, data, size, strW + count, count );
674 for (i = j = 0; i < count; i++)
675 {
676 if (strW[i + count] == '\n' && (!i || strW[i + count - 1] != '\r')) strW[j++] = '\r';
677 strW[j++] = strW[i + count];
678 }
679 strW[j++] = 0;
680 GlobalReAlloc( strW, j * sizeof(WCHAR), GMEM_FIXED ); /* release unused space */
681 TRACE( "returning %s\n", debugstr_wn( strW, j - 1 ));
682 return strW;
683 }
684
685
686 /**************************************************************************
687 * import_string
688 *
689 * Import XA_STRING, converting the string to CF_UNICODETEXT.
690 */
691 static HANDLE import_string( Atom type, const void *data, size_t size )
692 {
693 return unicode_text_from_string( 28591, data, size );
694 }
695
696
697 /**************************************************************************
698 * import_utf8_string
699 *
700 * Import XA_UTF8_STRING, converting the string to CF_UNICODETEXT.
701 */
702 static HANDLE import_utf8_string( Atom type, const void *data, size_t size )
703 {
704 return unicode_text_from_string( CP_UTF8, data, size );
705 }
706
707
708 /**************************************************************************
709 * import_compound_text
710 *
711 * Import COMPOUND_TEXT to CF_UNICODETEXT.
712 */
713 static HANDLE import_compound_text( Atom type, const void *data, size_t size )
714 {
715 char** srcstr;
716 int count;
717 HANDLE ret;
718 XTextProperty txtprop;
719
720 txtprop.value = (BYTE *)data;
721 txtprop.nitems = size;
722 txtprop.encoding = x11drv_atom(COMPOUND_TEXT);
723 txtprop.format = 8;
724 if (XmbTextPropertyToTextList( thread_display(), &txtprop, &srcstr, &count ) != Success) return 0;
725 if (!count) return 0;
726
727 ret = unicode_text_from_string( CP_UNIXCP, srcstr[0], strlen(srcstr[0]) + 1 );
728 XFreeStringList(srcstr);
729 return ret;
730 }
731
732
733 /**************************************************************************
734 * import_text
735 *
736 * Import XA_TEXT, converting the string to CF_UNICODETEXT.
737 */
738 static HANDLE import_text( Atom type, const void *data, size_t size )
739 {
740 if (type == XA_STRING) return import_string( type, data, size );
741 if (type == x11drv_atom(UTF8_STRING)) return import_utf8_string( type, data, size );
742 if (type == x11drv_atom(COMPOUND_TEXT)) return import_compound_text( type, data, size );
743 FIXME( "unsupported TEXT type %s\n", debugstr_xatom( type ));
744 return 0;
745 }
746
747
748 /**************************************************************************
749 * import_pixmap
750 *
751 * Import XA_PIXMAP, converting the image to CF_DIB.
752 */
753 static HANDLE import_pixmap( Atom type, const void *data, size_t size )
754 {
755 const Pixmap *pPixmap = (const Pixmap *)data;
756 BYTE *ptr = NULL;
757 XVisualInfo vis = default_visual;
758 char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
759 BITMAPINFO *info = (BITMAPINFO *)buffer;
760 struct gdi_image_bits bits;
761 Window root;
762 int x,y; /* Unused */
763 unsigned border_width; /* Unused */
764 unsigned int depth, width, height;
765
766 /* Get the Pixmap dimensions and bit depth */
767 if (!XGetGeometry(gdi_display, *pPixmap, &root, &x, &y, &width, &height,
768 &border_width, &depth)) depth = 0;
769 if (!pixmap_formats[depth]) return 0;
770
771 TRACE( "pixmap properties: width=%d, height=%d, depth=%d\n", width, height, depth );
772
773 if (depth != vis.depth) switch (pixmap_formats[depth]->bits_per_pixel)
774 {
775 case 1:
776 case 4:
777 case 8:
778 break;
779 case 16: /* assume R5G5B5 */
780 vis.red_mask = 0x7c00;
781 vis.green_mask = 0x03e0;
782 vis.blue_mask = 0x001f;
783 break;
784 case 24: /* assume R8G8B8 */
785 case 32: /* assume A8R8G8B8 */
786 vis.red_mask = 0xff0000;
787 vis.green_mask = 0x00ff00;
788 vis.blue_mask = 0x0000ff;
789 break;
790 default:
791 return 0;
792 }
793
794 if (!get_pixmap_image( *pPixmap, width, height, &vis, info, &bits ))
795 {
796 DWORD info_size = bitmap_info_size( info, DIB_RGB_COLORS );
797
798 ptr = GlobalAlloc( GMEM_FIXED, info_size + info->bmiHeader.biSizeImage );
799 if (ptr)
800 {
801 memcpy( ptr, info, info_size );
802 memcpy( ptr + info_size, bits.ptr, info->bmiHeader.biSizeImage );
803 }
804 if (bits.free) bits.free( &bits );
805 }
806 return ptr;
807 }
808
809
810 /**************************************************************************
811 * import_image_bmp
812 *
813 * Import image/bmp, converting the image to CF_DIB.
814 */
815 static HANDLE import_image_bmp( Atom type, const void *data, size_t size )
816 {
817 HANDLE hClipData = 0;
818 const BITMAPFILEHEADER *bfh = data;
819
820 if (size >= sizeof(BITMAPFILEHEADER)+sizeof(BITMAPCOREHEADER) &&
821 bfh->bfType == 0x4d42 /* "BM" */)
822 {
823 const BITMAPINFO *bmi = (const BITMAPINFO *)(bfh + 1);
824 HBITMAP hbmp;
825 HDC hdc = GetDC(0);
826
827 if ((hbmp = CreateDIBitmap( hdc, &bmi->bmiHeader, CBM_INIT,
828 (const BYTE *)data + bfh->bfOffBits, bmi, DIB_RGB_COLORS )))
829 {
830 hClipData = create_dib_from_bitmap( hbmp );
831 DeleteObject(hbmp);
832 }
833 ReleaseDC(0, hdc);
834 }
835 return hClipData;
836 }
837
838
839 /**************************************************************************
840 * import_enhmetafile
841 */
842 static HANDLE import_enhmetafile( Atom type, const void *data, size_t size )
843 {
844 return SetEnhMetaFileBits( size, data );
845 }
846
847
848 /**************************************************************************
849 * import_text_html
850 */
851 static HANDLE import_text_html( Atom type, const void *data, size_t size )
852 {
853 static const char header[] =
854 "Version:0.9\n"
855 "StartHTML:0000000100\n"
856 "EndHTML:%010lu\n"
857 "StartFragment:%010lu\n"
858 "EndFragment:%010lu\n"
859 "<!--StartFragment-->";
860 static const char trailer[] = "\n<!--EndFragment-->";
861 char *text = NULL;
862 HANDLE ret;
863 SIZE_T len, total;
864
865 /* Firefox uses UTF-16LE with byte order mark. Convert to UTF-8 without the BOM. */
866 if (size >= sizeof(WCHAR) && ((const WCHAR *)data)[0] == 0xfeff)
867 {
868 len = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data + 1, size / sizeof(WCHAR) - 1,
869 NULL, 0, NULL, NULL );
870 if (!(text = HeapAlloc( GetProcessHeap(), 0, len ))) return 0;
871 WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data + 1, size / sizeof(WCHAR) - 1,
872 text, len, NULL, NULL );
873 size = len;
874 data = text;
875 }
876
877 len = strlen( header ) + 12; /* 3 * 4 extra chars for %010lu */
878 total = len + size + sizeof(trailer);
879 if ((ret = GlobalAlloc( GMEM_FIXED, total )))
880 {
881 char *p = ret;
882 p += sprintf( p, header, total - 1, len, len + size + 1 /* include the final \n in the data */ );
883 memcpy( p, data, size );
884 strcpy( p + size, trailer );
885 TRACE( "returning %s\n", debugstr_a( ret ));
886 }
887 HeapFree( GetProcessHeap(), 0, text );
888 return ret;
889 }
890
891
892 /**************************************************************************
893 * import_text_uri_list
894 *
895 * Import text/uri-list.
896 */
897 static HANDLE import_text_uri_list( Atom type, const void *data, size_t size )
898 {
899 const char *uriList = data;
900 char *uri;
901 WCHAR *path;
902 WCHAR *out = NULL;
903 int total = 0;
904 int capacity = 4096;
905 int start = 0;
906 int end = 0;
907 DROPFILES *dropFiles = NULL;
908
909 if (!(out = HeapAlloc(GetProcessHeap(), 0, capacity * sizeof(WCHAR)))) return 0;
910
911 while (end < size)
912 {
913 while (end < size && uriList[end] != '\r')
914 ++end;
915 if (end < (size - 1) && uriList[end+1] != '\n')
916 {
917 WARN("URI list line doesn't end in \\r\\n\n");
918 break;
919 }
920
921 uri = HeapAlloc(GetProcessHeap(), 0, end - start + 1);
922 if (uri == NULL)
923 break;
924 lstrcpynA(uri, &uriList[start], end - start + 1);
925 path = uri_to_dos(uri);
926 TRACE("converted URI %s to DOS path %s\n", debugstr_a(uri), debugstr_w(path));
927 HeapFree(GetProcessHeap(), 0, uri);
928
929 if (path)
930 {
931 int pathSize = strlenW(path) + 1;
932 if (pathSize > capacity - total)
933 {
934 capacity = 2*capacity + pathSize;
935 out = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, out, (capacity + 1)*sizeof(WCHAR));
936 if (out == NULL)
937 goto done;
938 }
939 memcpy(&out[total], path, pathSize * sizeof(WCHAR));
940 total += pathSize;
941 done:
942 HeapFree(GetProcessHeap(), 0, path);
943 if (out == NULL)
944 break;
945 }
946
947 start = end + 2;
948 end = start;
949 }
950 if (out && end >= size)
951 {
952 if ((dropFiles = GlobalAlloc( GMEM_FIXED, sizeof(DROPFILES) + (total + 1) * sizeof(WCHAR) )))
953 {
954 dropFiles->pFiles = sizeof(DROPFILES);
955 dropFiles->pt.x = 0;
956 dropFiles->pt.y = 0;
957 dropFiles->fNC = 0;
958 dropFiles->fWide = TRUE;
959 out[total] = '\0';
960 memcpy( (char*)dropFiles + dropFiles->pFiles, out, (total + 1) * sizeof(WCHAR) );
961 }
962 }
963 HeapFree(GetProcessHeap(), 0, out);
964 return dropFiles;
965 }
966
967
968 /**************************************************************************
969 * import_targets
970 *
971 * Import TARGETS and mark the corresponding clipboard formats as available.
972 */
973 static HANDLE import_targets( Atom type, const void *data, size_t size )
974 {
975 UINT i, pos, count = size / sizeof(Atom);
976 const Atom *properties = data;
977 struct clipboard_format *format, **formats;
978
979 if (type != XA_ATOM && type != x11drv_atom(TARGETS)) return 0;
980
981 register_x11_formats( properties, count );
982
983 /* the builtin formats contain duplicates, so allocate some extra space */
984 if (!(formats = HeapAlloc( GetProcessHeap(), 0, (count + ARRAY_SIZE(builtin_formats)) * sizeof(*formats ))))
985 return 0;
986
987 pos = 0;
988 LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
989 {
990 for (i = 0; i < count; i++) if (properties[i] == format->atom) break;
991 if (i == count) continue;
992 if (format->import && format->id)
993 {
994 TRACE( "property %s -> format %s\n",
995 debugstr_xatom( properties[i] ), debugstr_format( format->id ));
996 SetClipboardData( format->id, 0 );
997 formats[pos++] = format;
998 }
999 else TRACE( "property %s (ignoring)\n", debugstr_xatom( properties[i] ));
1000 }
1001
1002 HeapFree( GetProcessHeap(), 0, current_x11_formats );
1003 current_x11_formats = formats;
1004 nb_current_x11_formats = pos;
1005 return (HANDLE)1;
1006 }
1007
1008
1009 /**************************************************************************
1010 * import_data
1011 *
1012 * Generic import clipboard data routine.
1013 */
1014 static HANDLE import_data( Atom type, const void *data, size_t size )
1015 {
1016 void *ret = GlobalAlloc( GMEM_FIXED, size );
1017
1018 if (ret) memcpy( ret, data, size );
1019 return ret;
1020 }
1021
1022
1023 /**************************************************************************
1024 * import_selection
1025 *
1026 * Import the specified format from the selection and return a global handle to the data.
1027 */
1028 static HANDLE import_selection( Display *display, Window win, Atom selection,
1029 struct clipboard_format *format )
1030 {
1031 unsigned char *data;
1032 unsigned long size;
1033 Atom type;
1034 HANDLE ret;
1035
1036 if (!format->import) return 0;
1037
1038 if (!convert_selection( display, win, selection, format, &type, &data, &size ))
1039 {
1040 TRACE( "failed to convert selection\n" );
1041 return 0;
1042 }
1043 ret = format->import( type, data, size );
1044 HeapFree( GetProcessHeap(), 0, data );
1045 return ret;
1046 }
1047
1048
1049 /**************************************************************************
1050 * X11DRV_CLIPBOARD_ImportSelection
1051 *
1052 * Import the X selection into the clipboard format registered for the given X target.
1053 */
1054 void X11DRV_CLIPBOARD_ImportSelection( Display *display, Window win, Atom selection,
1055 Atom *targets, UINT count,
1056 void (*callback)( Atom, UINT, HANDLE ))
1057 {
1058 UINT i;
1059 HANDLE handle;
1060 struct clipboard_format *format;
1061
1062 register_x11_formats( targets, count );
1063
1064 for (i = 0; i < count; i++)
1065 {
1066 if (!(format = find_x11_format( targets[i] ))) continue;
1067 if (!format->id) continue;
1068 if (!(handle = import_selection( display, win, selection, format ))) continue;
1069 callback( targets[i], format->id, handle );
1070 }
1071 }
1072
1073
1074 /**************************************************************************
1075 * render_format
1076 */
1077 static HANDLE render_format( UINT id )
1078 {
1079 Display *display = thread_display();
1080 unsigned int i;
1081 HANDLE handle = 0;
1082
1083 if (!current_selection) return 0;
1084
1085 for (i = 0; i < nb_current_x11_formats; i++)
1086 {
1087 if (current_x11_formats[i]->id != id) continue;
1088 if (!(handle = import_selection( display, import_window,
1089 current_selection, current_x11_formats[i] ))) continue;
1090 SetClipboardData( id, handle );
1091 break;
1092 }
1093 return handle;
1094 }
1095
1096
1097 /**************************************************************************
1098 * export_data
1099 *
1100 * Generic export clipboard data routine.
1101 */
1102 static BOOL export_data( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1103 {
1104 void *ptr = GlobalLock( handle );
1105
1106 if (!ptr) return FALSE;
1107 put_property( display, win, prop, target, 8, ptr, GlobalSize( handle ));
1108 GlobalUnlock( handle );
1109 return TRUE;
1110 }
1111
1112
1113 /**************************************************************************
1114 * string_from_unicode_text
1115 *
1116 * Convert CF_UNICODETEXT data to a string in the specified codepage.
1117 */
1118 static char *string_from_unicode_text( UINT codepage, HANDLE handle, UINT *size )
1119 {
1120 UINT i, j;
1121 char *str;
1122 WCHAR *strW = GlobalLock( handle );
1123 UINT lenW = GlobalSize( handle ) / sizeof(WCHAR);
1124 DWORD len = WideCharToMultiByte( codepage, 0, strW, lenW, NULL, 0, NULL, NULL );
1125
1126 if ((str = HeapAlloc( GetProcessHeap(), 0, len )))
1127 {
1128 WideCharToMultiByte( codepage, 0, strW, lenW, str, len, NULL, NULL);
1129 GlobalUnlock( handle );
1130
1131 /* remove carriage returns */
1132 for (i = j = 0; i < len; i++)
1133 {
1134 if (str[i] == '\r' && (i == len - 1 || str[i + 1] == '\n')) continue;
1135 str[j++] = str[i];
1136 }
1137 while (j && !str[j - 1]) j--; /* remove trailing nulls */
1138 *size = j;
1139 TRACE( "returning %s\n", debugstr_an( str, j ));
1140 }
1141 GlobalUnlock( handle );
1142 return str;
1143 }
1144
1145
1146 /**************************************************************************
1147 * export_string
1148 *
1149 * Export CF_UNICODETEXT converting the string to XA_STRING.
1150 */
1151 static BOOL export_string( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1152 {
1153 UINT size;
1154 char *text = string_from_unicode_text( 28591, handle, &size );
1155
1156 if (!text) return FALSE;
1157 put_property( display, win, prop, target, 8, text, size );
1158 HeapFree( GetProcessHeap(), 0, text );
1159 GlobalUnlock( handle );
1160 return TRUE;
1161 }
1162
1163
1164 /**************************************************************************
1165 * export_utf8_string
1166 *
1167 * Export CF_UNICODE converting the string to UTF8.
1168 */
1169 static BOOL export_utf8_string( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1170 {
1171 UINT size;
1172 char *text = string_from_unicode_text( CP_UTF8, handle, &size );
1173
1174 if (!text) return FALSE;
1175 put_property( display, win, prop, target, 8, text, size );
1176 HeapFree( GetProcessHeap(), 0, text );
1177 GlobalUnlock( handle );
1178 return TRUE;
1179 }
1180
1181
1182 /**************************************************************************
1183 * export_text
1184 *
1185 * Export CF_UNICODE to the polymorphic TEXT type, using UTF8.
1186 */
1187 static BOOL export_text( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1188 {
1189 return export_utf8_string( display, win, prop, x11drv_atom(UTF8_STRING), handle );
1190 }
1191
1192
1193 /**************************************************************************
1194 * export_compound_text
1195 *
1196 * Export CF_UNICODE to COMPOUND_TEXT
1197 */
1198 static BOOL export_compound_text( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1199 {
1200 XTextProperty textprop;
1201 XICCEncodingStyle style;
1202 UINT size;
1203 char *text = string_from_unicode_text( CP_UNIXCP, handle, &size );
1204
1205 if (!text) return FALSE;
1206 if (target == x11drv_atom(COMPOUND_TEXT))
1207 style = XCompoundTextStyle;
1208 else
1209 style = XStdICCTextStyle;
1210
1211 /* Update the X property */
1212 if (XmbTextListToTextProperty( display, &text, 1, style, &textprop ) == Success)
1213 {
1214 XSetTextProperty( display, win, &textprop, prop );
1215 XFree( textprop.value );
1216 }
1217
1218 HeapFree( GetProcessHeap(), 0, text );
1219 return TRUE;
1220 }
1221
1222
1223 /**************************************************************************
1224 * export_pixmap
1225 *
1226 * Export CF_DIB to XA_PIXMAP.
1227 */
1228 static BOOL export_pixmap( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1229 {
1230 Pixmap pixmap;
1231 BITMAPINFO *pbmi;
1232 struct gdi_image_bits bits;
1233
1234 pbmi = GlobalLock( handle );
1235 bits.ptr = (LPBYTE)pbmi + bitmap_info_size( pbmi, DIB_RGB_COLORS );
1236 bits.free = NULL;
1237 bits.is_copy = FALSE;
1238 pixmap = create_pixmap_from_image( 0, &default_visual, pbmi, &bits, DIB_RGB_COLORS );
1239 GlobalUnlock( handle );
1240
1241 put_property( display, win, prop, target, 32, &pixmap, 1 );
1242 /* FIXME: free the pixmap when the property is deleted */
1243 return TRUE;
1244 }
1245
1246
1247 /**************************************************************************
1248 * export_image_bmp
1249 *
1250 * Export CF_DIB to image/bmp.
1251 */
1252 static BOOL export_image_bmp( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1253 {
1254 LPBYTE dibdata = GlobalLock( handle );
1255 UINT bmpsize;
1256 BITMAPFILEHEADER *bfh;
1257
1258 bmpsize = sizeof(BITMAPFILEHEADER) + GlobalSize( handle );
1259 bfh = HeapAlloc( GetProcessHeap(), 0, bmpsize );
1260 if (bfh)
1261 {
1262 /* bitmap file header */
1263 bfh->bfType = 0x4d42; /* "BM" */
1264 bfh->bfSize = bmpsize;
1265 bfh->bfReserved1 = 0;
1266 bfh->bfReserved2 = 0;
1267 bfh->bfOffBits = sizeof(BITMAPFILEHEADER) + bitmap_info_size((BITMAPINFO*)dibdata, DIB_RGB_COLORS);
1268
1269 /* rest of bitmap is the same as the packed dib */
1270 memcpy(bfh+1, dibdata, bmpsize-sizeof(BITMAPFILEHEADER));
1271 }
1272 GlobalUnlock( handle );
1273 put_property( display, win, prop, target, 8, bfh, bmpsize );
1274 HeapFree( GetProcessHeap(), 0, bfh );
1275 return TRUE;
1276 }
1277
1278
1279 /**************************************************************************
1280 * export_enhmetafile
1281 *
1282 * Export EnhMetaFile.
1283 */
1284 static BOOL export_enhmetafile( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1285 {
1286 unsigned int size;
1287 void *ptr;
1288
1289 if (!(size = GetEnhMetaFileBits( handle, 0, NULL ))) return FALSE;
1290 if (!(ptr = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
1291
1292 GetEnhMetaFileBits( handle, size, ptr );
1293 put_property( display, win, prop, target, 8, ptr, size );
1294 HeapFree( GetProcessHeap(), 0, ptr );
1295 return TRUE;
1296 }
1297
1298
1299 /**************************************************************************
1300 * export_text_html
1301 *
1302 * Export HTML Format to text/html.
1303 *
1304 * FIXME: We should attempt to add an <a base> tag and convert windows paths.
1305 */
1306 static BOOL export_text_html( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1307 {
1308 const char *p, *data;
1309 UINT start = 0, end = 0;
1310 BOOL ret = TRUE;
1311
1312 if (!(data = GlobalLock( handle ))) return FALSE;
1313
1314 p = data;
1315 while (*p && *p != '<')
1316 {
1317 if (!strncmp( p, "StartFragment:", 14 )) start = atoi( p + 14 );
1318 else if (!strncmp( p, "EndFragment:", 12 )) end = atoi( p + 12 );
1319 if (!(p = strpbrk( p, "\r\n" ))) break;
1320 while (*p == '\r' || *p == '\n') p++;
1321 }
1322 if (start && start < end && end <= GlobalSize( handle ))
1323 put_property( display, win, prop, target, 8, data + start, end - start );
1324 else
1325 ret = FALSE;
1326
1327 GlobalUnlock( handle );
1328 return ret;
1329 }
1330
1331
1332 /**************************************************************************
1333 * export_hdrop
1334 *
1335 * Export CF_HDROP format to text/uri-list.
1336 */
1337 static BOOL export_hdrop( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1338 {
1339 UINT i;
1340 UINT numFiles;
1341 char *textUriList;
1342 UINT textUriListSize = 32;
1343 UINT next = 0;
1344
1345 textUriList = HeapAlloc( GetProcessHeap(), 0, textUriListSize );
1346 if (!textUriList) return FALSE;
1347 numFiles = DragQueryFileW( handle, 0xFFFFFFFF, NULL, 0 );
1348 for (i = 0; i < numFiles; i++)
1349 {
1350 UINT dosFilenameSize;
1351 WCHAR *dosFilename = NULL;
1352 char *unixFilename = NULL;
1353 UINT uriSize;
1354 UINT u;
1355
1356 dosFilenameSize = 1 + DragQueryFileW( handle, i, NULL, 0 );
1357 dosFilename = HeapAlloc(GetProcessHeap(), 0, dosFilenameSize*sizeof(WCHAR));
1358 if (dosFilename == NULL) goto failed;
1359 DragQueryFileW( handle, i, dosFilename, dosFilenameSize );
1360 unixFilename = wine_get_unix_file_name(dosFilename);
1361 HeapFree(GetProcessHeap(), 0, dosFilename);
1362 if (unixFilename == NULL) goto failed;
1363 uriSize = 8 + /* file:/// */
1364 3 * (lstrlenA(unixFilename) - 1) + /* "%xy" per char except first '/' */
1365 2; /* \r\n */
1366 if ((next + uriSize) > textUriListSize)
1367 {
1368 UINT biggerSize = max( 2 * textUriListSize, next + uriSize );
1369 void *bigger = HeapReAlloc( GetProcessHeap(), 0, textUriList, biggerSize );
1370 if (bigger)
1371 {
1372 textUriList = bigger;
1373 textUriListSize = biggerSize;
1374 }
1375 else
1376 {
1377 HeapFree(GetProcessHeap(), 0, unixFilename);
1378 goto failed;
1379 }
1380 }
1381 lstrcpyA(&textUriList[next], "file:///");
1382 next += 8;
1383 /* URL encode everything - unnecessary, but easier/lighter than linking in shlwapi, and can't hurt */
1384 for (u = 1; unixFilename[u]; u++)
1385 {
1386 static const char hex_table[] = "0123456789abcdef";
1387 textUriList[next++] = '%';
1388 textUriList[next++] = hex_table[unixFilename[u] >> 4];
1389 textUriList[next++] = hex_table[unixFilename[u] & 0xf];
1390 }
1391 textUriList[next++] = '\r';
1392 textUriList[next++] = '\n';
1393 HeapFree(GetProcessHeap(), 0, unixFilename);
1394 }
1395 put_property( display, win, prop, target, 8, textUriList, next );
1396 HeapFree( GetProcessHeap(), 0, textUriList );
1397 return TRUE;
1398
1399 failed:
1400 HeapFree( GetProcessHeap(), 0, textUriList );
1401 return FALSE;
1402 }
1403
1404
1405 /***********************************************************************
1406 * get_clipboard_formats
1407 *
1408 * Return a list of all formats currently available on the Win32 clipboard.
1409 * Helper for export_targets.
1410 */
1411 static UINT *get_clipboard_formats( UINT *size )
1412 {
1413 UINT *ids;
1414
1415 *size = 256;
1416 for (;;)
1417 {
1418 if (!(ids = HeapAlloc( GetProcessHeap(), 0, *size * sizeof(*ids) ))) return NULL;
1419 if (GetUpdatedClipboardFormats( ids, *size, size )) break;
1420 HeapFree( GetProcessHeap(), 0, ids );
1421 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return NULL;
1422 }
1423 register_win32_formats( ids, *size );
1424 return ids;
1425 }
1426
1427
1428 /***********************************************************************
1429 * is_format_available
1430 *
1431 * Check if a clipboard format is included in the list.
1432 * Helper for export_targets.
1433 */
1434 static BOOL is_format_available( UINT format, const UINT *ids, unsigned int count )
1435 {
1436 while (count--) if (*ids++ == format) return TRUE;
1437 return FALSE;
1438 }
1439
1440
1441 /***********************************************************************
1442 * export_targets
1443 *
1444 * Service a TARGETS selection request event
1445 */
1446 static BOOL export_targets( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1447 {
1448 struct clipboard_format *format;
1449 UINT pos, count, *formats;
1450 Atom *targets;
1451
1452 if (!(formats = get_clipboard_formats( &count ))) return FALSE;
1453
1454 /* the builtin formats contain duplicates, so allocate some extra space */
1455 if (!(targets = HeapAlloc( GetProcessHeap(), 0,
1456 (count + ARRAY_SIZE(builtin_formats)) * sizeof(*targets) )))
1457 {
1458 HeapFree( GetProcessHeap(), 0, formats );
1459 return FALSE;
1460 }
1461
1462 pos = 0;
1463 LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
1464 {
1465 if (!format->export) continue;
1466 /* formats with id==0 are always exported */
1467 if (format->id && !is_format_available( format->id, formats, count )) continue;
1468 TRACE( "%d: %s -> %s\n", pos, debugstr_format( format->id ), debugstr_xatom( format->atom ));
1469 targets[pos++] = format->atom;
1470 }
1471
1472 put_property( display, win, prop, XA_ATOM, 32, targets, pos );
1473 HeapFree( GetProcessHeap(), 0, targets );
1474 HeapFree( GetProcessHeap(), 0, formats );
1475 return TRUE;
1476 }
1477
1478
1479 /**************************************************************************
1480 * export_selection
1481 *
1482 * Export selection data, depending on the target type.
1483 */
1484 static BOOL export_selection( Display *display, Window win, Atom prop, Atom target )
1485 {
1486 struct clipboard_format *format;
1487 HANDLE handle = 0;
1488 BOOL open = FALSE, ret = FALSE;
1489
1490 LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
1491 {
1492 if (format->atom != target) continue;
1493 if (!format->export) continue;
1494 if (!format->id)
1495 {
1496 TRACE( "win %lx prop %s target %s\n", win, debugstr_xatom( prop ), debugstr_xatom( target ));
1497 ret = format->export( display, win, prop, target, 0 );
1498 break;
1499 }
1500 if (!open && !(open = OpenClipboard( clipboard_hwnd )))
1501 {
1502 ERR( "failed to open clipboard for %s\n", debugstr_xatom( target ));
1503 return FALSE;
1504 }
1505 if ((handle = GetClipboardData( format->id )))
1506 {
1507 TRACE( "win %lx prop %s target %s exporting %s %p\n",
1508 win, debugstr_xatom( prop ), debugstr_xatom( target ),
1509 debugstr_format( format->id ), handle );
1510
1511 ret = format->export( display, win, prop, target, handle );
1512 break;
1513 }
1514 /* keep looking for another Win32 format mapping to the same target */
1515 }
1516 if (open) CloseClipboard();
1517 return ret;
1518 }
1519
1520
1521 /***********************************************************************
1522 * export_multiple
1523 *
1524 * Service a MULTIPLE selection request event
1525 * prop contains a list of (target,property) atom pairs.
1526 * The first atom names a target and the second names a property.
1527 * The effect is as if we have received a sequence of SelectionRequest events
1528 * (one for each atom pair) except that:
1529 * 1. We reply with a SelectionNotify only when all the requested conversions
1530 * have been performed.
1531 * 2. If we fail to convert the target named by an atom in the MULTIPLE property,
1532 * we replace the atom in the property by None.
1533 */
1534 static BOOL export_multiple( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1535 {
1536 Atom atype;
1537 int aformat;
1538 Atom *list;
1539 unsigned long i, count, failed, remain;
1540
1541 /* Read the MULTIPLE property contents. This should contain a list of
1542 * (target,property) atom pairs.
1543 */
1544 if (XGetWindowProperty( display, win, prop, 0, 0x3FFF, False, AnyPropertyType, &atype, &aformat,
1545 &count, &remain, (unsigned char**)&list ))
1546 return FALSE;
1547
1548 TRACE( "type %s format %d count %ld remain %ld\n",
1549 debugstr_xatom( atype ), aformat, count, remain );
1550
1551 /*
1552 * Make sure we got what we expect.
1553 * NOTE: According to the X-ICCCM Version 2.0 documentation the property sent
1554 * in a MULTIPLE selection request should be of type ATOM_PAIR.
1555 * However some X apps(such as XPaint) are not compliant with this and return
1556 * a user defined atom in atype when XGetWindowProperty is called.
1557 * The data *is* an atom pair but is not denoted as such.
1558 */
1559 if (aformat == 32 /* atype == xAtomPair */ )
1560 {
1561 for (i = failed = 0; i < count; i += 2)
1562 {
1563 if (list[i+1] == None) continue;
1564 if (export_selection( display, win, list[i + 1], list[i] )) continue;
1565 failed++;
1566 list[i + 1] = None;
1567 }
1568 if (failed) put_property( display, win, prop, atype, 32, list, count );
1569 }
1570 XFree( list );
1571 return TRUE;
1572 }
1573
1574
1575 /***********************************************************************
1576 * export_timestamp
1577 *
1578 * Export the timestamp that was used to acquire the selection
1579 */
1580 static BOOL export_timestamp( Display *display, Window win, Atom prop, Atom target, HANDLE handle )
1581 {
1582 Time time = CurrentTime; /* FIXME */
1583 put_property( display, win, prop, XA_INTEGER, 32, &time, 1 );
1584 return TRUE;
1585 }
1586
1587
1588 /**************************************************************************
1589 * X11DRV_CLIPBOARD_GetProperty
1590 * Gets type, data and size.
1591 */
1592 static BOOL X11DRV_CLIPBOARD_GetProperty(Display *display, Window w, Atom prop,
1593 Atom *atype, unsigned char** data, unsigned long* datasize)
1594 {
1595 int aformat;
1596 unsigned long pos = 0, nitems, remain, count;
1597 unsigned char *val = NULL, *buffer;
1598
1599 for (;;)
1600 {
1601 if (XGetWindowProperty(display, w, prop, pos, INT_MAX / 4, False,
1602 AnyPropertyType, atype, &aformat, &nitems, &remain, &buffer))
1603 {
1604 WARN("Failed to read property\n");
1605 HeapFree( GetProcessHeap(), 0, val );
1606 return FALSE;
1607 }
1608
1609 count = get_property_size( aformat, nitems );
1610 if (!val) *data = HeapAlloc( GetProcessHeap(), 0, pos * sizeof(int) + count + 1 );
1611 else *data = HeapReAlloc( GetProcessHeap(), 0, val, pos * sizeof(int) + count + 1 );
1612
1613 if (!*data)
1614 {
1615 XFree( buffer );
1616 HeapFree( GetProcessHeap(), 0, val );
1617 return FALSE;
1618 }
1619 val = *data;
1620 memcpy( (int *)val + pos, buffer, count );
1621 XFree( buffer );
1622 if (!remain)
1623 {
1624 *datasize = pos * sizeof(int) + count;
1625 val[*datasize] = 0;
1626 break;
1627 }
1628 pos += count / sizeof(int);
1629 }
1630
1631 TRACE( "got property %s type %s format %u len %lu from window %lx\n",
1632 debugstr_xatom( prop ), debugstr_xatom( *atype ), aformat, *datasize, w );
1633
1634 /* Delete the property on the window now that we are done
1635 * This will send a PropertyNotify event to the selection owner. */
1636 XDeleteProperty(display, w, prop);
1637 return TRUE;
1638 }
1639
1640
1641 struct clipboard_data_packet {
1642 struct list entry;
1643 unsigned long size;
1644 unsigned char *data;
1645 };
1646
1647 /**************************************************************************
1648 * read_property
1649 *
1650 * Reads the contents of the X selection property.
1651 */
1652 static BOOL read_property( Display *display, Window w, Atom prop,
1653 Atom *type, unsigned char **data, unsigned long *datasize )
1654 {
1655 XEvent xe;
1656
1657 if (prop == None)
1658 return FALSE;
1659
1660 while (XCheckTypedWindowEvent(display, w, PropertyNotify, &xe))
1661 ;
1662
1663 if (!X11DRV_CLIPBOARD_GetProperty(display, w, prop, type, data, datasize))
1664 return FALSE;
1665
1666 if (*type == x11drv_atom(INCR))
1667 {
1668 unsigned char *buf;
1669 unsigned long bufsize = 0;
1670 struct list packets;
1671 struct clipboard_data_packet *packet, *packet2;
1672 BOOL res;
1673
1674 HeapFree(GetProcessHeap(), 0, *data);
1675 *data = NULL;
1676
1677 list_init(&packets);
1678
1679 for (;;)
1680 {
1681 int i;
1682 unsigned char *prop_data;
1683 unsigned long prop_size;
1684
1685 /* Wait until PropertyNotify is received */
1686 for (i = 0; i < SELECTION_RETRIES; i++)
1687 {
1688 Bool res;
1689
1690 res = XCheckTypedWindowEvent(display, w, PropertyNotify, &xe);
1691 if (res && xe.xproperty.atom == prop &&
1692 xe.xproperty.state == PropertyNewValue)
1693 break;
1694 Sleep(SELECTION_WAIT);
1695 }
1696
1697 if (i >= SELECTION_RETRIES ||
1698 !X11DRV_CLIPBOARD_GetProperty(display, w, prop, type, &prop_data, &prop_size))
1699 {
1700 res = FALSE;
1701 break;
1702 }
1703
1704 /* Retrieved entire data. */
1705 if (prop_size == 0)
1706 {
1707 HeapFree(GetProcessHeap(), 0, prop_data);
1708 res = TRUE;
1709 break;
1710 }
1711
1712 packet = HeapAlloc(GetProcessHeap(), 0, sizeof(*packet));
1713 if (!packet)
1714 {
1715 HeapFree(GetProcessHeap(), 0, prop_data);
1716 res = FALSE;
1717 break;
1718 }
1719
1720 packet->size = prop_size;
1721 packet->data = prop_data;
1722 list_add_tail(&packets, &packet->entry);
1723 bufsize += prop_size;
1724 }
1725
1726 if (res)
1727 {
1728 buf = HeapAlloc(GetProcessHeap(), 0, bufsize + 1);
1729 if (buf)
1730 {
1731 unsigned long bytes_copied = 0;
1732 *datasize = bufsize;
1733 LIST_FOR_EACH_ENTRY( packet, &packets, struct clipboard_data_packet, entry)
1734 {
1735 memcpy(&buf[bytes_copied], packet->data, packet->size);
1736 bytes_copied += packet->size;
1737 }
1738 buf[bufsize] = 0;
1739 *data = buf;
1740 }
1741 else
1742 res = FALSE;
1743 }
1744
1745 LIST_FOR_EACH_ENTRY_SAFE( packet, packet2, &packets, struct clipboard_data_packet, entry)
1746 {
1747 HeapFree(GetProcessHeap(), 0, packet->data);
1748 HeapFree(GetProcessHeap(), 0, packet);
1749 }
1750
1751 return res;
1752 }
1753
1754 return TRUE;
1755 }
1756
1757
1758 /**************************************************************************
1759 * acquire_selection
1760 *
1761 * Acquire the X11 selection when the Win32 clipboard has changed.
1762 */
1763 static void acquire_selection( Display *display )
1764 {
1765 if (selection_window) XDestroyWindow( display, selection_window );
1766
1767 selection_window = XCreateWindow( display, root_window, 0, 0, 1, 1, 0, CopyFromParent,
1768 InputOutput, CopyFromParent, 0, NULL );
1769 if (!selection_window) return;
1770
1771 XSetSelectionOwner( display, x11drv_atom(CLIPBOARD), selection_window, CurrentTime );
1772 if (use_primary_selection) XSetSelectionOwner( display, XA_PRIMARY, selection_window, CurrentTime );
1773 TRACE( "win %lx\n", selection_window );
1774 }
1775
1776
1777 /**************************************************************************
1778 * release_selection
1779 *
1780 * Release the X11 selection when some other X11 app has grabbed it.
1781 */
1782 static void release_selection( Display *display, Time time )
1783 {
1784 assert( selection_window );
1785
1786 TRACE( "win %lx\n", selection_window );
1787
1788 /* release PRIMARY if we still own it */
1789 if (use_primary_selection && XGetSelectionOwner( display, XA_PRIMARY ) == selection_window)
1790 XSetSelectionOwner( display, XA_PRIMARY, None, time );
1791
1792 XDestroyWindow( display, selection_window );
1793 selection_window = 0;
1794 }
1795
1796
1797 /**************************************************************************
1798 * request_selection_contents
1799 *
1800 * Retrieve the contents of the X11 selection when it's owned by an X11 app.
1801 */
1802 static BOOL request_selection_contents( Display *display, BOOL changed )
1803 {
1804 struct clipboard_format *targets = find_x11_format( x11drv_atom(TARGETS) );
1805 struct clipboard_format *string = find_x11_format( XA_STRING );
1806 struct clipboard_format *format = NULL;
1807 Window owner = 0;
1808 unsigned char *data = NULL;
1809 unsigned long size = 0;
1810 Atom type = 0;
1811
1812 static Atom last_selection;
1813 static Window last_owner;
1814 static struct clipboard_format *last_format;
1815 static Atom last_type;
1816 static unsigned char *last_data;
1817 static unsigned long last_size;
1818
1819 assert( targets );
1820 assert( string );
1821
1822 current_selection = 0;
1823 if (use_primary_selection)
1824 {
1825 if ((owner = XGetSelectionOwner( display, XA_PRIMARY )))
1826 current_selection = XA_PRIMARY;
1827 }
1828 if (!current_selection)
1829 {
1830 if ((owner = XGetSelectionOwner( display, x11drv_atom(CLIPBOARD) )))
1831 current_selection = x11drv_atom(CLIPBOARD);
1832 }
1833
1834 if (current_selection)
1835 {
1836 if (convert_selection( display, import_window, current_selection, targets, &type, &data, &size ))
1837 format = targets;
1838 else if (convert_selection( display, import_window, current_selection, string, &type, &data, &size ))
1839 format = string;
1840 }
1841
1842 changed = (changed ||
1843 rendered_formats ||
1844 last_selection != current_selection ||
1845 last_owner != owner ||
1846 last_format != format ||
1847 last_type != type ||
1848 last_size != size ||
1849 memcmp( last_data, data, size ));
1850
1851 if (!changed || !OpenClipboard( clipboard_hwnd ))
1852 {
1853 HeapFree( GetProcessHeap(), 0, data );
1854 return FALSE;
1855 }
1856
1857 TRACE( "selection changed, importing\n" );
1858 EmptyClipboard();
1859 is_clipboard_owner = TRUE;
1860 rendered_formats = 0;
1861
1862 if (format) format->import( type, data, size );
1863
1864 HeapFree( GetProcessHeap(), 0, last_data );
1865 last_selection = current_selection;
1866 last_owner = owner;
1867 last_format = format;
1868 last_type = type;
1869 last_data = data;
1870 last_size = size;
1871 last_clipboard_update = GetTickCount64();
1872 CloseClipboard();
1873 if (!use_xfixes)
1874 SetTimer( clipboard_hwnd, 1, SELECTION_UPDATE_DELAY, NULL );
1875 return TRUE;
1876 }
1877
1878
1879 /**************************************************************************
1880 * update_clipboard
1881 *
1882 * Periodically update the clipboard while the selection is owned by an X11 app.
1883 */
1884 BOOL update_clipboard( HWND hwnd )
1885 {
1886 if (use_xfixes) return TRUE;
1887 if (hwnd != clipboard_hwnd) return TRUE;
1888 if (!is_clipboard_owner) return TRUE;
1889 if (GetTickCount64() - last_clipboard_update <= SELECTION_UPDATE_DELAY) return TRUE;
1890 return request_selection_contents( thread_display(), FALSE );
1891 }
1892
1893
1894 /**************************************************************************
1895 * clipboard_wndproc
1896 *
1897 * Window procedure for the clipboard manager.
1898 */
1899 static LRESULT CALLBACK clipboard_wndproc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp )
1900 {
1901 switch (msg)
1902 {
1903 case WM_NCCREATE:
1904 return TRUE;
1905 case WM_CLIPBOARDUPDATE:
1906 if (is_clipboard_owner) break; /* ignore our own changes */
1907 acquire_selection( thread_init_display() );
1908 break;
1909 case WM_RENDERFORMAT:
1910 if (render_format( wp )) rendered_formats++;
1911 break;
1912 case WM_TIMER:
1913 if (!is_clipboard_owner) break;
1914 request_selection_contents( thread_display(), FALSE );
1915 break;
1916 case WM_DESTROYCLIPBOARD:
1917 TRACE( "WM_DESTROYCLIPBOARD: lost ownership\n" );
1918 is_clipboard_owner = FALSE;
1919 KillTimer( hwnd, 1 );
1920 break;
1921 }
1922 return DefWindowProcW( hwnd, msg, wp, lp );
1923 }
1924
1925
1926 /**************************************************************************
1927 * wait_clipboard_mutex
1928 *
1929 * Make sure that there's only one clipboard thread per window station.
1930 */
1931 static BOOL wait_clipboard_mutex(void)
1932 {
1933 static const WCHAR prefix[] = {'_','_','w','i','n','e','_','c','l','i','p','b','o','a','r','d','_'};
1934 WCHAR buffer[MAX_PATH + ARRAY_SIZE( prefix )];
1935 HANDLE mutex;
1936
1937 memcpy( buffer, prefix, sizeof(prefix) );
1938 if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_NAME,
1939 buffer + ARRAY_SIZE( prefix ),
1940 sizeof(buffer) - sizeof(prefix), NULL ))
1941 {
1942 ERR( "failed to get winstation name\n" );
1943 return FALSE;
1944 }
1945 mutex = CreateMutexW( NULL, TRUE, buffer );
1946 if (GetLastError() == ERROR_ALREADY_EXISTS)
1947 {
1948 TRACE( "waiting for mutex %s\n", debugstr_w( buffer ));
1949 WaitForSingleObject( mutex, INFINITE );
1950 }
1951 return TRUE;
1952 }
1953
1954
1955 /**************************************************************************
1956 * selection_notify_event
1957 *
1958 * Called when x11 clipboard content changes
1959 */
1960 #ifdef SONAME_LIBXFIXES
1961 static BOOL selection_notify_event( HWND hwnd, XEvent *event )
1962 {
1963 XFixesSelectionNotifyEvent *req = (XFixesSelectionNotifyEvent*)event;
1964
1965 if (!is_clipboard_owner) return FALSE;
1966 if (req->owner == selection_window) return FALSE;
1967 request_selection_contents( req->display, TRUE );
1968 return FALSE;
1969 }
1970 #endif
1971
1972 /**************************************************************************
1973 * xfixes_init
1974 *
1975 * Initialize xfixes to receive clipboard update notifications
1976 */
1977 static void xfixes_init(void)
1978 {
1979 #ifdef SONAME_LIBXFIXES
1980 typeof(XFixesSelectSelectionInput) *pXFixesSelectSelectionInput;
1981 typeof(XFixesQueryExtension) *pXFixesQueryExtension;
1982 typeof(XFixesQueryVersion) *pXFixesQueryVersion;
1983
1984 int event_base, error_base;
1985 int major = 3, minor = 0;
1986 void *handle;
1987
1988 handle = dlopen(SONAME_LIBXFIXES, RTLD_NOW);
1989 if (!handle) return;
1990
1991 pXFixesQueryExtension = dlsym(handle, "XFixesQueryExtension");
1992 if (!pXFixesQueryExtension) return;
1993 pXFixesQueryVersion = dlsym(handle, "XFixesQueryVersion");
1994 if (!pXFixesQueryVersion) return;
1995 pXFixesSelectSelectionInput = dlsym(handle, "XFixesSelectSelectionInput");
1996 if (!pXFixesSelectSelectionInput) return;
1997
1998 if (!pXFixesQueryExtension(clipboard_display, &event_base, &error_base))
1999 return;
2000 pXFixesQueryVersion(clipboard_display, &major, &minor);
2001 use_xfixes = (major >= 1);
2002 if (!use_xfixes) return;
2003
2004 pXFixesSelectSelectionInput(clipboard_display, import_window, x11drv_atom(CLIPBOARD),
2005 XFixesSetSelectionOwnerNotifyMask |
2006 XFixesSelectionWindowDestroyNotifyMask |
2007 XFixesSelectionClientCloseNotifyMask);
2008 if (use_primary_selection)
2009 {
2010 pXFixesSelectSelectionInput(clipboard_display, import_window, XA_PRIMARY,
2011 XFixesSetSelectionOwnerNotifyMask |
2012 XFixesSelectionWindowDestroyNotifyMask |
2013 XFixesSelectionClientCloseNotifyMask);
2014 }
2015 X11DRV_register_event_handler(event_base + XFixesSelectionNotify,
2016 selection_notify_event, "XFixesSelectionNotify");
2017 TRACE("xfixes succesully initialized\n");
2018 #else
2019 WARN("xfixes not supported\n");
2020 #endif
2021 }
2022
2023
2024 /**************************************************************************
2025 * clipboard_thread
2026 *
2027 * Thread running inside the desktop process to manage the clipboard
2028 */
2029 static DWORD WINAPI clipboard_thread( void *arg )
2030 {
2031 static const WCHAR clipboard_classname[] = {'_','_','w','i','n','e','_','c','l','i','p','b','o','a','r','d','_','m','a','n','a','g','e','r',0};
2032 XSetWindowAttributes attr;
2033 WNDCLASSW class;
2034 MSG msg;
2035
2036 if (!wait_clipboard_mutex()) return 0;
2037
2038 clipboard_display = thread_init_display();
2039 attr.event_mask = PropertyChangeMask;
2040 import_window = XCreateWindow( clipboard_display, root_window, 0, 0, 1, 1, 0, CopyFromParent,
2041 InputOutput, CopyFromParent, CWEventMask, &attr );
2042 if (!import_window)
2043 {
2044 ERR( "failed to create import window\n" );
2045 return 0;
2046 }
2047
2048 memset( &class, 0, sizeof(class) );
2049 class.lpfnWndProc = clipboard_wndproc;
2050 class.lpszClassName = clipboard_classname;
2051
2052 if (!RegisterClassW( &class ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
2053 {
2054 ERR( "could not register clipboard window class err %u\n", GetLastError() );
2055 return 0;
2056 }
2057 if (!(clipboard_hwnd = CreateWindowW( clipboard_classname, NULL, 0, 0, 0, 0, 0,
2058 HWND_MESSAGE, 0, 0, NULL )))
2059 {
2060 ERR( "failed to create clipboard window err %u\n", GetLastError() );
2061 return 0;
2062 }
2063
2064 clipboard_thread_id = GetCurrentThreadId();
2065 AddClipboardFormatListener( clipboard_hwnd );
2066 register_builtin_formats();
2067 request_selection_contents( clipboard_display, TRUE );
2068
2069 xfixes_init();
2070
2071 TRACE( "clipboard thread %04x running\n", GetCurrentThreadId() );
2072 while (GetMessageW( &msg, 0, 0, 0 )) DispatchMessageW( &msg );
2073 return 0;
2074 }
2075
2076
2077 /**************************************************************************
2078 * X11DRV_UpdateClipboard
2079 */
2080 void CDECL X11DRV_UpdateClipboard(void)
2081 {
2082 static ULONG last_update;
2083 ULONG now;
2084 DWORD_PTR ret;
2085
2086 if (use_xfixes) return;
2087 if (GetCurrentThreadId() == clipboard_thread_id) return;
2088 now = GetTickCount();
2089 if ((int)(now - last_update) <= SELECTION_UPDATE_DELAY) return;
2090 if (SendMessageTimeoutW( GetClipboardOwner(), WM_X11DRV_UPDATE_CLIPBOARD, 0, 0,
2091 SMTO_ABORTIFHUNG, 5000, &ret ) && ret)
2092 last_update = now;
2093 }
2094
2095
2096 /***********************************************************************
2097 * X11DRV_HandleSelectionRequest
2098 */
2099 BOOL X11DRV_SelectionRequest( HWND hwnd, XEvent *xev )
2100 {
2101 XSelectionRequestEvent *event = &xev->xselectionrequest;
2102 Display *display = event->display;
2103 XEvent result;
2104 Atom rprop = None;
2105
2106 TRACE( "got request on %lx for selection %s target %s win %lx prop %s\n",
2107 event->owner, debugstr_xatom( event->selection ), debugstr_xatom( event->target ),
2108 event->requestor, debugstr_xatom( event->property ));
2109
2110 if (event->owner != selection_window) goto done;
2111 if ((event->selection != x11drv_atom(CLIPBOARD)) &&
2112 (!use_primary_selection || event->selection != XA_PRIMARY)) goto done;
2113
2114 /* If the specified property is None the requestor is an obsolete client.
2115 * We support these by using the specified target atom as the reply property.
2116 */
2117 rprop = event->property;
2118 if( rprop == None )
2119 rprop = event->target;
2120
2121 if (!export_selection( display, event->requestor, rprop, event->target ))
2122 rprop = None; /* report failure to client */
2123
2124 done:
2125 result.xselection.type = SelectionNotify;
2126 result.xselection.display = display;
2127 result.xselection.requestor = event->requestor;
2128 result.xselection.selection = event->selection;
2129 result.xselection.property = rprop;
2130 result.xselection.target = event->target;
2131 result.xselection.time = event->time;
2132 TRACE( "sending SelectionNotify for %s to %lx\n", debugstr_xatom( rprop ), event->requestor );
2133 XSendEvent( display, event->requestor, False, NoEventMask, &result );
2134 return FALSE;
2135 }
2136
2137
2138 /***********************************************************************
2139 * X11DRV_SelectionClear
2140 */
2141 BOOL X11DRV_SelectionClear( HWND hwnd, XEvent *xev )
2142 {
2143 XSelectionClearEvent *event = &xev->xselectionclear;
2144
2145 if (event->window != selection_window) return FALSE;
2146 if (event->selection != x11drv_atom(CLIPBOARD)) return FALSE;
2147
2148 release_selection( event->display, event->time );
2149 request_selection_contents( event->display, TRUE );
2150 return FALSE;
2151 }
2152
2153
2154 /**************************************************************************
2155 * X11DRV_InitClipboard
2156 */
2157 void X11DRV_InitClipboard(void)
2158 {
2159 DWORD id;
2160 HANDLE handle = CreateThread( NULL, 0, clipboard_thread, NULL, 0, &id );
2161
2162 if (handle) CloseHandle( handle );
2163 else ERR( "failed to create clipboard thread\n" );
2164 }
Windows API implementation