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