dlls/winex11.drv/clipboard.c

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