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 NB_BUILTIN_FORMATS (sizeof(builtin_formats) / sizeof(builtin_formats[0]))
 191 #define GET_ATOM(prop)  (((prop) < FIRST_XATOM) ? (Atom)(prop) : X11DRV_Atoms[(prop) - FIRST_XATOM])
 192
 193 static DWORD clipboard_thread_id;
 194 static HWND clipboard_hwnd;
 195 static BOOL is_clipboard_owner;
 196 static Window selection_window;
 197 static Window import_window;
 198 static Atom current_selection;
 199 static UINT rendered_formats;
 200 static ULONG64 last_clipboard_update;
 201 static struct clipboard_format **current_x11_formats;
 202 static unsigned int nb_current_x11_formats;
 203 static BOOL use_xfixes;
 204
 205 Display *clipboard_display = NULL;
 206
 207 static const char *debugstr_format( UINT id )
 208 {
 209     WCHAR buffer[256];
 210
 211     if (GetClipboardFormatNameW( id, buffer, 256 ))
 212         return wine_dbg_sprintf( "%04x %s", id, debugstr_w(buffer) );
 213
 214     switch (id)
 215     {
 216     case 0: return "(none)";
 217 #define BUILTIN(id) case id: return #id;
 218     BUILTIN(CF_TEXT)
 219     BUILTIN(CF_BITMAP)
 220     BUILTIN(CF_METAFILEPICT)
 221     BUILTIN(CF_SYLK)
 222     BUILTIN(CF_DIF)
 223     BUILTIN(CF_TIFF)
 224     BUILTIN(CF_OEMTEXT)
 225     BUILTIN(CF_DIB)
 226     BUILTIN(CF_PALETTE)
 227     BUILTIN(CF_PENDATA)
 228     BUILTIN(CF_RIFF)
 229     BUILTIN(CF_WAVE)
 230     BUILTIN(CF_UNICODETEXT)
 231     BUILTIN(CF_ENHMETAFILE)
 232     BUILTIN(CF_HDROP)
 233     BUILTIN(CF_LOCALE)
 234     BUILTIN(CF_DIBV5)
 235     BUILTIN(CF_OWNERDISPLAY)
 236     BUILTIN(CF_DSPTEXT)
 237     BUILTIN(CF_DSPBITMAP)
 238     BUILTIN(CF_DSPMETAFILEPICT)
 239     BUILTIN(CF_DSPENHMETAFILE)
 240 #undef BUILTIN
 241     default: return wine_dbg_sprintf( "%04x", id );
 242     }
 243 }
 244
 245 static const char *debugstr_xatom( Atom atom )
 246 {
 247     const char *ret;
 248     char *name;
 249
 250     if (!atom) return "(None)";
 251     name = XGetAtomName( thread_display(), atom );
 252     ret = debugstr_a( name );
 253     XFree( name );
 254     return ret;
 255 }
 256
 257
 258 static int is_atom_error( Display *display, XErrorEvent *event, void *arg )
 259 {
 260     return (event->error_code == BadAtom);
 261 }
 262
 263
 264 /**************************************************************************
 265  *              find_win32_format
 266  */
 267 static struct clipboard_format *find_win32_format( UINT id )
 268 {
 269     struct clipboard_format *format;
 270
 271     LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
 272         if (format->id == id) return format;
 273     return NULL;
 274 }
 275
 276
 277 /**************************************************************************
 278  *              find_x11_format
 279  */
 280 static struct clipboard_format *find_x11_format( Atom atom )
 281 {
 282     struct clipboard_format *format;
 283
 284     LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
 285         if (format->atom == atom) return format;
 286     return NULL;
 287 }
 288
 289
 290 /**************************************************************************
 291  *              register_builtin_formats
 292  */
 293 static void register_builtin_formats(void)
 294 {
 295     struct clipboard_format *formats;
 296     unsigned int i;
 297
 298     if (!(formats = HeapAlloc( GetProcessHeap(), 0, NB_BUILTIN_FORMATS * sizeof(*formats)))) return;
 299
 300     for (i = 0; i < NB_BUILTIN_FORMATS; i++)
 301     {
 302         if (builtin_formats[i].name)
 303             formats[i].id = RegisterClipboardFormatW( builtin_formats[i].name );
 304         else
 305             formats[i].id = builtin_formats[i].id;
 306
 307         formats[i].atom   = GET_ATOM(builtin_formats[i].data);
 308         formats[i].import = builtin_formats[i].import;
 309         formats[i].export = builtin_formats[i].export;
 310         list_add_tail( &format_list, &formats[i].entry );
 311     }
 312 }
 313
 314
 315 /**************************************************************************
 316  *              register_formats
 317  */
 318 static void register_formats( const UINT *ids, const Atom *atoms, unsigned int count )
 319 {
 320     struct clipboard_format *formats;
 321     unsigned int i;
 322
 323     if (!(formats = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*formats)))) return;
 324
 325     for (i = 0; i < count; i++)
 326     {
 327         formats[i].id     = ids[i];
 328         formats[i].atom   = atoms[i];
 329         formats[i].import = import_data;
 330         formats[i].export = export_data;
 331         list_add_tail( &format_list, &formats[i].entry );
 332         TRACE( "registered %s atom %s\n", debugstr_format( ids[i] ), debugstr_xatom( atoms[i] ));
 333     }
 334 }
 335
 336
 337 /**************************************************************************
 338  *              register_win32_formats
 339  *
 340  * Register Win32 clipboard formats the first time we encounter them.
 341  */
 342 static void register_win32_formats( const UINT *ids, UINT size )
 343 {
 344     unsigned int count, len;
 345     UINT new_ids[256];
 346     char *names[256];
 347     Atom atoms[256];
 348     WCHAR buffer[256];
 349
 350     if (list_empty( &format_list)) register_builtin_formats();
 351
 352     while (size)
 353     {
 354         for (count = 0; count < 256 && size; ids++, size--)
 355         {
 356             if (find_win32_format( *ids )) continue;  /* it already exists */
 357             if (!GetClipboardFormatNameW( *ids, buffer, 256 )) continue;  /* not a named format */
 358             if (!(len = WideCharToMultiByte( CP_UNIXCP, 0, buffer, -1, NULL, 0, NULL, NULL ))) continue;
 359             if (!(names[count] = HeapAlloc( GetProcessHeap(), 0, len ))) continue;
 360             WideCharToMultiByte( CP_UNIXCP, 0, buffer, -1, names[count], len, NULL, NULL );
 361             new_ids[count++] = *ids;
 362         }
 363         if (!count) return;
 364
 365         XInternAtoms( thread_display(), names, count, False, atoms );
 366         register_formats( new_ids, atoms, count );
 367         while (count) HeapFree( GetProcessHeap(), 0, names[--count] );
 368     }
 369 }
 370
 371
 372 /**************************************************************************
 373  *              register_x11_formats
 374  *
 375  * Register X11 atom formats the first time we encounter them.
 376  */
 377 static void register_x11_formats( const Atom *atoms, UINT size )
 378 {
 379     Display *display = thread_display();
 380     unsigned int i, pos, count;
 381     char *names[256];
 382     UINT ids[256];
 383     Atom new_atoms[256];
 384     WCHAR buffer[256];
 385
 386     if (list_empty( &format_list)) register_builtin_formats();
 387
 388     while (size)
 389     {
 390         for (count = 0; count < 256 && size; atoms++, size--)
 391             if (!find_x11_format( *atoms )) new_atoms[count++] = *atoms;
 392
 393         if (!count) return;
 394
 395         X11DRV_expect_error( display, is_atom_error, NULL );
 396         if (!XGetAtomNames( display, new_atoms, count, names )) count = 0;
 397         if (X11DRV_check_error())
 398         {
 399             WARN( "got some bad atoms, ignoring\n" );
 400             count = 0;
 401         }
 402
 403         for (i = pos = 0; i < count; i++)
 404         {
 405             if (MultiByteToWideChar( CP_UNIXCP, 0, names[i], -1, buffer, 256 ) &&
 406                 (ids[pos] = RegisterClipboardFormatW( buffer )))
 407                 new_atoms[pos++] = new_atoms[i];
 408             XFree( names[i] );
 409         }
 410         register_formats( ids, new_atoms, pos );
 411     }
 412 }
 413
 414
 415 /**************************************************************************
 416  *              put_property
 417  *
 418  * Put data as a property on the specified window.
 419  */
 420 static void put_property( Display *display, Window win, Atom prop, Atom type, int format,
 421                           const void *ptr, size_t size )
 422 {
 423     const unsigned char *data = ptr;
 424     int mode = PropModeReplace;
 425     size_t width = (format == 32) ? sizeof(long) : format / 8;
 426     size_t max_size = XExtendedMaxRequestSize( display ) * 4;
 427
 428     if (!max_size) max_size = XMaxRequestSize( display ) * 4;
 429     max_size -= 64; /* request overhead */
 430
 431     do
 432     {
 433         size_t count = min( size, max_size / width );
 434         XChangeProperty( display, win, prop, type, format, mode, data, count );
 435         mode = PropModeAppend;
 436         size -= count;
 437         data += count * width;
 438     } while (size > 0);
 439 }
 440
 441
 442 /**************************************************************************
 443  *              convert_selection
 444  */
 445 static BOOL convert_selection( Display *display, Window win, Atom selection,
 446                                struct clipboard_format *format, Atom *type,
 447                                unsigned char **data, unsigned long *size )
 448 {
 449     int i;
 450     XEvent event;
 451
 452     TRACE( "import %s from %s win %lx to format %s\n",
 453            debugstr_xatom( format->atom ), debugstr_xatom( selection ),
 454            win, debugstr_format( format->id ) );
 455
 456     XConvertSelection( display, selection, format->atom, x11drv_atom(SELECTION_DATA), win, CurrentTime );
 457
 458     for (i = 0; i < SELECTION_RETRIES; i++)
 459     {
 460         Bool res = XCheckTypedWindowEvent( display, win, SelectionNotify, &event );
 461         if (res && event.xselection.selection == selection && event.xselection.target == format->atom)
 462             return read_property( display, win, event.xselection.property, type, data, size );
 463         usleep( SELECTION_WAIT );
 464     }
 465     ERR( "Timed out waiting for SelectionNotify event\n" );
 466     return FALSE;
 467 }
 468
 469
 470 /***********************************************************************
 471  *           bitmap_info_size
 472  *
 473  * Return the size of the bitmap info structure including color table.
 474  */
 475 static int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
 476 {
 477     unsigned int colors, size, masks = 0;
 478
 479     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 480     {
 481         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
 482         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
 483         return sizeof(BITMAPCOREHEADER) + colors *
 484              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
 485     }
 486     else  /* assume BITMAPINFOHEADER */
 487     {
 488         colors = info->bmiHeader.biClrUsed;
 489         if (!colors && (info->bmiHeader.biBitCount <= 8))
 490             colors = 1 << info->bmiHeader.biBitCount;
 491         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
 492         size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
 493         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
 494     }
 495 }
 496
 497
 498 /***********************************************************************
 499  *           create_dib_from_bitmap
 500  *
 501  *  Allocates a packed DIB and copies the bitmap data into it.
 502  */
 503 static HGLOBAL create_dib_from_bitmap(HBITMAP hBmp)
 504 {
 505     BITMAP bmp;
 506     HDC hdc;
 507     HGLOBAL hPackedDIB;
 508     LPBYTE pPackedDIB;
 509     LPBITMAPINFOHEADER pbmiHeader;
 510     unsigned int cDataSize, cPackedSize, OffsetBits;
 511     int nLinesCopied;
 512
 513     if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
 514
 515     /*
 516      * A packed DIB contains a BITMAPINFO structure followed immediately by
 517      * an optional color palette and the pixel data.
 518      */
 519
 520     /* Calculate the size of the packed DIB */
 521     cDataSize = abs( bmp.bmHeight ) * (((bmp.bmWidth * bmp.bmBitsPixel + 31) / 8) & ~3);
 522     cPackedSize = sizeof(BITMAPINFOHEADER)
 523                   + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
 524                   + cDataSize;
 525     /* Get the offset to the bits */
 526     OffsetBits = cPackedSize - cDataSize;
 527
 528     /* Allocate the packed DIB */
 529     TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
 530     hPackedDIB = GlobalAlloc( GMEM_FIXED, cPackedSize );
 531     if ( !hPackedDIB )
 532     {
 533         WARN("Could not allocate packed DIB!\n");
 534         return 0;
 535     }
 536
 537     /* A packed DIB starts with a BITMAPINFOHEADER */
 538     pPackedDIB = GlobalLock(hPackedDIB);
 539     pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
 540
 541     /* Init the BITMAPINFOHEADER */
 542     pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
 543     pbmiHeader->biWidth = bmp.bmWidth;
 544     pbmiHeader->biHeight = bmp.bmHeight;
 545     pbmiHeader->biPlanes = 1;
 546     pbmiHeader->biBitCount = bmp.bmBitsPixel;
 547     pbmiHeader->biCompression = BI_RGB;
 548     pbmiHeader->biSizeImage = 0;
 549     pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
 550     pbmiHeader->biClrUsed = 0;
 551     pbmiHeader->biClrImportant = 0;
 552
 553     /* Retrieve the DIB bits from the bitmap and fill in the
 554      * DIB color table if present */
 555     hdc = GetDC( 0 );
 556     nLinesCopied = GetDIBits(hdc,                       /* Handle to device context */
 557                              hBmp,                      /* Handle to bitmap */
 558                              0,                         /* First scan line to set in dest bitmap */
 559                              bmp.bmHeight,              /* Number of scan lines to copy */
 560                              pPackedDIB + OffsetBits,   /* [out] Address of array for bitmap bits */
 561                              (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
 562                              0);                        /* RGB or palette index */
 563     GlobalUnlock(hPackedDIB);
 564     ReleaseDC( 0, hdc );
 565
 566     /* Cleanup if GetDIBits failed */
 567     if (nLinesCopied != bmp.bmHeight)
 568     {
 569         TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
 570         GlobalFree(hPackedDIB);
 571         hPackedDIB = 0;
 572     }
 573     return hPackedDIB;
 574 }
 575
 576
 577 /***********************************************************************
 578  *           uri_to_dos
 579  *
 580  *  Converts a text/uri-list URI to DOS filename.
 581  */
 582 static WCHAR* uri_to_dos(char *encodedURI)
 583 {
 584     WCHAR *ret = NULL;
 585     int i;
 586     int j = 0;
 587     char *uri = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlen(encodedURI) + 1);
 588     if (uri == NULL)
 589         return NULL;
 590     for (i = 0; encodedURI[i]; ++i)
 591     {
 592         if (encodedURI[i] == '%')
 593         {
 594             if (encodedURI[i+1] && encodedURI[i+2])
 595             {
 596                 char buffer[3];
 597                 int number;
 598                 buffer[0] = encodedURI[i+1];
 599                 buffer[1] = encodedURI[i+2];
 600                 buffer[2] = '\0';
 601                 sscanf(buffer, "%x", &number);
 602                 uri[j++] = number;
 603                 i += 2;
 604             }
 605             else
 606             {
 607                 WARN("invalid URI encoding in %s\n", debugstr_a(encodedURI));
 608                 HeapFree(GetProcessHeap(), 0, uri);
 609                 return NULL;
 610             }
 611         }
 612         else
 613             uri[j++] = encodedURI[i];
 614     }
 615
 616     /* Read http://www.freedesktop.org/wiki/Draganddropwarts and cry... */
 617     if (strncmp(uri, "file:/", 6) == 0)
 618     {
 619         if (uri[6] == '/')
 620         {
 621             if (uri[7] == '/')
 622             {
 623                 /* file:///path/to/file (nautilus, thunar) */
 624                 ret = wine_get_dos_file_name(&uri[7]);
 625             }
 626             else if (uri[7])
 627             {
 628                 /* file://hostname/path/to/file (X file drag spec) */
 629                 char hostname[256];
 630                 char *path = strchr(&uri[7], '/');
 631                 if (path)
 632                 {
 633                     *path = '\0';
 634                     if (strcmp(&uri[7], "localhost") == 0)
 635                     {
 636                         *path = '/';
 637                         ret = wine_get_dos_file_name(path);
 638                     }
 639                     else if (gethostname(hostname, sizeof(hostname)) == 0)
 640                     {
 641                         if (strcmp(hostname, &uri[7]) == 0)
 642                         {
 643                             *path = '/';
 644                             ret = wine_get_dos_file_name(path);
 645                         }
 646                     }
 647                 }
 648             }
 649         }
 650         else if (uri[6])
 651         {
 652             /* file:/path/to/file (konqueror) */
 653             ret = wine_get_dos_file_name(&uri[5]);
 654         }
 655     }
 656     HeapFree(GetProcessHeap(), 0, uri);
 657     return ret;
 658 }
 659
 660
 661 /**************************************************************************
 662  *              unicode_text_from_string
 663  *
 664  * Convert a string in the specified encoding to CF_UNICODETEXT format.
 665  */
 666 static HANDLE unicode_text_from_string( UINT codepage, const void *data, size_t size )
 667 {
 668     DWORD i, j, count;
 669     WCHAR *strW;
 670
 671     count = MultiByteToWideChar( codepage, 0, data, size, NULL, 0);
 672
 673     if (!(strW = GlobalAlloc( GMEM_FIXED, (count * 2 + 1) * sizeof(WCHAR) ))) return 0;
 674
 675     MultiByteToWideChar( codepage, 0, data, size, strW + count, count );
 676     for (i = j = 0; i < count; i++)
 677     {
 678         if (strW[i + count] == '\n') strW[j++] = '\r';
 679         strW[j++] = strW[i + count];
 680     }
 681     strW[j++] = 0;
 682     GlobalReAlloc( strW, j * sizeof(WCHAR), GMEM_FIXED );  /* release unused space */
 683     TRACE( "returning %s\n", debugstr_wn( strW, j - 1 ));
 684     return strW;
 685 }
 686
 687
 688 /**************************************************************************
 689  *              import_string
 690  *
 691  * Import XA_STRING, converting the string to CF_UNICODETEXT.
 692  */
 693 static HANDLE import_string( Atom type, const void *data, size_t size )
 694 {
 695     return unicode_text_from_string( 28591, data, size );
 696 }
 697
 698
 699 /**************************************************************************
 700  *              import_utf8_string
 701  *
 702  * Import XA_UTF8_STRING, converting the string to CF_UNICODETEXT.
 703  */
 704 static HANDLE import_utf8_string( Atom type, const void *data, size_t size )
 705 {
 706     return unicode_text_from_string( CP_UTF8, data, size );
 707 }
 708
 709
 710 /**************************************************************************
 711  *              import_compound_text
 712  *
 713  * Import COMPOUND_TEXT to CF_UNICODETEXT.
 714  */
 715 static HANDLE import_compound_text( Atom type, const void *data, size_t size )
 716 {
 717     char** srcstr;
 718     int count;
 719     HANDLE ret;
 720     XTextProperty txtprop;
 721
 722     txtprop.value = (BYTE *)data;
 723     txtprop.nitems = size;
 724     txtprop.encoding = x11drv_atom(COMPOUND_TEXT);
 725     txtprop.format = 8;
 726     if (XmbTextPropertyToTextList( thread_display(), &txtprop, &srcstr, &count ) != Success) return 0;
 727     if (!count) return 0;
 728
 729     ret = unicode_text_from_string( CP_UNIXCP, srcstr[0], strlen(srcstr[0]) + 1 );
 730     XFreeStringList(srcstr);
 731     return ret;
 732 }
 733
 734
 735 /**************************************************************************
 736  *              import_text
 737  *
 738  * Import XA_TEXT, converting the string to CF_UNICODETEXT.
 739  */
 740 static HANDLE import_text( Atom type, const void *data, size_t size )
 741 {
 742     if (type == XA_STRING) return import_string( type, data, size );
 743     if (type == x11drv_atom(UTF8_STRING)) return import_utf8_string( type, data, size );
 744     if (type == x11drv_atom(COMPOUND_TEXT)) return import_compound_text( type, data, size );
 745     FIXME( "unsupported TEXT type %s\n", debugstr_xatom( type ));
 746     return 0;
 747 }
 748
 749
 750 /**************************************************************************
 751  *              import_pixmap
 752  *
 753  *  Import XA_PIXMAP, converting the image to CF_DIB.
 754  */
 755 static HANDLE import_pixmap( Atom type, const void *data, size_t size )
 756 {
 757     const Pixmap *pPixmap = (const Pixmap *)data;
 758     BYTE *ptr = NULL;
 759     XVisualInfo vis = default_visual;
 760     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 761     BITMAPINFO *info = (BITMAPINFO *)buffer;
 762     struct gdi_image_bits bits;
 763     Window root;
 764     int x,y;               /* Unused */
 765     unsigned border_width; /* Unused */
 766     unsigned int depth, width, height;
 767
 768     /* Get the Pixmap dimensions and bit depth */
 769     if (!XGetGeometry(gdi_display, *pPixmap, &root, &x, &y, &width, &height,
 770                       &border_width, &depth)) depth = 0;
 771     if (!pixmap_formats[depth]) return 0;
 772
 773     TRACE( "pixmap properties: width=%d, height=%d, depth=%d\n", width, height, depth );
 774
 775     if (depth != vis.depth) switch (pixmap_formats[depth]->bits_per_pixel)
 776     {
 777         case 1:
 778         case 4:
 779         case 8:
 780             break;
 781         case 16:  /* assume R5G5B5 */
 782             vis.red_mask   = 0x7c00;
 783             vis.green_mask = 0x03e0;
 784             vis.blue_mask  = 0x001f;
 785             break;
 786         case 24:  /* assume R8G8B8 */
 787         case 32:  /* assume A8R8G8B8 */
 788             vis.red_mask   = 0xff0000;
 789             vis.green_mask = 0x00ff00;
 790             vis.blue_mask  = 0x0000ff;
 791             break;
 792         default:
 793             return 0;
 794     }
 795
 796     if (!get_pixmap_image( *pPixmap, width, height, &vis, info, &bits ))
 797     {
 798         DWORD info_size = bitmap_info_size( info, DIB_RGB_COLORS );
 799
 800         ptr = GlobalAlloc( GMEM_FIXED, info_size + info->bmiHeader.biSizeImage );
 801         if (ptr)
 802         {
 803             memcpy( ptr, info, info_size );
 804             memcpy( ptr + info_size, bits.ptr, info->bmiHeader.biSizeImage );
 805         }
 806         if (bits.free) bits.free( &bits );
 807     }
 808     return ptr;
 809 }
 810
 811
 812 /**************************************************************************
 813  *              import_image_bmp
 814  *
 815  *  Import image/bmp, converting the image to CF_DIB.
 816  */
 817 static HANDLE import_image_bmp( Atom type, const void *data, size_t size )
 818 {
 819     HANDLE hClipData = 0;
 820     const BITMAPFILEHEADER *bfh = data;
 821
 822     if (size >= sizeof(BITMAPFILEHEADER)+sizeof(BITMAPCOREHEADER) &&
 823         bfh->bfType == 0x4d42 /* "BM" */)
 824     {
 825         const BITMAPINFO *bmi = (const BITMAPINFO *)(bfh + 1);
 826         HBITMAP hbmp;
 827         HDC hdc = GetDC(0);
 828
 829         if ((hbmp = CreateDIBitmap( hdc, &bmi->bmiHeader, CBM_INIT,
 830                                     (const BYTE *)data + bfh->bfOffBits, bmi, DIB_RGB_COLORS )))
 831         {
 832             hClipData = create_dib_from_bitmap( hbmp );
 833             DeleteObject(hbmp);
 834         }
 835         ReleaseDC(0, hdc);
 836     }
 837     return hClipData;
 838 }
 839
 840
 841 /**************************************************************************
 842  *              import_enhmetafile
 843  */
 844 static HANDLE import_enhmetafile( Atom type, const void *data, size_t size )
 845 {
 846     return SetEnhMetaFileBits( size, data );
 847 }
 848
 849
 850 /**************************************************************************
 851  *              import_text_html
 852  */
 853 static HANDLE import_text_html( Atom type, const void *data, size_t size )
 854 {
 855     static const char header[] =
 856         "Version:0.9\n"
 857         "StartHTML:0000000100\n"
 858         "EndHTML:%010lu\n"
 859         "StartFragment:%010lu\n"
 860         "EndFragment:%010lu\n"
 861         "<!--StartFragment-->";
 862     static const char trailer[] = "\n<!--EndFragment-->";
 863     char *text = NULL;
 864     HANDLE ret;
 865     SIZE_T len, total;
 866
 867     /* Firefox uses UTF-16LE with byte order mark. Convert to UTF-8 without the BOM. */
 868     if (size >= sizeof(WCHAR) && ((const WCHAR *)data)[0] == 0xfeff)
 869     {
 870         len = WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data + 1, size / sizeof(WCHAR) - 1,
 871                                    NULL, 0, NULL, NULL );
 872         if (!(text = HeapAlloc( GetProcessHeap(), 0, len ))) return 0;
 873         WideCharToMultiByte( CP_UTF8, 0, (const WCHAR *)data + 1, size / sizeof(WCHAR) - 1,
 874                              text, len, NULL, NULL );
 875         size = len;
 876         data = text;
 877     }
 878
 879     len = strlen( header ) + 12;  /* 3 * 4 extra chars for %010lu */
 880     total = len + size + sizeof(trailer);
 881     if ((ret = GlobalAlloc( GMEM_FIXED, total )))
 882     {
 883         char *p = ret;
 884         p += sprintf( p, header, total - 1, len, len + size + 1 /* include the final \n in the data */ );
 885         memcpy( p, data, size );
 886         strcpy( p + size, trailer );
 887         TRACE( "returning %s\n", debugstr_a( ret ));
 888     }
 889     HeapFree( GetProcessHeap(), 0, text );
 890     return ret;
 891 }
 892
 893
 894 /**************************************************************************
 895  *      import_text_uri_list
 896  *
 897  *  Import text/uri-list.
 898  */
 899 static HANDLE import_text_uri_list( Atom type, const void *data, size_t size )
 900 {
 901     const char *uriList = data;
 902     char *uri;
 903     WCHAR *path;
 904     WCHAR *out = NULL;
 905     int total = 0;
 906     int capacity = 4096;
 907     int start = 0;
 908     int end = 0;
 909     DROPFILES *dropFiles = NULL;
 910
 911     if (!(out = HeapAlloc(GetProcessHeap(), 0, capacity * sizeof(WCHAR)))) return 0;
 912
 913     while (end < size)
 914     {
 915         while (end < size && uriList[end] != '\r')
 916             ++end;
 917         if (end < (size - 1) && uriList[end+1] != '\n')
 918         {
 919             WARN("URI list line doesn't end in \\r\\n\n");
 920             break;
 921         }
 922
 923         uri = HeapAlloc(GetProcessHeap(), 0, end - start + 1);
 924         if (uri == NULL)
 925             break;
 926         lstrcpynA(uri, &uriList[start], end - start + 1);
 927         path = uri_to_dos(uri);
 928         TRACE("converted URI %s to DOS path %s\n", debugstr_a(uri), debugstr_w(path));
 929         HeapFree(GetProcessHeap(), 0, uri);
 930
 931         if (path)
 932         {
 933             int pathSize = strlenW(path) + 1;
 934             if (pathSize > capacity - total)
 935             {
 936                 capacity = 2*capacity + pathSize;
 937                 out = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, out, (capacity + 1)*sizeof(WCHAR));
 938                 if (out == NULL)
 939                     goto done;
 940             }
 941             memcpy(&out[total], path, pathSize * sizeof(WCHAR));
 942             total += pathSize;
 943         done:
 944             HeapFree(GetProcessHeap(), 0, path);
 945             if (out == NULL)
 946                 break;
 947         }
 948
 949         start = end + 2;
 950         end = start;
 951     }
 952     if (out && end >= size)
 953     {
 954         if ((dropFiles = GlobalAlloc( GMEM_FIXED, sizeof(DROPFILES) + (total + 1) * sizeof(WCHAR) )))
 955         {
 956             dropFiles->pFiles = sizeof(DROPFILES);
 957             dropFiles->pt.x = 0;
 958             dropFiles->pt.y = 0;
 959             dropFiles->fNC = 0;
 960             dropFiles->fWide = TRUE;
 961             out[total] = '\0';
 962             memcpy( (char*)dropFiles + dropFiles->pFiles, out, (total + 1) * sizeof(WCHAR) );
 963         }
 964     }
 965     HeapFree(GetProcessHeap(), 0, out);
 966     return dropFiles;
 967 }
 968
 969
 970 /**************************************************************************
 971  *              import_targets
 972  *
 973  *  Import TARGETS and mark the corresponding clipboard formats as available.
 974  */
 975 static HANDLE import_targets( Atom type, const void *data, size_t size )
 976 {
 977     UINT i, pos, count = size / sizeof(Atom);
 978     const Atom *properties = data;
 979     struct clipboard_format *format, **formats;
 980
 981     if (type != XA_ATOM && type != x11drv_atom(TARGETS)) return 0;
 982
 983     register_x11_formats( properties, count );
 984
 985     /* the builtin formats contain duplicates, so allocate some extra space */
 986     if (!(formats = HeapAlloc( GetProcessHeap(), 0, (count + NB_BUILTIN_FORMATS) * sizeof(*formats ))))
 987         return 0;
 988
 989     pos = 0;
 990     LIST_FOR_EACH_ENTRY( format, &format_list, struct clipboard_format, entry )
 991     {
 992         for (i = 0; i < count; i++) if (properties[i] == format->atom) break;
 993         if (i == count) continue;
 994         if (format->import && format->id)
 995         {
 996             TRACE( "property %s -> format %s\n",
 997                    debugstr_xatom( properties[i] ), debugstr_format( format->id ));
 998             SetClipboardData( format->id, 0 );
 999             formats[pos++] = format;
1000         }
1001         else TRACE( "property %s (ignoring)\n", debugstr_xatom( properties[i] ));
1002     }
1003
1004     HeapFree( GetProcessHeap(), 0, current_x11_formats );
1005     current_x11_formats = formats;
1006     nb_current_x11_formats = pos;
1007     return (HANDLE)1;
1008 }
1009
1010
1011 /**************************************************************************
1012  *              import_data
1013  *
1014  *  Generic import clipboard data routine.
1015  */
1016 static HANDLE import_data( Atom type, const void *data, size_t size )
1017 {
1018     void *ret = GlobalAlloc( GMEM_FIXED, size );
1019
1020     if (ret) memcpy( ret, data, size );
1021     return ret;
1022 }
1023
1024
1025 /**************************************************************************
1026  *              import_selection
1027  *
1028  * Import the specified format from the selection and return a global handle to the data.
1029  */
1030 static HANDLE import_selection( Display *display, Window win, Atom selection,
1031                                 struct clipboard_format *format )
1032 {
1033     unsigned char *data;
1034     unsigned long size;
1035     Atom type;
1036     HANDLE ret;
1037
1038     if (!format->import) return 0;
1039
1040     if (!convert_selection( display, win, selection, format, &type, &data, &size ))
1041     {
1042         TRACE( "failed to convert selection\n" );
1043         return 0;
1044     }
1045     ret = format->import( type, data, size );
1046     HeapFree( GetProcessHeap(), 0, data );
1047     return ret;
1048 }
1049
1050
1051 /**************************************************************************
1052  *      X11DRV_CLIPBOARD_ImportSelection
1053  *
1054  *  Import the X selection into the clipboard format registered for the given X target.
1055  */
1056 void X11DRV_CLIPBOARD_ImportSelection( Display *display, Window win, Atom selection,
1057                                        Atom *targets, UINT count,
1058                                        void (*callback)( Atom, UINT, HANDLE ))
1059 {
1060     UINT i;
1061     HANDLE handle;
1062     struct clipboard_format *format;
1063
1064     register_x11_formats( targets, count );
1065
1066     for (i = 0; i < count; i++)
1067     {
1068         if (!(format = find_x11_format( targets[i] ))) continue;
1069         if (!format->id) continue;
1070         if (!(handle = import_selection( display, win, selection, format ))) continue;
1071         callback( targets[i], format->id, handle );
1072     }
1073 }
1074
1075
1076 /**************************************************************************
1077  *              render_format
1078  */
1079 static HANDLE render_format( UINT id )
1080 {
1081     Display *display = thread_display();
1082     unsigned int i;
1083     HANDLE handle = 0;
1084
1085     if (!current_selection) return 0;
1086
1087     for (i = 0; i < nb_current_x11_formats; i++)
1088     {
1089         if (current_x11_formats[i]->id != id) continue;
1090         handle = import_selection( display, import_window, current_selection, current_x11_formats[i] );
1091         if (handle) 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, (count + NB_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                 usleep(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)
1852     {
1853         HeapFree( GetProcessHeap(), 0, data );
1854         return FALSE;
1855     }
1856
1857     if (!OpenClipboard( clipboard_hwnd )) return FALSE;
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 + sizeof(prefix) / sizeof(WCHAR)];
1936     HANDLE mutex;
1937
1938     memcpy( buffer, prefix, sizeof(prefix) );
1939     if (!GetUserObjectInformationW( GetProcessWindowStation(), UOI_NAME,
1940                                     buffer + sizeof(prefix) / sizeof(WCHAR),
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 }