dlls/winemac.drv/clipboard.c

   1 /*
   2  * Mac clipboard driver
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1996 Alex Korobka
   6  *           1999 Noel Borthwick
   7  *           2003 Ulrich Czekalla for CodeWeavers
   8  * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc.
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include "macdrv.h"
  28 #include "winuser.h"
  29 #include "shellapi.h"
  30 #include "shlobj.h"
  31 #include "wine/list.h"
  32 #include "wine/server.h"
  33 #include "wine/unicode.h"
  34
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(clipboard);
  37
  38
  39 /**************************************************************************
  40  *              Types
  41  **************************************************************************/
  42
  43 typedef HANDLE (*DRVIMPORTFUNC)(CFDataRef data);
  44 typedef CFDataRef (*DRVEXPORTFUNC)(HANDLE data);
  45
  46 typedef struct _WINE_CLIPFORMAT
  47 {
  48     struct list             entry;
  49     UINT                    format_id;
  50     CFStringRef             type;
  51     DRVIMPORTFUNC           import_func;
  52     DRVEXPORTFUNC           export_func;
  53     BOOL                    synthesized;
  54     struct _WINE_CLIPFORMAT *natural_format;
  55 } WINE_CLIPFORMAT;
  56
  57
  58 /**************************************************************************
  59  *              Constants
  60  **************************************************************************/
  61
  62 #define CLIPBOARD_UPDATE_DELAY 2000   /* delay between checks of the Mac pasteboard */
  63
  64
  65 /**************************************************************************
  66  *              Forward Function Declarations
  67  **************************************************************************/
  68
  69 static HANDLE import_clipboard_data(CFDataRef data);
  70 static HANDLE import_bmp_to_bitmap(CFDataRef data);
  71 static HANDLE import_bmp_to_dib(CFDataRef data);
  72 static HANDLE import_enhmetafile(CFDataRef data);
  73 static HANDLE import_html(CFDataRef data);
  74 static HANDLE import_metafilepict(CFDataRef data);
  75 static HANDLE import_nsfilenames_to_hdrop(CFDataRef data);
  76 static HANDLE import_utf8_to_text(CFDataRef data);
  77 static HANDLE import_utf8_to_unicodetext(CFDataRef data);
  78 static HANDLE import_utf16_to_unicodetext(CFDataRef data);
  79
  80 static CFDataRef export_clipboard_data(HANDLE data);
  81 static CFDataRef export_bitmap_to_bmp(HANDLE data);
  82 static CFDataRef export_dib_to_bmp(HANDLE data);
  83 static CFDataRef export_enhmetafile(HANDLE data);
  84 static CFDataRef export_hdrop_to_filenames(HANDLE data);
  85 static CFDataRef export_html(HANDLE data);
  86 static CFDataRef export_metafilepict(HANDLE data);
  87 static CFDataRef export_text_to_utf8(HANDLE data);
  88 static CFDataRef export_unicodetext_to_utf8(HANDLE data);
  89 static CFDataRef export_unicodetext_to_utf16(HANDLE data);
  90
  91
  92 /**************************************************************************
  93  *              Static Variables
  94  **************************************************************************/
  95
  96 /* Clipboard formats */
  97 static struct list format_list = LIST_INIT(format_list);
  98
  99 /*  There are two naming schemes involved and we want to have a mapping between
 100     them.  There are Win32 clipboard format names and there are Mac pasteboard
 101     types.
 102
 103     The Win32 standard clipboard formats don't have names, but they are associated
 104     with Mac pasteboard types through the following tables, which are used to
 105     initialize the format_list.  Where possible, the standard clipboard formats
 106     are mapped to predefined pasteboard type UTIs.  Otherwise, we create Wine-
 107     specific types of the form "org.winehq.builtin.<format>", where <format> is
 108     the name of the symbolic constant for the format minus "CF_" and lowercased.
 109     E.g. CF_BITMAP -> org.winehq.builtin.bitmap.
 110
 111     Win32 clipboard formats which originate in a Windows program may be registered
 112     with an arbitrary name.  We construct a Mac pasteboard type from these by
 113     prepending "org.winehq.registered." to the registered name.
 114
 115     Likewise, Mac pasteboard types which originate in other apps may have
 116     arbitrary type strings.  We ignore these.
 117
 118     Summary:
 119     Win32 clipboard format names:
 120         <none>                              standard clipboard format; maps via
 121                                             format_list to either a predefined Mac UTI
 122                                             or org.winehq.builtin.<format>.
 123         <other>                             name registered within Win32 land; maps to
 124                                             org.winehq.registered.<other>
 125     Mac pasteboard type names:
 126         org.winehq.builtin.<format ID>      representation of Win32 standard clipboard
 127                                             format for which there was no corresponding
 128                                             predefined Mac UTI; maps via format_list
 129         org.winehq.registered.<format name> representation of Win32 registered
 130                                             clipboard format name; maps to <format name>
 131         <other>                             Mac pasteboard type originating with system
 132                                             or other apps; either maps via format_list
 133                                             to a standard clipboard format or ignored
 134 */
 135
 136 static const struct
 137 {
 138     UINT          id;
 139     CFStringRef   type;
 140     DRVIMPORTFUNC import;
 141     DRVEXPORTFUNC export;
 142     BOOL          synthesized;
 143 } builtin_format_ids[] =
 144 {
 145     { CF_BITMAP,            CFSTR("org.winehq.builtin.bitmap"),             import_bmp_to_bitmap,           export_bitmap_to_bmp,       FALSE },
 146     { CF_DIBV5,             CFSTR("org.winehq.builtin.dibv5"),              import_clipboard_data,          export_clipboard_data,      FALSE },
 147     { CF_DIF,               CFSTR("org.winehq.builtin.dif"),                import_clipboard_data,          export_clipboard_data,      FALSE },
 148     { CF_ENHMETAFILE,       CFSTR("org.winehq.builtin.enhmetafile"),        import_enhmetafile,             export_enhmetafile,         FALSE },
 149     { CF_LOCALE,            CFSTR("org.winehq.builtin.locale"),             import_clipboard_data,          export_clipboard_data,      FALSE },
 150     { CF_METAFILEPICT,      CFSTR("org.winehq.builtin.metafilepict"),       import_metafilepict,            export_metafilepict,        FALSE },
 151     { CF_OEMTEXT,           CFSTR("org.winehq.builtin.oemtext"),            import_clipboard_data,          export_clipboard_data,      FALSE },
 152     { CF_PALETTE,           CFSTR("org.winehq.builtin.palette"),            import_clipboard_data,          export_clipboard_data,      FALSE },
 153     { CF_PENDATA,           CFSTR("org.winehq.builtin.pendata"),            import_clipboard_data,          export_clipboard_data,      FALSE },
 154     { CF_RIFF,              CFSTR("org.winehq.builtin.riff"),               import_clipboard_data,          export_clipboard_data,      FALSE },
 155     { CF_SYLK,              CFSTR("org.winehq.builtin.sylk"),               import_clipboard_data,          export_clipboard_data,      FALSE },
 156     { CF_TEXT,              CFSTR("org.winehq.builtin.text"),               import_clipboard_data,          export_clipboard_data,      FALSE },
 157     { CF_TIFF,              CFSTR("public.tiff"),                           import_clipboard_data,          export_clipboard_data,      FALSE },
 158     { CF_WAVE,              CFSTR("com.microsoft.waveform-audio"),          import_clipboard_data,          export_clipboard_data,      FALSE },
 159
 160     { CF_DIB,               CFSTR("org.winehq.builtin.dib"),                import_clipboard_data,          export_clipboard_data,      FALSE },
 161     { CF_DIB,               CFSTR("com.microsoft.bmp"),                     import_bmp_to_dib,              export_dib_to_bmp,          TRUE },
 162
 163     { CF_HDROP,             CFSTR("org.winehq.builtin.hdrop"),              import_clipboard_data,          export_clipboard_data,      FALSE },
 164     { CF_HDROP,             CFSTR("NSFilenamesPboardType"),                 import_nsfilenames_to_hdrop,    export_hdrop_to_filenames,  TRUE },
 165
 166     { CF_UNICODETEXT,       CFSTR("org.winehq.builtin.unicodetext"),        import_clipboard_data,          export_clipboard_data,      FALSE },
 167     { CF_UNICODETEXT,       CFSTR("public.utf16-plain-text"),               import_utf16_to_unicodetext,    export_unicodetext_to_utf16,TRUE },
 168     { CF_UNICODETEXT,       CFSTR("public.utf8-plain-text"),                import_utf8_to_unicodetext,     export_unicodetext_to_utf8, TRUE },
 169 };
 170
 171 static const WCHAR wszRichTextFormat[] = {'R','i','c','h',' ','T','e','x','t',' ','F','o','r','m','a','t',0};
 172 static const WCHAR wszGIF[] = {'G','I','F',0};
 173 static const WCHAR wszJFIF[] = {'J','F','I','F',0};
 174 static const WCHAR wszPNG[] = {'P','N','G',0};
 175 static const WCHAR wszHTMLFormat[] = {'H','T','M','L',' ','F','o','r','m','a','t',0};
 176 static const struct
 177 {
 178     LPCWSTR       name;
 179     CFStringRef   type;
 180     DRVIMPORTFUNC import;
 181     DRVEXPORTFUNC export;
 182     BOOL          synthesized;
 183 } builtin_format_names[] =
 184 {
 185     { wszRichTextFormat,    CFSTR("public.rtf"),                            import_clipboard_data,          export_clipboard_data },
 186     { wszGIF,               CFSTR("com.compuserve.gif"),                    import_clipboard_data,          export_clipboard_data },
 187     { wszJFIF,              CFSTR("public.jpeg"),                           import_clipboard_data,          export_clipboard_data },
 188     { wszPNG,               CFSTR("public.png"),                            import_clipboard_data,          export_clipboard_data },
 189     { wszHTMLFormat,        NULL,                                           import_clipboard_data,          export_clipboard_data },
 190     { wszHTMLFormat,        CFSTR("public.html"),                           import_html,                    export_html,            TRUE },
 191     { CFSTR_SHELLURLW,      CFSTR("public.url"),                            import_utf8_to_text,            export_text_to_utf8 },
 192 };
 193
 194 /* The prefix prepended to a Win32 clipboard format name to make a Mac pasteboard type. */
 195 static const CFStringRef registered_name_type_prefix = CFSTR("org.winehq.registered.");
 196
 197 static DWORD clipboard_thread_id;
 198 static HWND clipboard_hwnd;
 199 static BOOL is_clipboard_owner;
 200 static macdrv_window clipboard_cocoa_window;
 201 static ULONG64 last_clipboard_update;
 202 static DWORD last_get_seqno;
 203 static WINE_CLIPFORMAT **current_mac_formats;
 204 static unsigned int nb_current_mac_formats;
 205 static WCHAR clipboard_pipe_name[256];
 206
 207
 208 /**************************************************************************
 209  *              Internal Clipboard implementation methods
 210  **************************************************************************/
 211
 212 /*
 213  * format_list functions
 214  */
 215
 216 /**************************************************************************
 217  *              debugstr_format
 218  */
 219 const char *debugstr_format(UINT id)
 220 {
 221     WCHAR buffer[256];
 222
 223     if (GetClipboardFormatNameW(id, buffer, 256))
 224         return wine_dbg_sprintf("0x%04x %s", id, debugstr_w(buffer));
 225
 226     switch (id)
 227     {
 228 #define BUILTIN(id) case id: return #id;
 229     BUILTIN(CF_TEXT)
 230     BUILTIN(CF_BITMAP)
 231     BUILTIN(CF_METAFILEPICT)
 232     BUILTIN(CF_SYLK)
 233     BUILTIN(CF_DIF)
 234     BUILTIN(CF_TIFF)
 235     BUILTIN(CF_OEMTEXT)
 236     BUILTIN(CF_DIB)
 237     BUILTIN(CF_PALETTE)
 238     BUILTIN(CF_PENDATA)
 239     BUILTIN(CF_RIFF)
 240     BUILTIN(CF_WAVE)
 241     BUILTIN(CF_UNICODETEXT)
 242     BUILTIN(CF_ENHMETAFILE)
 243     BUILTIN(CF_HDROP)
 244     BUILTIN(CF_LOCALE)
 245     BUILTIN(CF_DIBV5)
 246     BUILTIN(CF_OWNERDISPLAY)
 247     BUILTIN(CF_DSPTEXT)
 248     BUILTIN(CF_DSPBITMAP)
 249     BUILTIN(CF_DSPMETAFILEPICT)
 250     BUILTIN(CF_DSPENHMETAFILE)
 251 #undef BUILTIN
 252     default: return wine_dbg_sprintf("0x%04x", id);
 253     }
 254 }
 255
 256
 257 /**************************************************************************
 258  *              insert_clipboard_format
 259  */
 260 static WINE_CLIPFORMAT *insert_clipboard_format(UINT id, CFStringRef type)
 261 {
 262     WINE_CLIPFORMAT *format;
 263
 264     format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format));
 265
 266     if (format == NULL)
 267     {
 268         WARN("No more memory for a new format!\n");
 269         return NULL;
 270     }
 271     format->format_id = id;
 272     format->import_func = import_clipboard_data;
 273     format->export_func = export_clipboard_data;
 274     format->synthesized = FALSE;
 275     format->natural_format = NULL;
 276
 277     if (type)
 278         format->type = CFStringCreateCopy(NULL, type);
 279     else
 280     {
 281         WCHAR buffer[256];
 282
 283         if (!GetClipboardFormatNameW(format->format_id, buffer, ARRAY_SIZE(buffer)))
 284         {
 285             WARN("failed to get name for format %s; error 0x%08x\n", debugstr_format(format->format_id), GetLastError());
 286             HeapFree(GetProcessHeap(), 0, format);
 287             return NULL;
 288         }
 289
 290         format->type = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%S"),
 291                                                 registered_name_type_prefix, (const WCHAR*)buffer);
 292     }
 293
 294     list_add_tail(&format_list, &format->entry);
 295
 296     TRACE("Registering format %s type %s\n", debugstr_format(format->format_id),
 297           debugstr_cf(format->type));
 298
 299     return format;
 300 }
 301
 302
 303 /**************************************************************************
 304  *              register_format
 305  *
 306  * Register a custom Mac clipboard format.
 307  */
 308 static WINE_CLIPFORMAT* register_format(UINT id, CFStringRef type)
 309 {
 310     WINE_CLIPFORMAT *format;
 311
 312     /* walk format chain to see if it's already registered */
 313     LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
 314         if (format->format_id == id) return format;
 315
 316     return insert_clipboard_format(id, type);
 317 }
 318
 319
 320 /**************************************************************************
 321  *              natural_format_for_format
 322  *
 323  * Find the "natural" format for this format_id (the one which isn't
 324  * synthesized from another type).
 325  */
 326 static WINE_CLIPFORMAT* natural_format_for_format(UINT format_id)
 327 {
 328     WINE_CLIPFORMAT *format;
 329
 330     LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
 331         if (format->format_id == format_id && !format->synthesized) break;
 332
 333     if (&format->entry == &format_list)
 334         format = NULL;
 335
 336     TRACE("%s -> %p/%s\n", debugstr_format(format_id), format, debugstr_cf(format ? format->type : NULL));
 337     return format;
 338 }
 339
 340
 341 /**************************************************************************
 342  *              register_builtin_formats
 343  */
 344 static void register_builtin_formats(void)
 345 {
 346     UINT i;
 347     WINE_CLIPFORMAT *format;
 348
 349     /* Register built-in formats */
 350     for (i = 0; i < ARRAY_SIZE(builtin_format_ids); i++)
 351     {
 352         if (!(format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format)))) break;
 353         format->format_id       = builtin_format_ids[i].id;
 354         format->type            = CFRetain(builtin_format_ids[i].type);
 355         format->import_func     = builtin_format_ids[i].import;
 356         format->export_func     = builtin_format_ids[i].export;
 357         format->synthesized     = builtin_format_ids[i].synthesized;
 358         format->natural_format  = NULL;
 359         list_add_tail(&format_list, &format->entry);
 360     }
 361
 362     /* Register known mappings between Windows formats and Mac types */
 363     for (i = 0; i < ARRAY_SIZE(builtin_format_names); i++)
 364     {
 365         if (!(format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format)))) break;
 366         format->format_id       = RegisterClipboardFormatW(builtin_format_names[i].name);
 367         format->import_func     = builtin_format_names[i].import;
 368         format->export_func     = builtin_format_names[i].export;
 369         format->synthesized     = builtin_format_names[i].synthesized;
 370         format->natural_format  = NULL;
 371
 372         if (builtin_format_names[i].type)
 373             format->type = CFRetain(builtin_format_names[i].type);
 374         else
 375         {
 376             format->type = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%S"),
 377                                                     registered_name_type_prefix, builtin_format_names[i].name);
 378         }
 379
 380         list_add_tail(&format_list, &format->entry);
 381     }
 382
 383     LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
 384     {
 385         if (format->synthesized)
 386             format->natural_format = natural_format_for_format(format->format_id);
 387     }
 388 }
 389
 390
 391 /**************************************************************************
 392  *              format_for_type
 393  */
 394 static WINE_CLIPFORMAT* format_for_type(CFStringRef type)
 395 {
 396     WINE_CLIPFORMAT *format;
 397
 398     TRACE("type %s\n", debugstr_cf(type));
 399
 400     if (list_empty(&format_list)) register_builtin_formats();
 401
 402     LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
 403     {
 404         if (CFEqual(format->type, type))
 405             goto done;
 406     }
 407
 408     format = NULL;
 409     if (CFStringHasPrefix(type, CFSTR("org.winehq.builtin.")))
 410     {
 411         ERR("Shouldn't happen. Built-in type %s should have matched something in format list.\n",
 412             debugstr_cf(type));
 413     }
 414     else if (CFStringHasPrefix(type, registered_name_type_prefix))
 415     {
 416         LPWSTR name;
 417         int len = CFStringGetLength(type) - CFStringGetLength(registered_name_type_prefix);
 418
 419         name = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
 420         CFStringGetCharacters(type, CFRangeMake(CFStringGetLength(registered_name_type_prefix), len),
 421                               (UniChar*)name);
 422         name[len] = 0;
 423
 424         format = register_format(RegisterClipboardFormatW(name), type);
 425         if (!format)
 426             ERR("Failed to register format for type %s name %s\n", debugstr_cf(type), debugstr_w(name));
 427
 428         HeapFree(GetProcessHeap(), 0, name);
 429     }
 430
 431 done:
 432     TRACE(" -> %p/%s\n", format, debugstr_format(format ? format->format_id : 0));
 433     return format;
 434 }
 435
 436
 437 /***********************************************************************
 438  *              bitmap_info_size
 439  *
 440  * Return the size of the bitmap info structure including color table.
 441  */
 442 static int bitmap_info_size(const BITMAPINFO *info, WORD coloruse)
 443 {
 444     unsigned int colors, size, masks = 0;
 445
 446     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 447     {
 448         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER*)info;
 449         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
 450         return sizeof(BITMAPCOREHEADER) + colors *
 451              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
 452     }
 453     else  /* assume BITMAPINFOHEADER */
 454     {
 455         colors = min(info->bmiHeader.biClrUsed, 256);
 456         if (!colors && (info->bmiHeader.biBitCount <= 8))
 457             colors = 1 << info->bmiHeader.biBitCount;
 458         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
 459         size = max(info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD));
 460         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
 461     }
 462 }
 463
 464
 465 /***********************************************************************
 466  *              create_dib_from_bitmap
 467  *
 468  * Allocates a packed DIB and copies the bitmap data into it.
 469  */
 470 static HGLOBAL create_dib_from_bitmap(HBITMAP bitmap)
 471 {
 472     HANDLE ret = 0;
 473     BITMAPINFOHEADER header;
 474     HDC hdc = GetDC(0);
 475     DWORD header_size;
 476     BITMAPINFO *bmi;
 477
 478     memset(&header, 0, sizeof(header));
 479     header.biSize = sizeof(header);
 480     if (!GetDIBits(hdc, bitmap, 0, 0, NULL, (BITMAPINFO *)&header, DIB_RGB_COLORS)) goto done;
 481
 482     header_size = bitmap_info_size((BITMAPINFO *)&header, DIB_RGB_COLORS);
 483     if (!(ret = GlobalAlloc(GMEM_FIXED, header_size + header.biSizeImage))) goto done;
 484     bmi = (BITMAPINFO *)ret;
 485     memset(bmi, 0, header_size);
 486     memcpy(bmi, &header, header.biSize);
 487     GetDIBits(hdc, bitmap, 0, abs(header.biHeight), (char *)bmi + header_size, bmi, DIB_RGB_COLORS);
 488
 489 done:
 490     ReleaseDC(0, hdc);
 491     return ret;
 492 }
 493
 494
 495 /**************************************************************************
 496  *              create_bitmap_from_dib
 497  *
 498  *  Given a packed DIB, creates a bitmap object from it.
 499  */
 500 static HANDLE create_bitmap_from_dib(HANDLE dib)
 501 {
 502     HANDLE ret = 0;
 503     BITMAPINFO *bmi;
 504
 505     if (dib && (bmi = GlobalLock(dib)))
 506     {
 507         HDC hdc;
 508         unsigned int offset;
 509
 510         hdc = GetDC(NULL);
 511
 512         offset = bitmap_info_size(bmi, DIB_RGB_COLORS);
 513
 514         ret = CreateDIBitmap(hdc, &bmi->bmiHeader, CBM_INIT, (LPBYTE)bmi + offset,
 515                              bmi, DIB_RGB_COLORS);
 516
 517         GlobalUnlock(dib);
 518         ReleaseDC(NULL, hdc);
 519     }
 520
 521     return ret;
 522 }
 523
 524
 525 /**************************************************************************
 526  *              get_html_description_field
 527  *
 528  *  Find the value of a field in an HTML Format description.
 529  */
 530 static const char* get_html_description_field(const char* data, const char* keyword)
 531 {
 532     const char* pos = data;
 533
 534     while (pos && *pos && *pos != '<')
 535     {
 536         if (memcmp(pos, keyword, strlen(keyword)) == 0)
 537             return pos + strlen(keyword);
 538
 539         pos = strchr(pos, '\n');
 540         if (pos) pos++;
 541     }
 542
 543     return NULL;
 544 }
 545
 546
 547 /**************************************************************************
 548  *              import_clipboard_data
 549  *
 550  *  Generic import clipboard data routine.
 551  */
 552 static HANDLE import_clipboard_data(CFDataRef data)
 553 {
 554     HANDLE data_handle = NULL;
 555
 556     size_t len = CFDataGetLength(data);
 557     if (len)
 558     {
 559         LPVOID p;
 560
 561         /* Turn on the DDESHARE flag to enable shared 32 bit memory */
 562         data_handle = GlobalAlloc(GMEM_FIXED, len);
 563         if (!data_handle)
 564             return NULL;
 565
 566         if ((p = GlobalLock(data_handle)))
 567         {
 568             memcpy(p, CFDataGetBytePtr(data), len);
 569             GlobalUnlock(data_handle);
 570         }
 571         else
 572         {
 573             GlobalFree(data_handle);
 574             data_handle = NULL;
 575         }
 576     }
 577
 578     return data_handle;
 579 }
 580
 581
 582 /**************************************************************************
 583  *              import_bmp_to_bitmap
 584  *
 585  *  Import BMP data, converting to CF_BITMAP format.
 586  */
 587 static HANDLE import_bmp_to_bitmap(CFDataRef data)
 588 {
 589     HANDLE ret;
 590     HANDLE dib = import_bmp_to_dib(data);
 591
 592     ret = create_bitmap_from_dib(dib);
 593
 594     GlobalFree(dib);
 595     return ret;
 596 }
 597
 598
 599 /**************************************************************************
 600  *              import_bmp_to_dib
 601  *
 602  *  Import BMP data, converting to CF_DIB or CF_DIBV5 format.  This just
 603  *  entails stripping the BMP file format header.
 604  */
 605 static HANDLE import_bmp_to_dib(CFDataRef data)
 606 {
 607     HANDLE ret = 0;
 608     BITMAPFILEHEADER *bfh = (BITMAPFILEHEADER*)CFDataGetBytePtr(data);
 609     CFIndex len = CFDataGetLength(data);
 610
 611     if (len >= sizeof(*bfh) + sizeof(BITMAPCOREHEADER) &&
 612         bfh->bfType == 0x4d42 /* "BM" */)
 613     {
 614         BITMAPINFO *bmi = (BITMAPINFO*)(bfh + 1);
 615         BYTE* p;
 616
 617         len -= sizeof(*bfh);
 618         ret = GlobalAlloc(GMEM_FIXED, len);
 619         if (!ret || !(p = GlobalLock(ret)))
 620         {
 621             GlobalFree(ret);
 622             return 0;
 623         }
 624
 625         memcpy(p, bmi, len);
 626         GlobalUnlock(ret);
 627     }
 628
 629     return ret;
 630 }
 631
 632
 633 /**************************************************************************
 634  *              import_enhmetafile
 635  *
 636  *  Import enhanced metafile data, converting it to CF_ENHMETAFILE.
 637  */
 638 static HANDLE import_enhmetafile(CFDataRef data)
 639 {
 640     HANDLE ret = 0;
 641     CFIndex len = CFDataGetLength(data);
 642
 643     TRACE("data %s\n", debugstr_cf(data));
 644
 645     if (len)
 646         ret = SetEnhMetaFileBits(len, (const BYTE*)CFDataGetBytePtr(data));
 647
 648     return ret;
 649 }
 650
 651
 652 /**************************************************************************
 653  *              import_html
 654  *
 655  *  Import HTML data.
 656  */
 657 static HANDLE import_html(CFDataRef data)
 658 {
 659     static const char header[] =
 660         "Version:0.9\n"
 661         "StartHTML:0000000100\n"
 662         "EndHTML:%010lu\n"
 663         "StartFragment:%010lu\n"
 664         "EndFragment:%010lu\n"
 665         "<!--StartFragment-->";
 666     static const char trailer[] = "\n<!--EndFragment-->";
 667     HANDLE ret;
 668     SIZE_T len, total;
 669     size_t size = CFDataGetLength(data);
 670
 671     len = strlen(header) + 12;  /* 3 * 4 extra chars for %010lu */
 672     total = len + size + sizeof(trailer);
 673     if ((ret = GlobalAlloc(GMEM_FIXED, total)))
 674     {
 675         char *p = ret;
 676         p += sprintf(p, header, total - 1, len, len + size + 1 /* include the final \n in the data */);
 677         CFDataGetBytes(data, CFRangeMake(0, size), (UInt8*)p);
 678         strcpy(p + size, trailer);
 679         TRACE("returning %s\n", debugstr_a(ret));
 680     }
 681     return ret;
 682 }
 683
 684
 685 /**************************************************************************
 686  *              import_metafilepict
 687  *
 688  *  Import metafile picture data, converting it to CF_METAFILEPICT.
 689  */
 690 static HANDLE import_metafilepict(CFDataRef data)
 691 {
 692     HANDLE ret = 0;
 693     CFIndex len = CFDataGetLength(data);
 694     METAFILEPICT *mfp;
 695
 696     TRACE("data %s\n", debugstr_cf(data));
 697
 698     if (len >= sizeof(*mfp) && (ret = GlobalAlloc(GMEM_FIXED, sizeof(*mfp))))
 699     {
 700         const BYTE *bytes = (const BYTE*)CFDataGetBytePtr(data);
 701
 702         mfp = GlobalLock(ret);
 703         memcpy(mfp, bytes, sizeof(*mfp));
 704         mfp->hMF = SetMetaFileBitsEx(len - sizeof(*mfp), bytes + sizeof(*mfp));
 705         GlobalUnlock(ret);
 706     }
 707
 708     return ret;
 709 }
 710
 711
 712 /**************************************************************************
 713  *              import_nsfilenames_to_hdrop
 714  *
 715  *  Import NSFilenamesPboardType data, converting the property-list-
 716  *  serialized array of path strings to CF_HDROP.
 717  */
 718 static HANDLE import_nsfilenames_to_hdrop(CFDataRef data)
 719 {
 720     HDROP hdrop = NULL;
 721     CFArrayRef names;
 722     CFIndex count, i;
 723     size_t len;
 724     char *buffer = NULL;
 725     WCHAR **paths = NULL;
 726     DROPFILES* dropfiles;
 727     UniChar* p;
 728
 729     TRACE("data %s\n", debugstr_cf(data));
 730
 731     names = (CFArrayRef)CFPropertyListCreateWithData(NULL, data, kCFPropertyListImmutable,
 732                                                      NULL, NULL);
 733     if (!names || CFGetTypeID(names) != CFArrayGetTypeID())
 734     {
 735         WARN("failed to interpret data as a CFArray\n");
 736         goto done;
 737     }
 738
 739     count = CFArrayGetCount(names);
 740
 741     len = 0;
 742     for (i = 0; i < count; i++)
 743     {
 744         CFIndex this_len;
 745         CFStringRef name = (CFStringRef)CFArrayGetValueAtIndex(names, i);
 746         TRACE("    %s\n", debugstr_cf(name));
 747         if (CFGetTypeID(name) != CFStringGetTypeID())
 748         {
 749             WARN("non-string in array\n");
 750             goto done;
 751         }
 752
 753         this_len = CFStringGetMaximumSizeOfFileSystemRepresentation(name);
 754         if (this_len > len)
 755             len = this_len;
 756     }
 757
 758     buffer = HeapAlloc(GetProcessHeap(), 0, len);
 759     if (!buffer)
 760     {
 761         WARN("failed to allocate buffer for file-system representations\n");
 762         goto done;
 763     }
 764
 765     paths = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(paths[0]));
 766     if (!paths)
 767     {
 768         WARN("failed to allocate array of DOS paths\n");
 769         goto done;
 770     }
 771
 772     for (i = 0; i < count; i++)
 773     {
 774         CFStringRef name = (CFStringRef)CFArrayGetValueAtIndex(names, i);
 775         if (!CFStringGetFileSystemRepresentation(name, buffer, len))
 776         {
 777             WARN("failed to get file-system representation for %s\n", debugstr_cf(name));
 778             goto done;
 779         }
 780         paths[i] = wine_get_dos_file_name(buffer);
 781         if (!paths[i])
 782         {
 783             WARN("failed to get DOS path for %s\n", debugstr_a(buffer));
 784             goto done;
 785         }
 786     }
 787
 788     len = 1; /* for the terminating null */
 789     for (i = 0; i < count; i++)
 790         len += strlenW(paths[i]) + 1;
 791
 792     hdrop = GlobalAlloc(GMEM_FIXED, sizeof(*dropfiles) + len * sizeof(WCHAR));
 793     if (!hdrop || !(dropfiles = GlobalLock(hdrop)))
 794     {
 795         WARN("failed to allocate HDROP\n");
 796         GlobalFree(hdrop);
 797         hdrop = NULL;
 798         goto done;
 799     }
 800
 801     dropfiles->pFiles   = sizeof(*dropfiles);
 802     dropfiles->pt.x     = 0;
 803     dropfiles->pt.y     = 0;
 804     dropfiles->fNC      = FALSE;
 805     dropfiles->fWide    = TRUE;
 806
 807     p = (WCHAR*)(dropfiles + 1);
 808     for (i = 0; i < count; i++)
 809     {
 810         strcpyW(p, paths[i]);
 811         p += strlenW(p) + 1;
 812     }
 813     *p = 0;
 814
 815     GlobalUnlock(hdrop);
 816
 817 done:
 818     if (paths)
 819     {
 820         for (i = 0; i < count; i++)
 821             HeapFree(GetProcessHeap(), 0, paths[i]);
 822         HeapFree(GetProcessHeap(), 0, paths);
 823     }
 824     HeapFree(GetProcessHeap(), 0, buffer);
 825     if (names) CFRelease(names);
 826     return hdrop;
 827 }
 828
 829
 830 /**************************************************************************
 831  *              import_utf8_to_text
 832  *
 833  *  Import a UTF-8 string, converting the string to CF_TEXT.
 834  */
 835 static HANDLE import_utf8_to_text(CFDataRef data)
 836 {
 837     HANDLE ret = NULL;
 838     HANDLE unicode_handle = import_utf8_to_unicodetext(data);
 839     LPWSTR unicode_string = GlobalLock(unicode_handle);
 840
 841     if (unicode_string)
 842     {
 843         int unicode_len;
 844         HANDLE handle;
 845         char *p;
 846         INT len;
 847
 848         unicode_len = GlobalSize(unicode_handle) / sizeof(WCHAR);
 849
 850         len = WideCharToMultiByte(CP_ACP, 0, unicode_string, unicode_len, NULL, 0, NULL, NULL);
 851         if (!unicode_len || unicode_string[unicode_len - 1]) len += 1;
 852         handle = GlobalAlloc(GMEM_FIXED, len);
 853
 854         if (handle && (p = GlobalLock(handle)))
 855         {
 856             WideCharToMultiByte(CP_ACP, 0, unicode_string, unicode_len, p, len, NULL, NULL);
 857             p[len - 1] = 0;
 858             GlobalUnlock(handle);
 859             ret = handle;
 860         }
 861         GlobalUnlock(unicode_handle);
 862     }
 863
 864     GlobalFree(unicode_handle);
 865     return ret;
 866 }
 867
 868
 869 /**************************************************************************
 870  *              import_utf8_to_unicodetext
 871  *
 872  *  Import a UTF-8 string, converting the string to CF_UNICODETEXT.
 873  */
 874 static HANDLE import_utf8_to_unicodetext(CFDataRef data)
 875 {
 876     const BYTE *src;
 877     unsigned long src_len;
 878     unsigned long new_lines = 0;
 879     LPSTR dst;
 880     unsigned long i, j;
 881     HANDLE unicode_handle = NULL;
 882
 883     src = CFDataGetBytePtr(data);
 884     src_len = CFDataGetLength(data);
 885     for (i = 0; i < src_len; i++)
 886     {
 887         if (src[i] == '\n')
 888             new_lines++;
 889     }
 890
 891     if ((dst = HeapAlloc(GetProcessHeap(), 0, src_len + new_lines + 1)))
 892     {
 893         UINT count;
 894
 895         for (i = 0, j = 0; i < src_len; i++)
 896         {
 897             if (src[i] == '\n')
 898                 dst[j++] = '\r';
 899
 900             dst[j++] = src[i];
 901         }
 902         dst[j] = 0;
 903
 904         count = MultiByteToWideChar(CP_UTF8, 0, dst, -1, NULL, 0);
 905         unicode_handle = GlobalAlloc(GMEM_FIXED, count * sizeof(WCHAR));
 906
 907         if (unicode_handle)
 908         {
 909             WCHAR *textW = GlobalLock(unicode_handle);
 910             MultiByteToWideChar(CP_UTF8, 0, dst, -1, textW, count);
 911             GlobalUnlock(unicode_handle);
 912         }
 913
 914         HeapFree(GetProcessHeap(), 0, dst);
 915     }
 916
 917     return unicode_handle;
 918 }
 919
 920
 921 /**************************************************************************
 922  *              import_utf16_to_unicodetext
 923  *
 924  *  Import a UTF-8 string, converting the string to CF_UNICODETEXT.
 925  */
 926 static HANDLE import_utf16_to_unicodetext(CFDataRef data)
 927 {
 928     const WCHAR *src;
 929     unsigned long src_len;
 930     unsigned long new_lines = 0;
 931     LPWSTR dst;
 932     unsigned long i, j;
 933     HANDLE unicode_handle;
 934
 935     src = (const WCHAR *)CFDataGetBytePtr(data);
 936     src_len = CFDataGetLength(data) / sizeof(WCHAR);
 937     for (i = 0; i < src_len; i++)
 938     {
 939         if (src[i] == '\n')
 940             new_lines++;
 941         else if (src[i] == '\r' && (i + 1 >= src_len || src[i + 1] != '\n'))
 942             new_lines++;
 943     }
 944
 945     if ((unicode_handle = GlobalAlloc(GMEM_FIXED, (src_len + new_lines + 1) * sizeof(WCHAR))))
 946     {
 947         dst = GlobalLock(unicode_handle);
 948
 949         for (i = 0, j = 0; i < src_len; i++)
 950         {
 951             if (src[i] == '\n')
 952                 dst[j++] = '\r';
 953
 954             dst[j++] = src[i];
 955
 956             if (src[i] == '\r' && (i + 1 >= src_len || src[i + 1] != '\n'))
 957                 dst[j++] = '\n';
 958         }
 959         dst[j] = 0;
 960
 961         GlobalUnlock(unicode_handle);
 962     }
 963
 964     return unicode_handle;
 965 }
 966
 967
 968 /**************************************************************************
 969  *              export_clipboard_data
 970  *
 971  *  Generic export clipboard data routine.
 972  */
 973 static CFDataRef export_clipboard_data(HANDLE data)
 974 {
 975     CFDataRef ret;
 976     UINT len;
 977     LPVOID src;
 978
 979     len = GlobalSize(data);
 980     src = GlobalLock(data);
 981     if (!src) return NULL;
 982
 983     ret = CFDataCreate(NULL, src, len);
 984     GlobalUnlock(data);
 985
 986     return ret;
 987 }
 988
 989
 990 /**************************************************************************
 991  *              export_bitmap_to_bmp
 992  *
 993  *  Export CF_BITMAP to BMP file format.
 994  */
 995 static CFDataRef export_bitmap_to_bmp(HANDLE data)
 996 {
 997     CFDataRef ret = NULL;
 998     HGLOBAL dib;
 999
1000     dib = create_dib_from_bitmap(data);
1001     if (dib)
1002     {
1003         ret = export_dib_to_bmp(dib);
1004         GlobalFree(dib);
1005     }
1006
1007     return ret;
1008 }
1009
1010
1011 /**************************************************************************
1012  *              export_dib_to_bmp
1013  *
1014  *  Export CF_DIB or CF_DIBV5 to BMP file format.  This just entails
1015  *  prepending a BMP file format header to the data.
1016  */
1017 static CFDataRef export_dib_to_bmp(HANDLE data)
1018 {
1019     CFMutableDataRef ret = NULL;
1020     BYTE *dibdata;
1021     CFIndex len;
1022     BITMAPFILEHEADER bfh;
1023
1024     dibdata = GlobalLock(data);
1025     if (!dibdata)
1026         return NULL;
1027
1028     len = sizeof(bfh) + GlobalSize(data);
1029     ret = CFDataCreateMutable(NULL, len);
1030     if (ret)
1031     {
1032         bfh.bfType = 0x4d42; /* "BM" */
1033         bfh.bfSize = len;
1034         bfh.bfReserved1 = 0;
1035         bfh.bfReserved2 = 0;
1036         bfh.bfOffBits = sizeof(bfh) + bitmap_info_size((BITMAPINFO*)dibdata, DIB_RGB_COLORS);
1037         CFDataAppendBytes(ret, (UInt8*)&bfh, sizeof(bfh));
1038
1039         /* rest of bitmap is the same as the packed dib */
1040         CFDataAppendBytes(ret, (UInt8*)dibdata, len - sizeof(bfh));
1041     }
1042
1043     GlobalUnlock(data);
1044
1045     return ret;
1046 }
1047
1048
1049 /**************************************************************************
1050  *              export_enhmetafile
1051  *
1052  *  Export an enhanced metafile to data.
1053  */
1054 static CFDataRef export_enhmetafile(HANDLE data)
1055 {
1056     CFMutableDataRef ret = NULL;
1057     unsigned int size = GetEnhMetaFileBits(data, 0, NULL);
1058
1059     TRACE("data %p\n", data);
1060
1061     ret = CFDataCreateMutable(NULL, size);
1062     if (ret)
1063     {
1064         CFDataSetLength(ret, size);
1065         GetEnhMetaFileBits(data, size, (BYTE*)CFDataGetMutableBytePtr(ret));
1066     }
1067
1068     TRACE(" -> %s\n", debugstr_cf(ret));
1069     return ret;
1070 }
1071
1072
1073 /**************************************************************************
1074  *              export_hdrop_to_filenames
1075  *
1076  *  Export CF_HDROP to NSFilenamesPboardType data, which is a CFArray of
1077  *  CFStrings (holding Unix paths) which is serialized as a property list.
1078  */
1079 static CFDataRef export_hdrop_to_filenames(HANDLE data)
1080 {
1081     CFDataRef ret = NULL;
1082     DROPFILES *dropfiles;
1083     CFMutableArrayRef filenames = NULL;
1084     void *p;
1085     WCHAR *buffer = NULL;
1086     size_t buffer_len = 0;
1087
1088     TRACE("data %p\n", data);
1089
1090     if (!(dropfiles = GlobalLock(data)))
1091     {
1092         WARN("failed to lock data %p\n", data);
1093         goto done;
1094     }
1095
1096     filenames = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1097     if (!filenames)
1098     {
1099         WARN("failed to create filenames array\n");
1100         goto done;
1101     }
1102
1103     p = (char*)dropfiles + dropfiles->pFiles;
1104     while (dropfiles->fWide ? *(WCHAR*)p : *(char*)p)
1105     {
1106         char *unixname;
1107         CFStringRef filename;
1108
1109         TRACE("    %s\n", dropfiles->fWide ? debugstr_w(p) : debugstr_a(p));
1110
1111         if (dropfiles->fWide)
1112             unixname = wine_get_unix_file_name(p);
1113         else
1114         {
1115             int len = MultiByteToWideChar(CP_ACP, 0, p, -1, NULL, 0);
1116             if (len)
1117             {
1118                 if (len > buffer_len)
1119                 {
1120                     HeapFree(GetProcessHeap(), 0, buffer);
1121                     buffer_len = len * 2;
1122                     buffer = HeapAlloc(GetProcessHeap(), 0, buffer_len * sizeof(*buffer));
1123                 }
1124
1125                 MultiByteToWideChar(CP_ACP, 0, p, -1, buffer, buffer_len);
1126                 unixname = wine_get_unix_file_name(buffer);
1127             }
1128             else
1129                 unixname = NULL;
1130         }
1131         if (!unixname)
1132         {
1133             WARN("failed to convert DOS path to Unix: %s\n",
1134                  dropfiles->fWide ? debugstr_w(p) : debugstr_a(p));
1135             goto done;
1136         }
1137
1138         if (dropfiles->fWide)
1139             p = (WCHAR*)p + strlenW(p) + 1;
1140         else
1141             p = (char*)p + strlen(p) + 1;
1142
1143         filename = CFStringCreateWithFileSystemRepresentation(NULL, unixname);
1144         HeapFree(GetProcessHeap(), 0, unixname);
1145         if (!filename)
1146         {
1147             WARN("failed to create CFString from Unix path %s\n", debugstr_a(unixname));
1148             goto done;
1149         }
1150
1151         CFArrayAppendValue(filenames, filename);
1152         CFRelease(filename);
1153     }
1154
1155     ret = CFPropertyListCreateData(NULL, filenames, kCFPropertyListXMLFormat_v1_0, 0, NULL);
1156
1157 done:
1158     HeapFree(GetProcessHeap(), 0, buffer);
1159     GlobalUnlock(data);
1160     if (filenames) CFRelease(filenames);
1161     TRACE(" -> %s\n", debugstr_cf(ret));
1162     return ret;
1163 }
1164
1165
1166 /**************************************************************************
1167  *              export_html
1168  *
1169  *  Export HTML Format to public.html data.
1170  *
1171  * FIXME: We should attempt to add an <a base> tag and convert windows paths.
1172  */
1173 static CFDataRef export_html(HANDLE handle)
1174 {
1175     CFDataRef ret;
1176     const char *data, *field_value;
1177     int fragmentstart, fragmentend;
1178
1179     data = GlobalLock(handle);
1180
1181     /* read the important fields */
1182     field_value = get_html_description_field(data, "StartFragment:");
1183     if (!field_value)
1184     {
1185         ERR("Couldn't find StartFragment value\n");
1186         goto failed;
1187     }
1188     fragmentstart = atoi(field_value);
1189
1190     field_value = get_html_description_field(data, "EndFragment:");
1191     if (!field_value)
1192     {
1193         ERR("Couldn't find EndFragment value\n");
1194         goto failed;
1195     }
1196     fragmentend = atoi(field_value);
1197
1198     /* export only the fragment */
1199     ret = CFDataCreate(NULL, (const UInt8*)&data[fragmentstart], fragmentend - fragmentstart);
1200     GlobalUnlock(handle);
1201     return ret;
1202
1203 failed:
1204     GlobalUnlock(handle);
1205     return NULL;
1206 }
1207
1208
1209 /**************************************************************************
1210  *              export_metafilepict
1211  *
1212  *  Export a metafile to data.
1213  */
1214 static CFDataRef export_metafilepict(HANDLE data)
1215 {
1216     CFMutableDataRef ret = NULL;
1217     METAFILEPICT *mfp = GlobalLock(data);
1218     unsigned int size = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
1219
1220     TRACE("data %p\n", data);
1221
1222     ret = CFDataCreateMutable(NULL, sizeof(*mfp) + size);
1223     if (ret)
1224     {
1225         CFDataAppendBytes(ret, (UInt8*)mfp, sizeof(*mfp));
1226         CFDataIncreaseLength(ret, size);
1227         GetMetaFileBitsEx(mfp->hMF, size, (BYTE*)CFDataGetMutableBytePtr(ret) + sizeof(*mfp));
1228     }
1229
1230     GlobalUnlock(data);
1231     TRACE(" -> %s\n", debugstr_cf(ret));
1232     return ret;
1233 }
1234
1235
1236 /**************************************************************************
1237  *              export_text_to_utf8
1238  *
1239  *  Export CF_TEXT to UTF-8.
1240  */
1241 static CFDataRef export_text_to_utf8(HANDLE data)
1242 {
1243     CFDataRef ret = NULL;
1244     const char* str;
1245
1246     if ((str = GlobalLock(data)))
1247     {
1248         int str_len = GlobalSize(data);
1249         int wstr_len;
1250         WCHAR *wstr;
1251         HANDLE unicode;
1252         char *p;
1253
1254         wstr_len = MultiByteToWideChar(CP_ACP, 0, str, str_len, NULL, 0);
1255         if (!str_len || str[str_len - 1]) wstr_len += 1;
1256         wstr = HeapAlloc(GetProcessHeap(), 0, wstr_len * sizeof(WCHAR));
1257         MultiByteToWideChar(CP_ACP, 0, str, str_len, wstr, wstr_len);
1258         wstr[wstr_len - 1] = 0;
1259
1260         unicode = GlobalAlloc(GMEM_FIXED, wstr_len * sizeof(WCHAR));
1261         if (unicode && (p = GlobalLock(unicode)))
1262         {
1263             memcpy(p, wstr, wstr_len * sizeof(WCHAR));
1264             GlobalUnlock(unicode);
1265         }
1266
1267         ret = export_unicodetext_to_utf8(unicode);
1268
1269         GlobalFree(unicode);
1270         GlobalUnlock(data);
1271     }
1272
1273     return ret;
1274 }
1275
1276
1277 /**************************************************************************
1278  *              export_unicodetext_to_utf8
1279  *
1280  *  Export CF_UNICODETEXT to UTF-8.
1281  */
1282 static CFDataRef export_unicodetext_to_utf8(HANDLE data)
1283 {
1284     CFMutableDataRef ret;
1285     LPVOID src;
1286     INT dst_len;
1287
1288     src = GlobalLock(data);
1289     if (!src) return NULL;
1290
1291     dst_len = WideCharToMultiByte(CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL);
1292     if (dst_len) dst_len--; /* Leave off null terminator. */
1293     ret = CFDataCreateMutable(NULL, dst_len);
1294     if (ret)
1295     {
1296         LPSTR dst;
1297         int i, j;
1298
1299         CFDataSetLength(ret, dst_len);
1300         dst = (LPSTR)CFDataGetMutableBytePtr(ret);
1301         WideCharToMultiByte(CP_UTF8, 0, src, -1, dst, dst_len, NULL, NULL);
1302
1303         /* Remove carriage returns */
1304         for (i = 0, j = 0; i < dst_len; i++)
1305         {
1306             if (dst[i] == '\r' &&
1307                 (i + 1 >= dst_len || dst[i + 1] == '\n' || dst[i + 1] == '\0'))
1308                 continue;
1309             dst[j++] = dst[i];
1310         }
1311         CFDataSetLength(ret, j);
1312     }
1313     GlobalUnlock(data);
1314
1315     return ret;
1316 }
1317
1318
1319 /**************************************************************************
1320  *              export_unicodetext_to_utf16
1321  *
1322  *  Export CF_UNICODETEXT to UTF-16.
1323  */
1324 static CFDataRef export_unicodetext_to_utf16(HANDLE data)
1325 {
1326     CFMutableDataRef ret;
1327     const WCHAR *src;
1328     INT src_len;
1329
1330     src = GlobalLock(data);
1331     if (!src) return NULL;
1332
1333     src_len = GlobalSize(data) / sizeof(WCHAR);
1334     if (src_len) src_len--; /* Leave off null terminator. */
1335     ret = CFDataCreateMutable(NULL, src_len * sizeof(WCHAR));
1336     if (ret)
1337     {
1338         LPWSTR dst;
1339         int i, j;
1340
1341         CFDataSetLength(ret, src_len * sizeof(WCHAR));
1342         dst = (LPWSTR)CFDataGetMutableBytePtr(ret);
1343
1344         /* Remove carriage returns */
1345         for (i = 0, j = 0; i < src_len; i++)
1346         {
1347             if (src[i] == '\r' &&
1348                 (i + 1 >= src_len || src[i + 1] == '\n' || src[i + 1] == '\0'))
1349                 continue;
1350             dst[j++] = src[i];
1351         }
1352         CFDataSetLength(ret, j * sizeof(WCHAR));
1353     }
1354     GlobalUnlock(data);
1355
1356     return ret;
1357 }
1358
1359
1360 /**************************************************************************
1361  *              macdrv_get_pasteboard_data
1362  */
1363 HANDLE macdrv_get_pasteboard_data(CFTypeRef pasteboard, UINT desired_format)
1364 {
1365     CFArrayRef types;
1366     CFIndex count;
1367     CFIndex i;
1368     CFStringRef type, best_type;
1369     WINE_CLIPFORMAT* best_format = NULL;
1370     HANDLE data = NULL;
1371
1372     TRACE("pasteboard %p, desired_format %s\n", pasteboard, debugstr_format(desired_format));
1373
1374     types = macdrv_copy_pasteboard_types(pasteboard);
1375     if (!types)
1376     {
1377         WARN("Failed to copy pasteboard types\n");
1378         return NULL;
1379     }
1380
1381     count = CFArrayGetCount(types);
1382     TRACE("got %ld types\n", count);
1383
1384     for (i = 0; (!best_format || best_format->synthesized) && i < count; i++)
1385     {
1386         WINE_CLIPFORMAT* format;
1387
1388         type = CFArrayGetValueAtIndex(types, i);
1389
1390         if ((format = format_for_type(type)))
1391         {
1392             TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1393
1394             if (format->format_id == desired_format)
1395             {
1396                 /* The best format is the matching one which is not synthesized.  Failing that,
1397                    the best format is the first matching synthesized format. */
1398                 if (!format->synthesized || !best_format)
1399                 {
1400                     best_type = type;
1401                     best_format = format;
1402                 }
1403             }
1404         }
1405     }
1406
1407     if (best_format)
1408     {
1409         CFDataRef pasteboard_data = macdrv_copy_pasteboard_data(pasteboard, best_type);
1410
1411         TRACE("got pasteboard data for type %s: %s\n", debugstr_cf(best_type), debugstr_cf(pasteboard_data));
1412
1413         if (pasteboard_data)
1414         {
1415             data = best_format->import_func(pasteboard_data);
1416             CFRelease(pasteboard_data);
1417         }
1418     }
1419
1420     CFRelease(types);
1421     TRACE(" -> %p\n", data);
1422     return data;
1423 }
1424
1425
1426 /**************************************************************************
1427  *              macdrv_pasteboard_has_format
1428  */
1429 BOOL macdrv_pasteboard_has_format(CFTypeRef pasteboard, UINT desired_format)
1430 {
1431     CFArrayRef types;
1432     int count;
1433     UINT i;
1434     BOOL found = FALSE;
1435
1436     TRACE("pasteboard %p, desired_format %s\n", pasteboard, debugstr_format(desired_format));
1437
1438     types = macdrv_copy_pasteboard_types(pasteboard);
1439     if (!types)
1440     {
1441         WARN("Failed to copy pasteboard types\n");
1442         return FALSE;
1443     }
1444
1445     count = CFArrayGetCount(types);
1446     TRACE("got %d types\n", count);
1447
1448     for (i = 0; i < count; i++)
1449     {
1450         CFStringRef type = CFArrayGetValueAtIndex(types, i);
1451         WINE_CLIPFORMAT* format = format_for_type(type);
1452
1453         if (format)
1454         {
1455             TRACE("for type %s got format %s\n", debugstr_cf(type), debugstr_format(format->format_id));
1456
1457             if (format->format_id == desired_format)
1458             {
1459                 found = TRUE;
1460                 break;
1461             }
1462         }
1463     }
1464
1465     CFRelease(types);
1466     TRACE(" -> %d\n", found);
1467     return found;
1468 }
1469
1470
1471 /**************************************************************************
1472  *              get_formats_for_pasteboard_types
1473  */
1474 static WINE_CLIPFORMAT** get_formats_for_pasteboard_types(CFArrayRef types, UINT *num_formats)
1475 {
1476     CFIndex count, i;
1477     CFMutableSetRef seen_formats;
1478     WINE_CLIPFORMAT** formats;
1479     UINT pos;
1480
1481     count = CFArrayGetCount(types);
1482     TRACE("got %ld types\n", count);
1483
1484     if (!count)
1485         return NULL;
1486
1487     seen_formats = CFSetCreateMutable(NULL, count, NULL);
1488     if (!seen_formats)
1489     {
1490         WARN("Failed to allocate seen formats set\n");
1491         return NULL;
1492     }
1493
1494     formats = HeapAlloc(GetProcessHeap(), 0, count * sizeof(*formats));
1495     if (!formats)
1496     {
1497         WARN("Failed to allocate formats array\n");
1498         CFRelease(seen_formats);
1499         return NULL;
1500     }
1501
1502     pos = 0;
1503     for (i = 0; i < count; i++)
1504     {
1505         CFStringRef type = CFArrayGetValueAtIndex(types, i);
1506         WINE_CLIPFORMAT* format = format_for_type(type);
1507
1508         if (!format)
1509         {
1510             TRACE("ignoring type %s\n", debugstr_cf(type));
1511             continue;
1512         }
1513
1514         if (!format->synthesized)
1515         {
1516             TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1517             CFSetAddValue(seen_formats, (void*)format->format_id);
1518             formats[pos++] = format;
1519         }
1520         else if (format->natural_format &&
1521                  CFArrayContainsValue(types, CFRangeMake(0, count), format->natural_format->type))
1522         {
1523             TRACE("for type %s deferring synthesized formats because type %s is also present\n",
1524                   debugstr_cf(type), debugstr_cf(format->natural_format->type));
1525         }
1526         else if (CFSetContainsValue(seen_formats, (void*)format->format_id))
1527         {
1528             TRACE("for type %s got duplicate synthesized format %p/%s; skipping\n", debugstr_cf(type), format,
1529                   debugstr_format(format->format_id));
1530         }
1531         else
1532         {
1533             TRACE("for type %s got synthesized format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1534             CFSetAddValue(seen_formats, (void*)format->format_id);
1535             formats[pos++] = format;
1536         }
1537     }
1538
1539     /* Now go back through the types adding the synthesized formats that we deferred before. */
1540     for (i = 0; i < count; i++)
1541     {
1542         CFStringRef type = CFArrayGetValueAtIndex(types, i);
1543         WINE_CLIPFORMAT* format = format_for_type(type);
1544
1545         if (!format) continue;
1546         if (!format->synthesized) continue;
1547
1548         /* Don't duplicate a real value with a synthesized value. */
1549         if (CFSetContainsValue(seen_formats, (void*)format->format_id)) continue;
1550
1551         TRACE("for type %s got synthesized format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1552         CFSetAddValue(seen_formats, (void*)format->format_id);
1553         formats[pos++] = format;
1554     }
1555
1556     CFRelease(seen_formats);
1557
1558     if (!pos)
1559     {
1560         HeapFree(GetProcessHeap(), 0, formats);
1561         formats = NULL;
1562     }
1563
1564     *num_formats = pos;
1565     return formats;
1566 }
1567
1568
1569 /**************************************************************************
1570  *              get_formats_for_pasteboard
1571  */
1572 static WINE_CLIPFORMAT** get_formats_for_pasteboard(CFTypeRef pasteboard, UINT *num_formats)
1573 {
1574     CFArrayRef types;
1575     WINE_CLIPFORMAT** formats;
1576
1577     TRACE("pasteboard %s\n", debugstr_cf(pasteboard));
1578
1579     types = macdrv_copy_pasteboard_types(pasteboard);
1580     if (!types)
1581     {
1582         WARN("Failed to copy pasteboard types\n");
1583         return NULL;
1584     }
1585
1586     formats = get_formats_for_pasteboard_types(types, num_formats);
1587     CFRelease(types);
1588     return formats;
1589 }
1590
1591
1592 /**************************************************************************
1593  *              macdrv_get_pasteboard_formats
1594  */
1595 UINT* macdrv_get_pasteboard_formats(CFTypeRef pasteboard, UINT* num_formats)
1596 {
1597     WINE_CLIPFORMAT** formats;
1598     UINT count, i;
1599     UINT* format_ids;
1600
1601     formats = get_formats_for_pasteboard(pasteboard, &count);
1602     if (!formats)
1603         return NULL;
1604
1605     format_ids = HeapAlloc(GetProcessHeap(), 0, count);
1606     if (!format_ids)
1607     {
1608         WARN("Failed to allocate formats IDs array\n");
1609         HeapFree(GetProcessHeap(), 0, formats);
1610         return NULL;
1611     }
1612
1613     for (i = 0; i < count; i++)
1614         format_ids[i] = formats[i]->format_id;
1615
1616     HeapFree(GetProcessHeap(), 0, formats);
1617
1618     *num_formats = count;
1619     return format_ids;
1620 }
1621
1622
1623 /**************************************************************************
1624  *              register_win32_formats
1625  *
1626  * Register Win32 clipboard formats the first time we encounter them.
1627  */
1628 static void register_win32_formats(const UINT *ids, UINT size)
1629 {
1630     unsigned int i;
1631
1632     if (list_empty(&format_list)) register_builtin_formats();
1633
1634     for (i = 0; i < size; i++)
1635         register_format(ids[i], NULL);
1636 }
1637
1638
1639 /***********************************************************************
1640  *              get_clipboard_formats
1641  *
1642  * Return a list of all formats currently available on the Win32 clipboard.
1643  * Helper for set_mac_pasteboard_types_from_win32_clipboard.
1644  */
1645 static UINT *get_clipboard_formats(UINT *size)
1646 {
1647     UINT *ids;
1648
1649     *size = 256;
1650     for (;;)
1651     {
1652         if (!(ids = HeapAlloc(GetProcessHeap(), 0, *size * sizeof(*ids)))) return NULL;
1653         if (GetUpdatedClipboardFormats(ids, *size, size)) break;
1654         HeapFree(GetProcessHeap(), 0, ids);
1655         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return NULL;
1656     }
1657     register_win32_formats(ids, *size);
1658     return ids;
1659 }
1660
1661
1662 /**************************************************************************
1663  *              set_mac_pasteboard_types_from_win32_clipboard
1664  */
1665 static void set_mac_pasteboard_types_from_win32_clipboard(void)
1666 {
1667     WINE_CLIPFORMAT *format;
1668     UINT count, i, *formats;
1669
1670     if (!(formats = get_clipboard_formats(&count))) return;
1671
1672     macdrv_clear_pasteboard(clipboard_cocoa_window);
1673
1674     for (i = 0; i < count; i++)
1675     {
1676         LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
1677         {
1678             if (format->format_id != formats[i]) continue;
1679             TRACE("%s -> %s\n", debugstr_format(format->format_id), debugstr_cf(format->type));
1680             macdrv_set_pasteboard_data(format->type, NULL, clipboard_cocoa_window);
1681         }
1682     }
1683
1684     HeapFree(GetProcessHeap(), 0, formats);
1685     return;
1686 }
1687
1688
1689 /**************************************************************************
1690  *              set_win32_clipboard_formats_from_mac_pasteboard
1691  */
1692 static void set_win32_clipboard_formats_from_mac_pasteboard(CFArrayRef types)
1693 {
1694     WINE_CLIPFORMAT** formats;
1695     UINT count, i;
1696
1697     formats = get_formats_for_pasteboard_types(types, &count);
1698     if (!formats)
1699         return;
1700
1701     for (i = 0; i < count; i++)
1702     {
1703         TRACE("adding format %s\n", debugstr_format(formats[i]->format_id));
1704         SetClipboardData(formats[i]->format_id, 0);
1705     }
1706
1707     HeapFree(GetProcessHeap(), 0, current_mac_formats);
1708     current_mac_formats = formats;
1709     nb_current_mac_formats = count;
1710 }
1711
1712
1713 /**************************************************************************
1714  *              render_format
1715  */
1716 static void render_format(UINT id)
1717 {
1718     unsigned int i;
1719
1720     for (i = 0; i < nb_current_mac_formats; i++)
1721     {
1722         CFDataRef pasteboard_data;
1723
1724         if (current_mac_formats[i]->format_id != id) continue;
1725
1726         pasteboard_data = macdrv_copy_pasteboard_data(NULL, current_mac_formats[i]->type);
1727         if (pasteboard_data)
1728         {
1729             HANDLE handle = current_mac_formats[i]->import_func(pasteboard_data);
1730             CFRelease(pasteboard_data);
1731             if (handle) SetClipboardData(id, handle);
1732             break;
1733         }
1734     }
1735 }
1736
1737
1738 /**************************************************************************
1739  *              grab_win32_clipboard
1740  *
1741  * Grab the Win32 clipboard when a Mac app has taken ownership of the
1742  * pasteboard, and fill it with the pasteboard data types.
1743  */
1744 static void grab_win32_clipboard(void)
1745 {
1746     static CFArrayRef last_types;
1747     CFArrayRef types;
1748
1749     types = macdrv_copy_pasteboard_types(NULL);
1750     if (!types)
1751     {
1752         WARN("Failed to copy pasteboard types\n");
1753         return;
1754     }
1755
1756     if (!macdrv_has_pasteboard_changed() && last_types && CFEqual(types, last_types))
1757     {
1758         CFRelease(types);
1759         return;
1760     }
1761
1762     if (last_types) CFRelease(last_types);
1763     last_types = types; /* takes ownership */
1764
1765     if (!OpenClipboard(clipboard_hwnd)) return;
1766     EmptyClipboard();
1767     is_clipboard_owner = TRUE;
1768     last_clipboard_update = GetTickCount64();
1769     set_win32_clipboard_formats_from_mac_pasteboard(types);
1770     CloseClipboard();
1771     SetTimer(clipboard_hwnd, 1, CLIPBOARD_UPDATE_DELAY, NULL);
1772 }
1773
1774
1775 /**************************************************************************
1776  *              update_clipboard
1777  *
1778  * Periodically update the clipboard while the clipboard is owned by a
1779  * Mac app.
1780  */
1781 static void update_clipboard(void)
1782 {
1783     static BOOL updating;
1784
1785     TRACE("is_clipboard_owner %d last_clipboard_update %llu now %llu\n",
1786           is_clipboard_owner, (unsigned long long)last_clipboard_update, (unsigned long long)GetTickCount64());
1787
1788     if (updating) return;
1789     updating = TRUE;
1790
1791     if (is_clipboard_owner)
1792     {
1793         if (GetTickCount64() - last_clipboard_update > CLIPBOARD_UPDATE_DELAY)
1794             grab_win32_clipboard();
1795     }
1796     else if (!macdrv_is_pasteboard_owner(clipboard_cocoa_window))
1797         grab_win32_clipboard();
1798
1799     updating = FALSE;
1800 }
1801
1802
1803 /**************************************************************************
1804  *              clipboard_wndproc
1805  *
1806  * Window procedure for the clipboard manager.
1807  */
1808 static LRESULT CALLBACK clipboard_wndproc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp)
1809 {
1810     switch (msg)
1811     {
1812         case WM_NCCREATE:
1813             return TRUE;
1814         case WM_CLIPBOARDUPDATE:
1815             if (is_clipboard_owner) break;  /* ignore our own changes */
1816             if ((LONG)(GetClipboardSequenceNumber() - last_get_seqno) <= 0) break;
1817             set_mac_pasteboard_types_from_win32_clipboard();
1818             break;
1819         case WM_RENDERFORMAT:
1820             render_format(wp);
1821             break;
1822         case WM_TIMER:
1823             if (!is_clipboard_owner) break;
1824             grab_win32_clipboard();
1825             break;
1826         case WM_DESTROYCLIPBOARD:
1827             TRACE("WM_DESTROYCLIPBOARD: lost ownership\n");
1828             is_clipboard_owner = FALSE;
1829             KillTimer(hwnd, 1);
1830             break;
1831     }
1832     return DefWindowProcW(hwnd, msg, wp, lp);
1833 }
1834
1835
1836 /**************************************************************************
1837  *              wait_clipboard_mutex
1838  *
1839  * Make sure that there's only one clipboard thread per window station.
1840  */
1841 static BOOL wait_clipboard_mutex(void)
1842 {
1843     static const WCHAR prefix[] = {'_','_','w','i','n','e','_','c','l','i','p','b','o','a','r','d','_'};
1844     WCHAR buffer[MAX_PATH + ARRAY_SIZE(prefix)];
1845     HANDLE mutex;
1846
1847     memcpy(buffer, prefix, sizeof(prefix));
1848     if (!GetUserObjectInformationW(GetProcessWindowStation(), UOI_NAME,
1849                                    buffer + ARRAY_SIZE(prefix),
1850                                    sizeof(buffer) - sizeof(prefix), NULL))
1851     {
1852         ERR("failed to get winstation name\n");
1853         return FALSE;
1854     }
1855     mutex = CreateMutexW(NULL, TRUE, buffer);
1856     if (GetLastError() == ERROR_ALREADY_EXISTS)
1857     {
1858         TRACE("waiting for mutex %s\n", debugstr_w(buffer));
1859         WaitForSingleObject(mutex, INFINITE);
1860     }
1861     return TRUE;
1862 }
1863
1864
1865 /**************************************************************************
1866  *              init_pipe_name
1867  *
1868  * Init-once helper for get_pipe_name.
1869  */
1870 static BOOL CALLBACK init_pipe_name(INIT_ONCE* once, void* param, void** context)
1871 {
1872     static const WCHAR prefix[] = {'\\','\\','.','\\','p','i','p','e','\\','_','_','w','i','n','e','_','c','l','i','p','b','o','a','r','d','_'};
1873
1874     memcpy(clipboard_pipe_name, prefix, sizeof(prefix));
1875     if (!GetUserObjectInformationW(GetProcessWindowStation(), UOI_NAME,
1876                                    clipboard_pipe_name + ARRAY_SIZE(prefix),
1877                                    sizeof(clipboard_pipe_name) - sizeof(prefix), NULL))
1878     {
1879         ERR("failed to get winstation name\n");
1880         return FALSE;
1881     }
1882
1883     return TRUE;
1884 }
1885
1886
1887 /**************************************************************************
1888  *              get_pipe_name
1889  *
1890  * Get the name of the pipe used to communicate with the per-window-station
1891  * clipboard manager thread.
1892  */
1893 static const WCHAR* get_pipe_name(void)
1894 {
1895     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
1896     InitOnceExecuteOnce(&once, init_pipe_name, NULL, NULL);
1897     return clipboard_pipe_name[0] ? clipboard_pipe_name : NULL;
1898 }
1899
1900
1901 /**************************************************************************
1902  *              clipboard_thread
1903  *
1904  * Thread running inside the desktop process to manage the clipboard
1905  */
1906 static DWORD WINAPI clipboard_thread(void *arg)
1907 {
1908     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};
1909     WNDCLASSW class;
1910     struct macdrv_window_features wf;
1911     const WCHAR* pipe_name;
1912     HANDLE pipe = NULL;
1913     HANDLE event = NULL;
1914     OVERLAPPED overlapped;
1915     BOOL need_connect = TRUE, pending = FALSE;
1916     MSG msg;
1917
1918     if (!wait_clipboard_mutex()) return 0;
1919
1920     memset(&class, 0, sizeof(class));
1921     class.lpfnWndProc   = clipboard_wndproc;
1922     class.lpszClassName = clipboard_classname;
1923
1924     if (!RegisterClassW(&class) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
1925     {
1926         ERR("could not register clipboard window class err %u\n", GetLastError());
1927         return 0;
1928     }
1929     if (!(clipboard_hwnd = CreateWindowW(clipboard_classname, NULL, 0, 0, 0, 0, 0,
1930                                          HWND_MESSAGE, 0, 0, NULL)))
1931     {
1932         ERR("failed to create clipboard window err %u\n", GetLastError());
1933         return 0;
1934     }
1935
1936     memset(&wf, 0, sizeof(wf));
1937     clipboard_cocoa_window = macdrv_create_cocoa_window(&wf, CGRectMake(100, 100, 100, 100), clipboard_hwnd,
1938                                                         macdrv_init_thread_data()->queue);
1939     if (!clipboard_cocoa_window)
1940     {
1941         ERR("failed to create clipboard Cocoa window\n");
1942         goto done;
1943     }
1944
1945     pipe_name = get_pipe_name();
1946     if (!pipe_name)
1947     {
1948         ERR("failed to get pipe name\n");
1949         goto done;
1950     }
1951
1952     pipe = CreateNamedPipeW(pipe_name, PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED,
1953                             PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, 1, 1, 0, NULL);
1954     if (!pipe)
1955     {
1956         ERR("failed to create named pipe: %u\n", GetLastError());
1957         goto done;
1958     }
1959
1960     event = CreateEventW(NULL, TRUE, FALSE, NULL);
1961     if (!event)
1962     {
1963         ERR("failed to create event: %d\n", GetLastError());
1964         goto done;
1965     }
1966
1967     clipboard_thread_id = GetCurrentThreadId();
1968     AddClipboardFormatListener(clipboard_hwnd);
1969     register_builtin_formats();
1970     grab_win32_clipboard();
1971
1972     TRACE("clipboard thread %04x running\n", GetCurrentThreadId());
1973     while (1)
1974     {
1975         DWORD result;
1976
1977         if (need_connect)
1978         {
1979             pending = FALSE;
1980             memset(&overlapped, 0, sizeof(overlapped));
1981             overlapped.hEvent = event;
1982             if (ConnectNamedPipe(pipe, &overlapped))
1983             {
1984                 ERR("asynchronous ConnectNamedPipe unexpectedly returned true: %d\n", GetLastError());
1985                 ResetEvent(event);
1986             }
1987             else
1988             {
1989                 result = GetLastError();
1990                 switch (result)
1991                 {
1992                     case ERROR_PIPE_CONNECTED:
1993                     case ERROR_NO_DATA:
1994                         SetEvent(event);
1995                         need_connect = FALSE;
1996                         break;
1997                     case ERROR_IO_PENDING:
1998                         need_connect = FALSE;
1999                         pending = TRUE;
2000                         break;
2001                     default:
2002                         ERR("failed to initiate pipe connection: %d\n", result);
2003                         break;
2004                 }
2005             }
2006         }
2007
2008         result = MsgWaitForMultipleObjectsEx(1, &event, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE | MWMO_INPUTAVAILABLE);
2009         switch (result)
2010         {
2011             case WAIT_OBJECT_0:
2012             {
2013                 DWORD written;
2014
2015                 if (pending && !GetOverlappedResult(pipe, &overlapped, &written, FALSE))
2016                     ERR("failed to connect pipe: %d\n", GetLastError());
2017
2018                 update_clipboard();
2019                 DisconnectNamedPipe(pipe);
2020                 need_connect = TRUE;
2021                 break;
2022             }
2023             case WAIT_OBJECT_0 + 1:
2024                 while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
2025                 {
2026                     if (msg.message == WM_QUIT)
2027                         goto done;
2028                     DispatchMessageW(&msg);
2029                 }
2030                 break;
2031             case WAIT_IO_COMPLETION:
2032                 break;
2033             default:
2034                 ERR("failed to wait for connection or input: %d\n", GetLastError());
2035                 break;
2036         }
2037     }
2038
2039 done:
2040     if (event) CloseHandle(event);
2041     if (pipe) CloseHandle(pipe);
2042     macdrv_destroy_cocoa_window(clipboard_cocoa_window);
2043     DestroyWindow(clipboard_hwnd);
2044     return 0;
2045 }
2046
2047
2048 /**************************************************************************
2049  *              Mac User Driver Clipboard Exports
2050  **************************************************************************/
2051
2052
2053 /**************************************************************************
2054  *              macdrv_UpdateClipboard
2055  */
2056 void CDECL macdrv_UpdateClipboard(void)
2057 {
2058     static ULONG last_update;
2059     ULONG now, end;
2060     const WCHAR* pipe_name;
2061     HANDLE pipe;
2062     BYTE dummy;
2063     DWORD count;
2064     OVERLAPPED overlapped = { 0 };
2065     BOOL canceled = FALSE;
2066
2067     if (GetCurrentThreadId() == clipboard_thread_id) return;
2068
2069     TRACE("\n");
2070
2071     now = GetTickCount();
2072     if ((int)(now - last_update) <= CLIPBOARD_UPDATE_DELAY) return;
2073     last_update = now;
2074
2075     if (!(pipe_name = get_pipe_name())) return;
2076     pipe = CreateFileW(pipe_name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
2077                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
2078     if (pipe == INVALID_HANDLE_VALUE)
2079     {
2080         WARN("failed to open pipe to clipboard manager: %d\n", GetLastError());
2081         return;
2082     }
2083
2084     overlapped.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
2085     if (!overlapped.hEvent)
2086     {
2087         ERR("failed to create event: %d\n", GetLastError());
2088         goto done;
2089     }
2090
2091     /* We expect the read to fail because the server just closes our connection.  This
2092        is just waiting for that close to happen. */
2093     if (ReadFile(pipe, &dummy, sizeof(dummy), NULL, &overlapped))
2094     {
2095         WARN("asynchronous ReadFile unexpectedly returned true: %d\n", GetLastError());
2096         goto done;
2097     }
2098     else
2099     {
2100         DWORD error = GetLastError();
2101         if (error == ERROR_PIPE_NOT_CONNECTED || error == ERROR_BROKEN_PIPE)
2102         {
2103             /* The server accepted, handled, and closed our connection before we
2104                attempted the read, which is fine. */
2105             goto done;
2106         }
2107         else if (error != ERROR_IO_PENDING)
2108         {
2109             ERR("failed to initiate read from pipe: %d\n", error);
2110             goto done;
2111         }
2112     }
2113
2114     end = now + 500;
2115     while (1)
2116     {
2117         DWORD result, timeout;
2118
2119         if (canceled)
2120             timeout = INFINITE;
2121         else
2122         {
2123             now = GetTickCount();
2124             timeout = end - now;
2125             if ((int)timeout < 0)
2126                 timeout = 0;
2127         }
2128
2129         result = MsgWaitForMultipleObjectsEx(1, &overlapped.hEvent, timeout, QS_SENDMESSAGE, MWMO_ALERTABLE);
2130         switch (result)
2131         {
2132             case WAIT_OBJECT_0:
2133             {
2134                 if (GetOverlappedResult(pipe, &overlapped, &count, FALSE))
2135                     WARN("unexpectedly succeeded in reading from pipe\n");
2136                 else
2137                 {
2138                     result = GetLastError();
2139                     if (result != ERROR_BROKEN_PIPE && result != ERROR_OPERATION_ABORTED &&
2140                         result != ERROR_HANDLES_CLOSED)
2141                         WARN("failed to read from pipe: %d\n", result);
2142                 }
2143
2144                 goto done;
2145             }
2146             case WAIT_OBJECT_0 + 1:
2147             {
2148                 MSG msg;
2149                 while (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE))
2150                     DispatchMessageW(&msg);
2151                 break;
2152             }
2153             case WAIT_IO_COMPLETION:
2154                 break;
2155             case WAIT_TIMEOUT:
2156                 WARN("timed out waiting for read\n");
2157                 CancelIoEx(pipe, &overlapped);
2158                 canceled = TRUE;
2159                 break;
2160             default:
2161                 if (canceled)
2162                 {
2163                     ERR("failed to wait for cancel: %d\n", GetLastError());
2164                     goto done;
2165                 }
2166
2167                 ERR("failed to wait for read: %d\n", GetLastError());
2168                 CancelIoEx(pipe, &overlapped);
2169                 canceled = TRUE;
2170                 break;
2171         }
2172     }
2173
2174 done:
2175     if (overlapped.hEvent) CloseHandle(overlapped.hEvent);
2176     CloseHandle(pipe);
2177 }
2178
2179
2180 /**************************************************************************
2181  *              MACDRV Private Clipboard Exports
2182  **************************************************************************/
2183
2184
2185 /**************************************************************************
2186  *              query_pasteboard_data
2187  */
2188 BOOL query_pasteboard_data(HWND hwnd, CFStringRef type)
2189 {
2190     WINE_CLIPFORMAT *format;
2191     BOOL ret = FALSE;
2192     HANDLE handle;
2193
2194     TRACE("win %p/%p type %s\n", hwnd, clipboard_cocoa_window, debugstr_cf(type));
2195
2196     format = format_for_type(type);
2197     if (!format) return FALSE;
2198
2199     if (!OpenClipboard(clipboard_hwnd))
2200     {
2201         ERR("failed to open clipboard for %s\n", debugstr_cf(type));
2202         return FALSE;
2203     }
2204
2205     if ((handle = GetClipboardData(format->format_id)))
2206     {
2207         CFDataRef data;
2208
2209         TRACE("exporting %s %p\n", debugstr_format(format->format_id), handle);
2210
2211         if ((data = format->export_func(handle)))
2212         {
2213             ret = macdrv_set_pasteboard_data(format->type, data, clipboard_cocoa_window);
2214             CFRelease(data);
2215         }
2216     }
2217
2218     last_get_seqno = GetClipboardSequenceNumber();
2219
2220     CloseClipboard();
2221
2222     return ret;
2223 }
2224
2225
2226 /**************************************************************************
2227  *              macdrv_lost_pasteboard_ownership
2228  *
2229  * Handler for the LOST_PASTEBOARD_OWNERSHIP event.
2230  */
2231 void macdrv_lost_pasteboard_ownership(HWND hwnd)
2232 {
2233     TRACE("win %p\n", hwnd);
2234     if (!macdrv_is_pasteboard_owner(clipboard_cocoa_window))
2235         grab_win32_clipboard();
2236 }
2237
2238
2239 /**************************************************************************
2240  *              macdrv_init_clipboard
2241  */
2242 void macdrv_init_clipboard(void)
2243 {
2244     DWORD id;
2245     HANDLE handle = CreateThread(NULL, 0, clipboard_thread, NULL, 0, &id);
2246
2247     if (handle) CloseHandle(handle);
2248     else ERR("failed to create clipboard thread\n");
2249 }