?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winemac: Reduce duplicated code by consolidating exit paths from format_for_type().
[wine.git] / dlls / winemac.drv / clipboard.c
blobf97faeaf3b457eeb2a8416ce6cafc8a81e08335a
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 struct
44 {
45 HWND hwnd_owner;
46 UINT flags;
47 } CLIPBOARDINFO, *LPCLIPBOARDINFO;
48
49 typedef HANDLE (*DRVIMPORTFUNC)(CFDataRef data);
50 typedef CFDataRef (*DRVEXPORTFUNC)(HANDLE data);
51
52 typedef struct
53 {
54 struct list entry;
55 UINT format_id;
56 CFStringRef type;
57 DRVIMPORTFUNC import_func;
58 DRVEXPORTFUNC export_func;
59 BOOL synthesized;
60 } WINE_CLIPFORMAT;
61
62
63 /**************************************************************************
64 * Constants
65 **************************************************************************/
66
67
68 /**************************************************************************
69 * Forward Function Declarations
70 **************************************************************************/
71
72 static HANDLE import_clipboard_data(CFDataRef data);
73 static HANDLE import_bmp_to_bitmap(CFDataRef data);
74 static HANDLE import_bmp_to_dib(CFDataRef data);
75 static HANDLE import_nsfilenames_to_hdrop(CFDataRef data);
76 static HANDLE import_oemtext_to_text(CFDataRef data);
77 static HANDLE import_oemtext_to_unicodetext(CFDataRef data);
78 static HANDLE import_text_to_oemtext(CFDataRef data);
79 static HANDLE import_text_to_unicodetext(CFDataRef data);
80 static HANDLE import_unicodetext_to_oemtext(CFDataRef data);
81 static HANDLE import_unicodetext_to_text(CFDataRef data);
82 static HANDLE import_utf8_to_oemtext(CFDataRef data);
83 static HANDLE import_utf8_to_text(CFDataRef data);
84 static HANDLE import_utf8_to_unicodetext(CFDataRef data);
85 static HANDLE import_utf16_to_oemtext(CFDataRef data);
86 static HANDLE import_utf16_to_text(CFDataRef data);
87 static HANDLE import_utf16_to_unicodetext(CFDataRef data);
88
89 static CFDataRef export_clipboard_data(HANDLE data);
90 static CFDataRef export_bitmap_to_bmp(HANDLE data);
91 static CFDataRef export_dib_to_bmp(HANDLE data);
92 static CFDataRef export_hdrop_to_filenames(HANDLE data);
93 static CFDataRef export_oemtext_to_utf8(HANDLE data);
94 static CFDataRef export_oemtext_to_utf16(HANDLE data);
95 static CFDataRef export_text_to_utf8(HANDLE data);
96 static CFDataRef export_text_to_utf16(HANDLE data);
97 static CFDataRef export_unicodetext_to_utf8(HANDLE data);
98 static CFDataRef export_unicodetext_to_utf16(HANDLE data);
99
100
101 /**************************************************************************
102 * Static Variables
103 **************************************************************************/
104
105 /* Clipboard formats */
106 static struct list format_list = LIST_INIT(format_list);
107
108 /* There are two naming schemes involved and we want to have a mapping between
109 them. There are Win32 clipboard format names and there are Mac pasteboard
110 types.
111
112 The Win32 standard clipboard formats don't have names, but they are associated
113 with Mac pasteboard types through the following tables, which are used to
114 initialize the format_list. Where possible, the standard clipboard formats
115 are mapped to predefined pasteboard type UTIs. Otherwise, we create Wine-
116 specific types of the form "org.winehq.builtin.<format>", where <format> is
117 the name of the symbolic constant for the format minus "CF_" and lowercased.
118 E.g. CF_BITMAP -> org.winehq.builtin.bitmap.
119
120 Win32 clipboard formats which originate in a Windows program may be registered
121 with an arbitrary name. We construct a Mac pasteboard type from these by
122 prepending "org.winehq.registered." to the registered name.
123
124 Likewise, Mac pasteboard types which originate in other apps may have
125 arbitrary type strings. We construct a Win32 clipboard format name from
126 these by prepending "org.winehq.mac-type." to the Mac pasteboard type.
127
128 Summary:
129 Win32 clipboard format names:
130 <none> standard clipboard format; maps via
131 format_list to either a predefined Mac UTI
132 or org.winehq.builtin.<format>.
133 org.winehq.mac-type.<Mac type> representation of Mac type in Win32 land;
134 maps to <Mac type>
135 <other> name registered within Win32 land; maps to
136 org.winehq.registered.<other>
137 Mac pasteboard type names:
138 org.winehq.builtin.<format ID> representation of Win32 standard clipboard
139 format for which there was no corresponding
140 predefined Mac UTI; maps via format_list
141 org.winehq.registered.<format name> representation of Win32 registered
142 clipboard format name; maps to <format name>
143 <other> Mac pasteboard type originating with system
144 or other apps; either maps via format_list
145 to a standard clipboard format or maps to
146 org.winehq.mac-type.<other>
147 */
148
149 static const struct
150 {
151 UINT id;
152 CFStringRef type;
153 DRVIMPORTFUNC import;
154 DRVEXPORTFUNC export;
155 BOOL synthesized;
156 } builtin_format_ids[] =
157 {
158 { CF_DIBV5, CFSTR("org.winehq.builtin.dibv5"), import_clipboard_data, export_clipboard_data, FALSE },
159 { CF_DIF, CFSTR("org.winehq.builtin.dif"), import_clipboard_data, export_clipboard_data, FALSE },
160 { CF_DSPBITMAP, CFSTR("org.winehq.builtin.dspbitmap"), import_clipboard_data, export_clipboard_data, FALSE },
161 { CF_DSPENHMETAFILE, CFSTR("org.winehq.builtin.dspenhmetafile"), import_clipboard_data, export_clipboard_data, FALSE },
162 { CF_DSPMETAFILEPICT, CFSTR("org.winehq.builtin.dspmetafilepict"), import_clipboard_data, export_clipboard_data, FALSE },
163 { CF_DSPTEXT, CFSTR("org.winehq.builtin.dsptext"), import_clipboard_data, export_clipboard_data, FALSE },
164 { CF_LOCALE, CFSTR("org.winehq.builtin.locale"), import_clipboard_data, export_clipboard_data, FALSE },
165 { CF_OWNERDISPLAY, CFSTR("org.winehq.builtin.ownerdisplay"), import_clipboard_data, export_clipboard_data, FALSE },
166 { CF_PALETTE, CFSTR("org.winehq.builtin.palette"), import_clipboard_data, export_clipboard_data, FALSE },
167 { CF_PENDATA, CFSTR("org.winehq.builtin.pendata"), import_clipboard_data, export_clipboard_data, FALSE },
168 { CF_RIFF, CFSTR("org.winehq.builtin.riff"), import_clipboard_data, export_clipboard_data, FALSE },
169 { CF_SYLK, CFSTR("org.winehq.builtin.sylk"), import_clipboard_data, export_clipboard_data, FALSE },
170 { CF_TIFF, CFSTR("public.tiff"), import_clipboard_data, export_clipboard_data, FALSE },
171 { CF_WAVE, CFSTR("com.microsoft.waveform-audio"), import_clipboard_data, export_clipboard_data, FALSE },
172
173 { CF_UNICODETEXT, CFSTR("org.winehq.builtin.unicodetext"), import_clipboard_data, export_clipboard_data, FALSE },
174 { CF_TEXT, CFSTR("org.winehq.builtin.unicodetext"), import_unicodetext_to_text, NULL, TRUE },
175 { CF_OEMTEXT, CFSTR("org.winehq.builtin.unicodetext"), import_unicodetext_to_oemtext, NULL, TRUE },
176
177 { CF_TEXT, CFSTR("org.winehq.builtin.text"), import_clipboard_data, export_clipboard_data, FALSE },
178 { CF_UNICODETEXT, CFSTR("org.winehq.builtin.text"), import_text_to_unicodetext, NULL, TRUE },
179 { CF_OEMTEXT, CFSTR("org.winehq.builtin.text"), import_text_to_oemtext, NULL, TRUE },
180
181 { CF_OEMTEXT, CFSTR("org.winehq.builtin.oemtext"), import_clipboard_data, export_clipboard_data, FALSE },
182 { CF_UNICODETEXT, CFSTR("org.winehq.builtin.oemtext"), import_oemtext_to_unicodetext, NULL, TRUE },
183 { CF_TEXT, CFSTR("org.winehq.builtin.oemtext"), import_oemtext_to_text, NULL, TRUE },
184
185 { CF_UNICODETEXT, CFSTR("public.utf8-plain-text"), import_utf8_to_unicodetext, export_unicodetext_to_utf8, TRUE },
186 { CF_TEXT, CFSTR("public.utf8-plain-text"), import_utf8_to_text, export_text_to_utf8, TRUE },
187 { CF_OEMTEXT, CFSTR("public.utf8-plain-text"), import_utf8_to_oemtext, export_oemtext_to_utf8, TRUE },
188
189 { CF_UNICODETEXT, CFSTR("public.utf16-plain-text"), import_utf16_to_unicodetext, export_unicodetext_to_utf16,TRUE },
190 { CF_TEXT, CFSTR("public.utf16-plain-text"), import_utf16_to_text, export_text_to_utf16, TRUE },
191 { CF_OEMTEXT, CFSTR("public.utf16-plain-text"), import_utf16_to_oemtext, export_oemtext_to_utf16, TRUE },
192
193 { CF_DIB, CFSTR("org.winehq.builtin.dib"), import_clipboard_data, export_clipboard_data, FALSE },
194 { CF_DIB, CFSTR("com.microsoft.bmp"), import_bmp_to_dib, export_dib_to_bmp, TRUE },
195
196 { CF_BITMAP, CFSTR("org.winehq.builtin.bitmap"), import_bmp_to_bitmap, export_bitmap_to_bmp, FALSE },
197 { CF_BITMAP, CFSTR("com.microsoft.bmp"), import_bmp_to_bitmap, export_bitmap_to_bmp, TRUE },
198
199 { CF_HDROP, CFSTR("org.winehq.builtin.hdrop"), import_clipboard_data, export_clipboard_data, FALSE },
200 { CF_HDROP, CFSTR("NSFilenamesPboardType"), import_nsfilenames_to_hdrop, export_hdrop_to_filenames, TRUE },
201 };
202
203 static const WCHAR wszRichTextFormat[] = {'R','i','c','h',' ','T','e','x','t',' ','F','o','r','m','a','t',0};
204 static const WCHAR wszGIF[] = {'G','I','F',0};
205 static const WCHAR wszJFIF[] = {'J','F','I','F',0};
206 static const WCHAR wszPNG[] = {'P','N','G',0};
207 static const WCHAR wszHTMLFormat[] = {'H','T','M','L',' ','F','o','r','m','a','t',0};
208 static const struct
209 {
210 LPCWSTR name;
211 CFStringRef type;
212 DRVIMPORTFUNC import;
213 DRVEXPORTFUNC export;
214 } builtin_format_names[] =
215 {
216 { wszRichTextFormat, CFSTR("public.rtf"), import_clipboard_data, export_clipboard_data },
217 { wszGIF, CFSTR("com.compuserve.gif"), import_clipboard_data, export_clipboard_data },
218 { wszJFIF, CFSTR("public.jpeg"), import_clipboard_data, export_clipboard_data },
219 { wszPNG, CFSTR("public.png"), import_clipboard_data, export_clipboard_data },
220 { wszHTMLFormat, CFSTR("public.html"), import_clipboard_data, export_clipboard_data },
221 { CFSTR_SHELLURLW, CFSTR("public.url"), import_utf8_to_text, export_text_to_utf8 },
222 };
223
224 /* The prefix prepended to an external Mac pasteboard type to make a Win32 clipboard format name. org.winehq.mac-type. */
225 static const WCHAR mac_type_name_prefix[] = {'o','r','g','.','w','i','n','e','h','q','.','m','a','c','-','t','y','p','e','.',0};
226
227 /* The prefix prepended to a Win32 clipboard format name to make a Mac pasteboard type. */
228 static const CFStringRef registered_name_type_prefix = CFSTR("org.winehq.registered.");
229
230
231 /**************************************************************************
232 * Internal Clipboard implementation methods
233 **************************************************************************/
234
235 /*
236 * format_list functions
237 */
238
239 /**************************************************************************
240 * debugstr_format
241 */
242 const char *debugstr_format(UINT id)
243 {
244 WCHAR buffer[256];
245
246 if (GetClipboardFormatNameW(id, buffer, 256))
247 return wine_dbg_sprintf("0x%04x %s", id, debugstr_w(buffer));
248
249 switch (id)
250 {
251 #define BUILTIN(id) case id: return #id;
252 BUILTIN(CF_TEXT)
253 BUILTIN(CF_BITMAP)
254 BUILTIN(CF_METAFILEPICT)
255 BUILTIN(CF_SYLK)
256 BUILTIN(CF_DIF)
257 BUILTIN(CF_TIFF)
258 BUILTIN(CF_OEMTEXT)
259 BUILTIN(CF_DIB)
260 BUILTIN(CF_PALETTE)
261 BUILTIN(CF_PENDATA)
262 BUILTIN(CF_RIFF)
263 BUILTIN(CF_WAVE)
264 BUILTIN(CF_UNICODETEXT)
265 BUILTIN(CF_ENHMETAFILE)
266 BUILTIN(CF_HDROP)
267 BUILTIN(CF_LOCALE)
268 BUILTIN(CF_DIBV5)
269 BUILTIN(CF_OWNERDISPLAY)
270 BUILTIN(CF_DSPTEXT)
271 BUILTIN(CF_DSPBITMAP)
272 BUILTIN(CF_DSPMETAFILEPICT)
273 BUILTIN(CF_DSPENHMETAFILE)
274 #undef BUILTIN
275 default: return wine_dbg_sprintf("0x%04x", id);
276 }
277 }
278
279
280 /**************************************************************************
281 * insert_clipboard_format
282 */
283 static WINE_CLIPFORMAT *insert_clipboard_format(UINT id, CFStringRef type)
284 {
285 WINE_CLIPFORMAT *format;
286
287 format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format));
288
289 if (format == NULL)
290 {
291 WARN("No more memory for a new format!\n");
292 return NULL;
293 }
294 format->format_id = id;
295 format->import_func = import_clipboard_data;
296 format->export_func = export_clipboard_data;
297 format->synthesized = FALSE;
298
299 if (type)
300 format->type = CFStringCreateCopy(NULL, type);
301 else
302 {
303 WCHAR buffer[256];
304
305 if (!GetClipboardFormatNameW(format->format_id, buffer, sizeof(buffer) / sizeof(buffer[0])))
306 {
307 WARN("failed to get name for format %s; error 0x%08x\n", debugstr_format(format->format_id), GetLastError());
308 HeapFree(GetProcessHeap(), 0, format);
309 return NULL;
310 }
311
312 if (!strncmpW(buffer, mac_type_name_prefix, strlenW(mac_type_name_prefix)))
313 {
314 const WCHAR *p = buffer + strlenW(mac_type_name_prefix);
315 format->type = CFStringCreateWithCharacters(NULL, (UniChar*)p, strlenW(p));
316 }
317 else
318 {
319 format->type = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@%S"),
320 registered_name_type_prefix, buffer);
321 }
322 }
323
324 list_add_tail(&format_list, &format->entry);
325
326 TRACE("Registering format %s type %s\n", debugstr_format(format->format_id),
327 debugstr_cf(format->type));
328
329 return format;
330 }
331
332
333 /**************************************************************************
334 * register_format
335 *
336 * Register a custom Mac clipboard format.
337 */
338 static WINE_CLIPFORMAT* register_format(UINT id, CFStringRef type)
339 {
340 WINE_CLIPFORMAT *format;
341
342 /* walk format chain to see if it's already registered */
343 LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
344 if (format->format_id == id) return format;
345
346 return insert_clipboard_format(id, type);
347 }
348
349
350 /**************************************************************************
351 * format_for_type
352 */
353 static WINE_CLIPFORMAT* format_for_type(WINE_CLIPFORMAT *current, CFStringRef type)
354 {
355 struct list *ptr = current ? &current->entry : &format_list;
356 WINE_CLIPFORMAT *format = NULL;
357
358 TRACE("current %p/%s type %s\n", current, debugstr_format(current ? current->format_id : 0), debugstr_cf(type));
359
360 while ((ptr = list_next(&format_list, ptr)))
361 {
362 format = LIST_ENTRY(ptr, WINE_CLIPFORMAT, entry);
363 if (CFEqual(format->type, type))
364 goto done;
365 }
366
367 format = NULL;
368 if (!current)
369 {
370 LPWSTR name;
371
372 if (CFStringHasPrefix(type, CFSTR("org.winehq.builtin.")))
373 {
374 ERR("Shouldn't happen. Built-in type %s should have matched something in format list.\n",
375 debugstr_cf(type));
376 goto done;
377 }
378 else if (CFStringHasPrefix(type, registered_name_type_prefix))
379 {
380 int len = CFStringGetLength(type) - CFStringGetLength(registered_name_type_prefix);
381 name = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
382 CFStringGetCharacters(type, CFRangeMake(CFStringGetLength(registered_name_type_prefix), len),
383 (UniChar*)name);
384 name[len] = 0;
385 }
386 else
387 {
388 int len = strlenW(mac_type_name_prefix) + CFStringGetLength(type);
389 name = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
390 memcpy(name, mac_type_name_prefix, sizeof(mac_type_name_prefix));
391 CFStringGetCharacters(type, CFRangeMake(0, CFStringGetLength(type)),
392 (UniChar*)name + strlenW(mac_type_name_prefix));
393 name[len] = 0;
394 }
395
396 format = register_format(RegisterClipboardFormatW(name), type);
397 if (!format)
398 ERR("Failed to register format for type %s name %s\n", debugstr_cf(type), debugstr_w(name));
399
400 HeapFree(GetProcessHeap(), 0, name);
401 }
402
403 done:
404 TRACE(" -> %p/%s\n", format, debugstr_format(format ? format->format_id : 0));
405 return format;
406 }
407
408
409 /**************************************************************************
410 * convert_text
411 *
412 * Convert string data between code pages or to/from wide characters. The
413 * special value of (UINT)-1 for a code page indicates to use wide
414 * characters.
415 */
416 static HANDLE convert_text(const void *src, int src_len, UINT src_cp, UINT dest_cp)
417 {
418 HANDLE ret = NULL;
419 const WCHAR *wstr;
420 int wstr_len;
421 HANDLE handle;
422 char *p;
423
424 if (src_cp == (UINT)-1)
425 {
426 wstr = src;
427 wstr_len = src_len / sizeof(WCHAR);
428 }
429 else
430 {
431 WCHAR *temp;
432
433 wstr_len = MultiByteToWideChar(src_cp, 0, src, src_len, NULL, 0);
434 if (!src_len || ((const char*)src)[src_len - 1]) wstr_len += 1;
435 temp = HeapAlloc(GetProcessHeap(), 0, wstr_len * sizeof(WCHAR));
436 MultiByteToWideChar(src_cp, 0, src, src_len, temp, wstr_len);
437 temp[wstr_len - 1] = 0;
438 wstr = temp;
439 }
440
441 if (dest_cp == (UINT)-1)
442 {
443 handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, wstr_len * sizeof(WCHAR));
444 if (handle && (p = GlobalLock(handle)))
445 {
446 memcpy(p, wstr, wstr_len * sizeof(WCHAR));
447 GlobalUnlock(handle);
448 ret = handle;
449 }
450 }
451 else
452 {
453 INT len;
454
455 len = WideCharToMultiByte(dest_cp, 0, wstr, wstr_len, NULL, 0, NULL, NULL);
456 if (!wstr_len || wstr[wstr_len - 1]) len += 1;
457 handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len);
458
459 if (handle && (p = GlobalLock(handle)))
460 {
461 WideCharToMultiByte(dest_cp, 0, wstr, wstr_len, p, len, NULL, NULL);
462 p[len - 1] = 0;
463 GlobalUnlock(handle);
464 ret = handle;
465 }
466 }
467
468 return ret;
469 }
470
471
472 /**************************************************************************
473 * convert_unicodetext_to_codepage
474 */
475 static HANDLE convert_unicodetext_to_codepage(HANDLE unicode_handle, UINT cp)
476 {
477 LPWSTR unicode_string = GlobalLock(unicode_handle);
478 HANDLE ret = NULL;
479
480 if (unicode_string)
481 {
482 ret = convert_text(unicode_string, GlobalSize(unicode_handle), -1, cp);
483 GlobalUnlock(unicode_handle);
484 }
485
486 return ret;
487 }
488
489
490 /***********************************************************************
491 * bitmap_info_size
492 *
493 * Return the size of the bitmap info structure including color table.
494 */
495 static int bitmap_info_size(const BITMAPINFO *info, WORD coloruse)
496 {
497 unsigned int colors, size, masks = 0;
498
499 if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
500 {
501 const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER*)info;
502 colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
503 return sizeof(BITMAPCOREHEADER) + colors *
504 ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
505 }
506 else /* assume BITMAPINFOHEADER */
507 {
508 colors = info->bmiHeader.biClrUsed;
509 if (!colors && (info->bmiHeader.biBitCount <= 8))
510 colors = 1 << info->bmiHeader.biBitCount;
511 if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
512 size = max(info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD));
513 return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
514 }
515 }
516
517
518 /***********************************************************************
519 * create_dib_from_bitmap
520 *
521 * Allocates a packed DIB and copies the bitmap data into it.
522 */
523 static HGLOBAL create_dib_from_bitmap(HBITMAP hBmp)
524 {
525 BITMAP bmp;
526 HDC hdc;
527 HGLOBAL hPackedDIB;
528 LPBYTE pPackedDIB;
529 LPBITMAPINFOHEADER pbmiHeader;
530 unsigned int cDataSize, cPackedSize, OffsetBits;
531 int nLinesCopied;
532
533 if (!GetObjectW(hBmp, sizeof(bmp), &bmp)) return 0;
534
535 /*
536 * A packed DIB contains a BITMAPINFO structure followed immediately by
537 * an optional color palette and the pixel data.
538 */
539
540 /* Calculate the size of the packed DIB */
541 cDataSize = abs(bmp.bmHeight) * (((bmp.bmWidth * bmp.bmBitsPixel + 31) / 8) & ~3);
542 cPackedSize = sizeof(BITMAPINFOHEADER)
543 + ((bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0)
544 + cDataSize;
545 /* Get the offset to the bits */
546 OffsetBits = cPackedSize - cDataSize;
547
548 /* Allocate the packed DIB */
549 TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
550 hPackedDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cPackedSize);
551 if (!hPackedDIB)
552 {
553 WARN("Could not allocate packed DIB!\n");
554 return 0;
555 }
556
557 /* A packed DIB starts with a BITMAPINFOHEADER */
558 pPackedDIB = GlobalLock(hPackedDIB);
559 pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
560
561 /* Init the BITMAPINFOHEADER */
562 pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
563 pbmiHeader->biWidth = bmp.bmWidth;
564 pbmiHeader->biHeight = bmp.bmHeight;
565 pbmiHeader->biPlanes = 1;
566 pbmiHeader->biBitCount = bmp.bmBitsPixel;
567 pbmiHeader->biCompression = BI_RGB;
568 pbmiHeader->biSizeImage = 0;
569 pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
570 pbmiHeader->biClrUsed = 0;
571 pbmiHeader->biClrImportant = 0;
572
573 /* Retrieve the DIB bits from the bitmap and fill in the
574 * DIB color table if present */
575 hdc = GetDC(0);
576 nLinesCopied = GetDIBits(hdc, /* Handle to device context */
577 hBmp, /* Handle to bitmap */
578 0, /* First scan line to set in dest bitmap */
579 bmp.bmHeight, /* Number of scan lines to copy */
580 pPackedDIB + OffsetBits, /* [out] Address of array for bitmap bits */
581 (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
582 0); /* RGB or palette index */
583 GlobalUnlock(hPackedDIB);
584 ReleaseDC(0, hdc);
585
586 /* Cleanup if GetDIBits failed */
587 if (nLinesCopied != bmp.bmHeight)
588 {
589 TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
590 GlobalFree(hPackedDIB);
591 hPackedDIB = 0;
592 }
593 return hPackedDIB;
594 }
595
596
597 /**************************************************************************
598 * import_clipboard_data
599 *
600 * Generic import clipboard data routine.
601 */
602 static HANDLE import_clipboard_data(CFDataRef data)
603 {
604 HANDLE data_handle = NULL;
605
606 size_t len = CFDataGetLength(data);
607 if (len)
608 {
609 LPVOID p;
610
611 /* Turn on the DDESHARE flag to enable shared 32 bit memory */
612 data_handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len);
613 if (!data_handle)
614 return NULL;
615
616 if ((p = GlobalLock(data_handle)))
617 {
618 memcpy(p, CFDataGetBytePtr(data), len);
619 GlobalUnlock(data_handle);
620 }
621 else
622 {
623 GlobalFree(data_handle);
624 data_handle = NULL;
625 }
626 }
627
628 return data_handle;
629 }
630
631
632 /**************************************************************************
633 * import_bmp_to_bitmap
634 *
635 * Import BMP data, converting to CF_BITMAP format.
636 */
637 static HANDLE import_bmp_to_bitmap(CFDataRef data)
638 {
639 HANDLE ret = 0;
640 HANDLE dib = import_bmp_to_dib(data);
641 BITMAPINFO *bmi;
642
643 if (dib && (bmi = GlobalLock(dib)))
644 {
645 HDC hdc;
646 unsigned int offset;
647
648 hdc = GetDC(NULL);
649
650 offset = bitmap_info_size(bmi, DIB_RGB_COLORS);
651
652 ret = CreateDIBitmap(hdc, &bmi->bmiHeader, CBM_INIT, (LPBYTE)bmi + offset,
653 bmi, DIB_RGB_COLORS);
654
655 GlobalUnlock(dib);
656 ReleaseDC(NULL, hdc);
657 }
658
659 GlobalFree(dib);
660 return ret;
661 }
662
663
664 /**************************************************************************
665 * import_bmp_to_dib
666 *
667 * Import BMP data, converting to CF_DIB format. This just entails
668 * stripping the BMP file format header.
669 */
670 static HANDLE import_bmp_to_dib(CFDataRef data)
671 {
672 HANDLE ret = 0;
673 BITMAPFILEHEADER *bfh = (BITMAPFILEHEADER*)CFDataGetBytePtr(data);
674 CFIndex len = CFDataGetLength(data);
675
676 if (len >= sizeof(*bfh) + sizeof(BITMAPCOREHEADER) &&
677 bfh->bfType == 0x4d42 /* "BM" */)
678 {
679 BITMAPINFO *bmi = (BITMAPINFO*)(bfh + 1);
680 BYTE* p;
681
682 len -= sizeof(*bfh);
683 ret = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len);
684 if (!ret || !(p = GlobalLock(ret)))
685 {
686 GlobalFree(ret);
687 return 0;
688 }
689
690 memcpy(p, bmi, len);
691 GlobalUnlock(ret);
692 }
693
694 return ret;
695 }
696
697
698 /**************************************************************************
699 * import_nsfilenames_to_hdrop
700 *
701 * Import NSFilenamesPboardType data, converting the property-list-
702 * serialized array of path strings to CF_HDROP.
703 */
704 static HANDLE import_nsfilenames_to_hdrop(CFDataRef data)
705 {
706 HDROP hdrop = NULL;
707 CFArrayRef names;
708 CFIndex count, i;
709 size_t len;
710 char *buffer = NULL;
711 WCHAR **paths = NULL;
712 DROPFILES* dropfiles;
713 UniChar* p;
714
715 TRACE("data %s\n", debugstr_cf(data));
716
717 names = (CFArrayRef)CFPropertyListCreateWithData(NULL, data, kCFPropertyListImmutable,
718 NULL, NULL);
719 if (!names || CFGetTypeID(names) != CFArrayGetTypeID())
720 {
721 WARN("failed to interpret data as a CFArray\n");
722 goto done;
723 }
724
725 count = CFArrayGetCount(names);
726
727 len = 0;
728 for (i = 0; i < count; i++)
729 {
730 CFIndex this_len;
731 CFStringRef name = (CFStringRef)CFArrayGetValueAtIndex(names, i);
732 TRACE(" %s\n", debugstr_cf(name));
733 if (CFGetTypeID(name) != CFStringGetTypeID())
734 {
735 WARN("non-string in array\n");
736 goto done;
737 }
738
739 this_len = CFStringGetMaximumSizeOfFileSystemRepresentation(name);
740 if (this_len > len)
741 len = this_len;
742 }
743
744 buffer = HeapAlloc(GetProcessHeap(), 0, len);
745 if (!buffer)
746 {
747 WARN("failed to allocate buffer for file-system representations\n");
748 goto done;
749 }
750
751 paths = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(paths[0]));
752 if (!paths)
753 {
754 WARN("failed to allocate array of DOS paths\n");
755 goto done;
756 }
757
758 for (i = 0; i < count; i++)
759 {
760 CFStringRef name = (CFStringRef)CFArrayGetValueAtIndex(names, i);
761 if (!CFStringGetFileSystemRepresentation(name, buffer, len))
762 {
763 WARN("failed to get file-system representation for %s\n", debugstr_cf(name));
764 goto done;
765 }
766 paths[i] = wine_get_dos_file_name(buffer);
767 if (!paths[i])
768 {
769 WARN("failed to get DOS path for %s\n", debugstr_a(buffer));
770 goto done;
771 }
772 }
773
774 len = 1; /* for the terminating null */
775 for (i = 0; i < count; i++)
776 len += strlenW(paths[i]) + 1;
777
778 hdrop = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(*dropfiles) + len * sizeof(WCHAR));
779 if (!hdrop || !(dropfiles = GlobalLock(hdrop)))
780 {
781 WARN("failed to allocate HDROP\n");
782 GlobalFree(hdrop);
783 hdrop = NULL;
784 goto done;
785 }
786
787 dropfiles->pFiles = sizeof(*dropfiles);
788 dropfiles->pt.x = 0;
789 dropfiles->pt.y = 0;
790 dropfiles->fNC = FALSE;
791 dropfiles->fWide = TRUE;
792
793 p = (WCHAR*)(dropfiles + 1);
794 for (i = 0; i < count; i++)
795 {
796 strcpyW(p, paths[i]);
797 p += strlenW(p) + 1;
798 }
799 *p = 0;
800
801 GlobalUnlock(hdrop);
802
803 done:
804 if (paths)
805 {
806 for (i = 0; i < count; i++)
807 HeapFree(GetProcessHeap(), 0, paths[i]);
808 HeapFree(GetProcessHeap(), 0, paths);
809 }
810 HeapFree(GetProcessHeap(), 0, buffer);
811 if (names) CFRelease(names);
812 return hdrop;
813 }
814
815
816 /**************************************************************************
817 * import_oemtext_to_text
818 *
819 * Import CF_OEMTEXT data, converting the string to CF_TEXT.
820 */
821 static HANDLE import_oemtext_to_text(CFDataRef data)
822 {
823 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), CP_OEMCP, CP_ACP);
824 }
825
826
827 /**************************************************************************
828 * import_oemtext_to_unicodetext
829 *
830 * Import CF_OEMTEXT data, converting the string to CF_UNICODETEXT.
831 */
832 static HANDLE import_oemtext_to_unicodetext(CFDataRef data)
833 {
834 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), CP_OEMCP, -1);
835 }
836
837
838 /**************************************************************************
839 * import_text_to_oemtext
840 *
841 * Import CF_TEXT data, converting the string to CF_OEMTEXT.
842 */
843 static HANDLE import_text_to_oemtext(CFDataRef data)
844 {
845 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), CP_ACP, CP_OEMCP);
846 }
847
848
849 /**************************************************************************
850 * import_text_to_unicodetext
851 *
852 * Import CF_TEXT data, converting the string to CF_UNICODETEXT.
853 */
854 static HANDLE import_text_to_unicodetext(CFDataRef data)
855 {
856 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), CP_ACP, -1);
857 }
858
859
860 /**************************************************************************
861 * import_unicodetext_to_oemtext
862 *
863 * Import a CF_UNICODETEXT string, converting the string to CF_OEMTEXT.
864 */
865 static HANDLE import_unicodetext_to_oemtext(CFDataRef data)
866 {
867 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), -1, CP_OEMCP);
868 }
869
870
871 /**************************************************************************
872 * import_unicodetext_to_text
873 *
874 * Import a CF_UNICODETEXT string, converting the string to CF_TEXT.
875 */
876 static HANDLE import_unicodetext_to_text(CFDataRef data)
877 {
878 return convert_text(CFDataGetBytePtr(data), CFDataGetLength(data), -1, CP_ACP);
879 }
880
881
882 /**************************************************************************
883 * import_utf8_to_oemtext
884 *
885 * Import a UTF-8 string, converting the string to CF_OEMTEXT.
886 */
887 static HANDLE import_utf8_to_oemtext(CFDataRef data)
888 {
889 HANDLE unicode_handle = import_utf8_to_unicodetext(data);
890 HANDLE ret = convert_unicodetext_to_codepage(unicode_handle, CP_OEMCP);
891
892 GlobalFree(unicode_handle);
893 return ret;
894 }
895
896
897 /**************************************************************************
898 * import_utf8_to_text
899 *
900 * Import a UTF-8 string, converting the string to CF_TEXT.
901 */
902 static HANDLE import_utf8_to_text(CFDataRef data)
903 {
904 HANDLE unicode_handle = import_utf8_to_unicodetext(data);
905 HANDLE ret = convert_unicodetext_to_codepage(unicode_handle, CP_ACP);
906
907 GlobalFree(unicode_handle);
908 return ret;
909 }
910
911
912 /**************************************************************************
913 * import_utf8_to_unicodetext
914 *
915 * Import a UTF-8 string, converting the string to CF_UNICODETEXT.
916 */
917 static HANDLE import_utf8_to_unicodetext(CFDataRef data)
918 {
919 const BYTE *src;
920 unsigned long src_len;
921 unsigned long new_lines = 0;
922 LPSTR dst;
923 unsigned long i, j;
924 HANDLE unicode_handle = NULL;
925
926 src = CFDataGetBytePtr(data);
927 src_len = CFDataGetLength(data);
928 for (i = 0; i < src_len; i++)
929 {
930 if (src[i] == '\n')
931 new_lines++;
932 }
933
934 if ((dst = HeapAlloc(GetProcessHeap(), 0, src_len + new_lines + 1)))
935 {
936 UINT count;
937
938 for (i = 0, j = 0; i < src_len; i++)
939 {
940 if (src[i] == '\n')
941 dst[j++] = '\r';
942
943 dst[j++] = src[i];
944 }
945 dst[j] = 0;
946
947 count = MultiByteToWideChar(CP_UTF8, 0, dst, -1, NULL, 0);
948 unicode_handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, count * sizeof(WCHAR));
949
950 if (unicode_handle)
951 {
952 WCHAR *textW = GlobalLock(unicode_handle);
953 MultiByteToWideChar(CP_UTF8, 0, dst, -1, textW, count);
954 GlobalUnlock(unicode_handle);
955 }
956
957 HeapFree(GetProcessHeap(), 0, dst);
958 }
959
960 return unicode_handle;
961 }
962
963
964 /**************************************************************************
965 * import_utf16_to_oemtext
966 *
967 * Import a UTF-16 string, converting the string to CF_OEMTEXT.
968 */
969 static HANDLE import_utf16_to_oemtext(CFDataRef data)
970 {
971 HANDLE unicode_handle = import_utf16_to_unicodetext(data);
972 HANDLE ret = convert_unicodetext_to_codepage(unicode_handle, CP_OEMCP);
973
974 GlobalFree(unicode_handle);
975 return ret;
976 }
977
978
979 /**************************************************************************
980 * import_utf16_to_text
981 *
982 * Import a UTF-16 string, converting the string to CF_TEXT.
983 */
984 static HANDLE import_utf16_to_text(CFDataRef data)
985 {
986 HANDLE unicode_handle = import_utf16_to_unicodetext(data);
987 HANDLE ret = convert_unicodetext_to_codepage(unicode_handle, CP_ACP);
988
989 GlobalFree(unicode_handle);
990 return ret;
991 }
992
993
994 /**************************************************************************
995 * import_utf16_to_unicodetext
996 *
997 * Import a UTF-8 string, converting the string to CF_UNICODETEXT.
998 */
999 static HANDLE import_utf16_to_unicodetext(CFDataRef data)
1000 {
1001 const WCHAR *src;
1002 unsigned long src_len;
1003 unsigned long new_lines = 0;
1004 LPWSTR dst;
1005 unsigned long i, j;
1006 HANDLE unicode_handle;
1007
1008 src = (const WCHAR *)CFDataGetBytePtr(data);
1009 src_len = CFDataGetLength(data) / sizeof(WCHAR);
1010 for (i = 0; i < src_len; i++)
1011 {
1012 if (src[i] == '\n')
1013 new_lines++;
1014 }
1015
1016 if ((unicode_handle = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, (src_len + new_lines + 1) * sizeof(WCHAR))))
1017 {
1018 dst = GlobalLock(unicode_handle);
1019
1020 for (i = 0, j = 0; i < src_len; i++)
1021 {
1022 if (src[i] == '\n')
1023 dst[j++] = '\r';
1024
1025 dst[j++] = src[i];
1026 }
1027 dst[j] = 0;
1028
1029 GlobalUnlock(unicode_handle);
1030 }
1031
1032 return unicode_handle;
1033 }
1034
1035
1036 /**************************************************************************
1037 * export_clipboard_data
1038 *
1039 * Generic export clipboard data routine.
1040 */
1041 static CFDataRef export_clipboard_data(HANDLE data)
1042 {
1043 CFDataRef ret;
1044 UINT len;
1045 LPVOID src;
1046
1047 len = GlobalSize(data);
1048 src = GlobalLock(data);
1049 if (!src) return NULL;
1050
1051 ret = CFDataCreate(NULL, src, len);
1052 GlobalUnlock(data);
1053
1054 return ret;
1055 }
1056
1057
1058 /**************************************************************************
1059 * export_bitmap_to_bmp
1060 *
1061 * Export CF_BITMAP to BMP file format.
1062 */
1063 static CFDataRef export_bitmap_to_bmp(HANDLE data)
1064 {
1065 CFDataRef ret = NULL;
1066 HGLOBAL dib;
1067
1068 dib = create_dib_from_bitmap(data);
1069 if (dib)
1070 {
1071 ret = export_dib_to_bmp(dib);
1072 GlobalFree(dib);
1073 }
1074
1075 return ret;
1076 }
1077
1078
1079 /**************************************************************************
1080 * export_codepage_to_utf8
1081 *
1082 * Export string data in a specified codepage to UTF-8.
1083 */
1084 static CFDataRef export_codepage_to_utf8(HANDLE data, UINT cp)
1085 {
1086 CFDataRef ret = NULL;
1087 const char* str;
1088
1089 if ((str = GlobalLock(data)))
1090 {
1091 HANDLE unicode = convert_text(str, GlobalSize(data), cp, -1);
1092
1093 ret = export_unicodetext_to_utf8(unicode);
1094
1095 GlobalFree(unicode);
1096 GlobalUnlock(data);
1097 }
1098
1099 return ret;
1100 }
1101
1102
1103 /**************************************************************************
1104 * export_codepage_to_utf16
1105 *
1106 * Export string data in a specified codepage to UTF-16.
1107 */
1108 static CFDataRef export_codepage_to_utf16(HANDLE data, UINT cp)
1109 {
1110 CFDataRef ret = NULL;
1111 const char* str;
1112
1113 if ((str = GlobalLock(data)))
1114 {
1115 HANDLE unicode = convert_text(str, GlobalSize(data), cp, -1);
1116
1117 ret = export_unicodetext_to_utf16(unicode);
1118
1119 GlobalFree(unicode);
1120 GlobalUnlock(data);
1121 }
1122
1123 return ret;
1124 }
1125
1126
1127 /**************************************************************************
1128 * export_dib_to_bmp
1129 *
1130 * Export CF_DIB to BMP file format. This just entails prepending a BMP
1131 * file format header to the data.
1132 */
1133 static CFDataRef export_dib_to_bmp(HANDLE data)
1134 {
1135 CFMutableDataRef ret = NULL;
1136 BYTE *dibdata;
1137 CFIndex len;
1138 BITMAPFILEHEADER bfh;
1139
1140 dibdata = GlobalLock(data);
1141 if (!dibdata)
1142 return NULL;
1143
1144 len = sizeof(bfh) + GlobalSize(data);
1145 ret = CFDataCreateMutable(NULL, len);
1146 if (ret)
1147 {
1148 bfh.bfType = 0x4d42; /* "BM" */
1149 bfh.bfSize = len;
1150 bfh.bfReserved1 = 0;
1151 bfh.bfReserved2 = 0;
1152 bfh.bfOffBits = sizeof(bfh) + bitmap_info_size((BITMAPINFO*)dibdata, DIB_RGB_COLORS);
1153 CFDataAppendBytes(ret, (UInt8*)&bfh, sizeof(bfh));
1154
1155 /* rest of bitmap is the same as the packed dib */
1156 CFDataAppendBytes(ret, (UInt8*)dibdata, len - sizeof(bfh));
1157 }
1158
1159 GlobalUnlock(data);
1160
1161 return ret;
1162 }
1163
1164
1165 /**************************************************************************
1166 * export_hdrop_to_filenames
1167 *
1168 * Export CF_HDROP to NSFilenamesPboardType data, which is a CFArray of
1169 * CFStrings (holding Unix paths) which is serialized as a property list.
1170 */
1171 static CFDataRef export_hdrop_to_filenames(HANDLE data)
1172 {
1173 CFDataRef ret = NULL;
1174 DROPFILES *dropfiles;
1175 CFMutableArrayRef filenames = NULL;
1176 void *p;
1177 WCHAR *buffer = NULL;
1178 size_t buffer_len = 0;
1179
1180 TRACE("data %p\n", data);
1181
1182 if (!(dropfiles = GlobalLock(data)))
1183 {
1184 WARN("failed to lock data %p\n", data);
1185 goto done;
1186 }
1187
1188 filenames = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
1189 if (!filenames)
1190 {
1191 WARN("failed to create filenames array\n");
1192 goto done;
1193 }
1194
1195 p = (char*)dropfiles + dropfiles->pFiles;
1196 while (dropfiles->fWide ? *(WCHAR*)p : *(char*)p)
1197 {
1198 char *unixname;
1199 CFStringRef filename;
1200
1201 TRACE(" %s\n", dropfiles->fWide ? debugstr_w(p) : debugstr_a(p));
1202
1203 if (dropfiles->fWide)
1204 unixname = wine_get_unix_file_name(p);
1205 else
1206 {
1207 int len = MultiByteToWideChar(CP_ACP, 0, p, -1, NULL, 0);
1208 if (len)
1209 {
1210 if (len > buffer_len)
1211 {
1212 HeapFree(GetProcessHeap(), 0, buffer);
1213 buffer_len = len * 2;
1214 buffer = HeapAlloc(GetProcessHeap(), 0, buffer_len * sizeof(*buffer));
1215 }
1216
1217 MultiByteToWideChar(CP_ACP, 0, p, -1, buffer, buffer_len);
1218 unixname = wine_get_unix_file_name(buffer);
1219 }
1220 else
1221 unixname = NULL;
1222 }
1223 if (!unixname)
1224 {
1225 WARN("failed to convert DOS path to Unix: %s\n",
1226 dropfiles->fWide ? debugstr_w(p) : debugstr_a(p));
1227 goto done;
1228 }
1229
1230 if (dropfiles->fWide)
1231 p = (WCHAR*)p + strlenW(p) + 1;
1232 else
1233 p = (char*)p + strlen(p) + 1;
1234
1235 filename = CFStringCreateWithFileSystemRepresentation(NULL, unixname);
1236 HeapFree(GetProcessHeap(), 0, unixname);
1237 if (!filename)
1238 {
1239 WARN("failed to create CFString from Unix path %s\n", debugstr_a(unixname));
1240 goto done;
1241 }
1242
1243 CFArrayAppendValue(filenames, filename);
1244 CFRelease(filename);
1245 }
1246
1247 ret = CFPropertyListCreateData(NULL, filenames, kCFPropertyListXMLFormat_v1_0, 0, NULL);
1248
1249 done:
1250 HeapFree(GetProcessHeap(), 0, buffer);
1251 GlobalUnlock(data);
1252 if (filenames) CFRelease(filenames);
1253 TRACE(" -> %s\n", debugstr_cf(ret));
1254 return ret;
1255 }
1256
1257
1258 /**************************************************************************
1259 * export_oemtext_to_utf8
1260 *
1261 * Export CF_OEMTEXT to UTF-8.
1262 */
1263 static CFDataRef export_oemtext_to_utf8(HANDLE data)
1264 {
1265 return export_codepage_to_utf8(data, CP_OEMCP);
1266 }
1267
1268
1269 /**************************************************************************
1270 * export_oemtext_to_utf16
1271 *
1272 * Export CF_OEMTEXT to UTF-16.
1273 */
1274 static CFDataRef export_oemtext_to_utf16(HANDLE data)
1275 {
1276 return export_codepage_to_utf16(data, CP_OEMCP);
1277 }
1278
1279
1280 /**************************************************************************
1281 * export_text_to_utf8
1282 *
1283 * Export CF_TEXT to UTF-8.
1284 */
1285 static CFDataRef export_text_to_utf8(HANDLE data)
1286 {
1287 return export_codepage_to_utf8(data, CP_ACP);
1288 }
1289
1290
1291 /**************************************************************************
1292 * export_text_to_utf16
1293 *
1294 * Export CF_TEXT to UTF-16.
1295 */
1296 static CFDataRef export_text_to_utf16(HANDLE data)
1297 {
1298 return export_codepage_to_utf16(data, CP_ACP);
1299 }
1300
1301
1302 /**************************************************************************
1303 * export_unicodetext_to_utf8
1304 *
1305 * Export CF_UNICODETEXT to UTF-8.
1306 */
1307 static CFDataRef export_unicodetext_to_utf8(HANDLE data)
1308 {
1309 CFMutableDataRef ret;
1310 LPVOID src;
1311 INT dst_len;
1312
1313 src = GlobalLock(data);
1314 if (!src) return NULL;
1315
1316 dst_len = WideCharToMultiByte(CP_UTF8, 0, src, -1, NULL, 0, NULL, NULL);
1317 if (dst_len) dst_len--; /* Leave off null terminator. */
1318 ret = CFDataCreateMutable(NULL, dst_len);
1319 if (ret)
1320 {
1321 LPSTR dst;
1322 int i, j;
1323
1324 CFDataSetLength(ret, dst_len);
1325 dst = (LPSTR)CFDataGetMutableBytePtr(ret);
1326 WideCharToMultiByte(CP_UTF8, 0, src, -1, dst, dst_len, NULL, NULL);
1327
1328 /* Remove carriage returns */
1329 for (i = 0, j = 0; i < dst_len; i++)
1330 {
1331 if (dst[i] == '\r' &&
1332 (i + 1 >= dst_len || dst[i + 1] == '\n' || dst[i + 1] == '\0'))
1333 continue;
1334 dst[j++] = dst[i];
1335 }
1336 CFDataSetLength(ret, j);
1337 }
1338 GlobalUnlock(data);
1339
1340 return ret;
1341 }
1342
1343
1344 /**************************************************************************
1345 * export_unicodetext_to_utf16
1346 *
1347 * Export CF_UNICODETEXT to UTF-16.
1348 */
1349 static CFDataRef export_unicodetext_to_utf16(HANDLE data)
1350 {
1351 CFMutableDataRef ret;
1352 const WCHAR *src;
1353 INT src_len;
1354
1355 src = GlobalLock(data);
1356 if (!src) return NULL;
1357
1358 src_len = GlobalSize(data) / sizeof(WCHAR);
1359 if (src_len) src_len--; /* Leave off null terminator. */
1360 ret = CFDataCreateMutable(NULL, src_len * sizeof(WCHAR));
1361 if (ret)
1362 {
1363 LPWSTR dst;
1364 int i, j;
1365
1366 CFDataSetLength(ret, src_len * sizeof(WCHAR));
1367 dst = (LPWSTR)CFDataGetMutableBytePtr(ret);
1368
1369 /* Remove carriage returns */
1370 for (i = 0, j = 0; i < src_len; i++)
1371 {
1372 if (src[i] == '\r' &&
1373 (i + 1 >= src_len || src[i + 1] == '\n' || src[i + 1] == '\0'))
1374 continue;
1375 dst[j++] = src[i];
1376 }
1377 CFDataSetLength(ret, j * sizeof(WCHAR));
1378 }
1379 GlobalUnlock(data);
1380
1381 return ret;
1382 }
1383
1384
1385 /**************************************************************************
1386 * get_clipboard_info
1387 */
1388 static BOOL get_clipboard_info(LPCLIPBOARDINFO cbinfo)
1389 {
1390 BOOL ret = FALSE;
1391
1392 SERVER_START_REQ(set_clipboard_info)
1393 {
1394 req->flags = 0;
1395
1396 if (wine_server_call_err(req))
1397 {
1398 ERR("Failed to get clipboard owner.\n");
1399 }
1400 else
1401 {
1402 cbinfo->hwnd_owner = wine_server_ptr_handle(reply->old_owner);
1403 cbinfo->flags = reply->flags;
1404
1405 ret = TRUE;
1406 }
1407 }
1408 SERVER_END_REQ;
1409
1410 return ret;
1411 }
1412
1413
1414 /**************************************************************************
1415 * release_ownership
1416 */
1417 static BOOL release_ownership(void)
1418 {
1419 BOOL ret = FALSE;
1420
1421 SERVER_START_REQ(set_clipboard_info)
1422 {
1423 req->flags = SET_CB_RELOWNER | SET_CB_SEQNO;
1424
1425 if (wine_server_call_err(req))
1426 ERR("Failed to set clipboard.\n");
1427 else
1428 ret = TRUE;
1429 }
1430 SERVER_END_REQ;
1431
1432 return ret;
1433 }
1434
1435
1436 /**************************************************************************
1437 * macdrv_get_pasteboard_data
1438 */
1439 HANDLE macdrv_get_pasteboard_data(CFTypeRef pasteboard, UINT desired_format)
1440 {
1441 CFArrayRef types;
1442 CFIndex count;
1443 CFIndex i;
1444 CFStringRef type, best_type;
1445 WINE_CLIPFORMAT* best_format = NULL;
1446 HANDLE data = NULL;
1447
1448 TRACE("pasteboard %p, desired_format %s\n", pasteboard, debugstr_format(desired_format));
1449
1450 types = macdrv_copy_pasteboard_types(pasteboard);
1451 if (!types)
1452 {
1453 WARN("Failed to copy pasteboard types\n");
1454 return NULL;
1455 }
1456
1457 count = CFArrayGetCount(types);
1458 TRACE("got %ld types\n", count);
1459
1460 for (i = 0; (!best_format || best_format->synthesized) && i < count; i++)
1461 {
1462 WINE_CLIPFORMAT* format;
1463
1464 type = CFArrayGetValueAtIndex(types, i);
1465
1466 format = NULL;
1467 while ((!best_format || best_format->synthesized) && (format = format_for_type(format, type)))
1468 {
1469 TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format ? format->format_id : 0));
1470
1471 if (format->format_id == desired_format)
1472 {
1473 /* The best format is the matching one which is not synthesized. Failing that,
1474 the best format is the first matching synthesized format. */
1475 if (!format->synthesized || !best_format)
1476 {
1477 best_type = type;
1478 best_format = format;
1479 }
1480 }
1481 }
1482 }
1483
1484 if (best_format)
1485 {
1486 CFDataRef pasteboard_data = macdrv_copy_pasteboard_data(pasteboard, best_type);
1487
1488 TRACE("got pasteboard data for type %s: %s\n", debugstr_cf(best_type), debugstr_cf(pasteboard_data));
1489
1490 if (pasteboard_data)
1491 {
1492 data = best_format->import_func(pasteboard_data);
1493 CFRelease(pasteboard_data);
1494 }
1495 }
1496
1497 CFRelease(types);
1498 TRACE(" -> %p\n", data);
1499 return data;
1500 }
1501
1502
1503 /**************************************************************************
1504 * macdrv_pasteboard_has_format
1505 */
1506 BOOL macdrv_pasteboard_has_format(CFTypeRef pasteboard, UINT desired_format)
1507 {
1508 CFArrayRef types;
1509 int count;
1510 UINT i;
1511 BOOL found = FALSE;
1512
1513 TRACE("pasteboard %p, desired_format %s\n", pasteboard, debugstr_format(desired_format));
1514
1515 types = macdrv_copy_pasteboard_types(pasteboard);
1516 if (!types)
1517 {
1518 WARN("Failed to copy pasteboard types\n");
1519 return FALSE;
1520 }
1521
1522 count = CFArrayGetCount(types);
1523 TRACE("got %d types\n", count);
1524
1525 for (i = 0; !found && i < count; i++)
1526 {
1527 CFStringRef type = CFArrayGetValueAtIndex(types, i);
1528 WINE_CLIPFORMAT* format;
1529
1530 format = NULL;
1531 while (!found && (format = format_for_type(format, type)))
1532 {
1533 TRACE("for type %s got format %s\n", debugstr_cf(type), debugstr_format(format->format_id));
1534
1535 if (format->format_id == desired_format)
1536 found = TRUE;
1537 }
1538 }
1539
1540 CFRelease(types);
1541 TRACE(" -> %d\n", found);
1542 return found;
1543 }
1544
1545
1546 /**************************************************************************
1547 * macdrv_copy_pasteboard_formats
1548 */
1549 CFArrayRef macdrv_copy_pasteboard_formats(CFTypeRef pasteboard)
1550 {
1551 CFArrayRef types;
1552 CFIndex count;
1553 CFMutableArrayRef formats;
1554 CFIndex i;
1555
1556 TRACE("pasteboard %p\n", pasteboard);
1557
1558 types = macdrv_copy_pasteboard_types(pasteboard);
1559 if (!types)
1560 {
1561 WARN("Failed to copy pasteboard types\n");
1562 return NULL;
1563 }
1564
1565 count = CFArrayGetCount(types);
1566 TRACE("got %ld types\n", count);
1567
1568 if (!count)
1569 {
1570 CFRelease(types);
1571 return NULL;
1572 }
1573
1574 formats = CFArrayCreateMutable(NULL, 0, NULL);
1575 if (!formats)
1576 {
1577 WARN("Failed to allocate formats array\n");
1578 CFRelease(types);
1579 return NULL;
1580 }
1581
1582 for (i = 0; i < count; i++)
1583 {
1584 CFStringRef type = CFArrayGetValueAtIndex(types, i);
1585 WINE_CLIPFORMAT* format;
1586
1587 format = NULL;
1588 while ((format = format_for_type(format, type)))
1589 {
1590 TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1591
1592 if (format->synthesized)
1593 {
1594 /* Don't override a real value with a synthesized value. */
1595 if (!CFArrayContainsValue(formats, CFRangeMake(0, CFArrayGetCount(formats)), (void*)format->format_id))
1596 CFArrayAppendValue(formats, (void*)format->format_id);
1597 }
1598 else
1599 {
1600 /* If the type was already in the array, it must have been synthesized
1601 because this one's real. Remove the synthesized entry in favor of
1602 this one. */
1603 CFIndex index = CFArrayGetFirstIndexOfValue(formats, CFRangeMake(0, CFArrayGetCount(formats)),
1604 (void*)format->format_id);
1605 if (index != kCFNotFound)
1606 CFArrayRemoveValueAtIndex(formats, index);
1607 CFArrayAppendValue(formats, (void*)format->format_id);
1608 }
1609 }
1610 }
1611
1612 CFRelease(types);
1613
1614 TRACE(" -> %s\n", debugstr_cf(formats));
1615 return formats;
1616 }
1617
1618
1619 /**************************************************************************
1620 * check_clipboard_ownership
1621 */
1622 static void check_clipboard_ownership(HWND *owner)
1623 {
1624 CLIPBOARDINFO cbinfo;
1625
1626 if (owner) *owner = NULL;
1627
1628 /* If Wine thinks we're the clipboard owner but Mac OS X thinks we're not
1629 the pasteboard owner, update Wine. */
1630 if (get_clipboard_info(&cbinfo) && (cbinfo.flags & CB_PROCESS))
1631 {
1632 if (!(cbinfo.flags & CB_OPEN) && !macdrv_is_pasteboard_owner())
1633 {
1634 TRACE("Lost clipboard ownership\n");
1635
1636 if (OpenClipboard(cbinfo.hwnd_owner))
1637 {
1638 /* Destroy private objects */
1639 SendMessageW(cbinfo.hwnd_owner, WM_DESTROYCLIPBOARD, 0, 0);
1640
1641 /* Give up ownership of the windows clipboard */
1642 release_ownership();
1643 CloseClipboard();
1644 }
1645 }
1646 else if (owner)
1647 *owner = cbinfo.hwnd_owner;
1648 }
1649 }
1650
1651
1652 /**************************************************************************
1653 * Mac User Driver Clipboard Exports
1654 **************************************************************************/
1655
1656
1657 /**************************************************************************
1658 * AcquireClipboard (MACDRV.@)
1659 */
1660 int CDECL macdrv_AcquireClipboard(HWND hwnd)
1661 {
1662 TRACE("hwnd %p\n", hwnd);
1663 check_clipboard_ownership(NULL);
1664 return 0;
1665 }
1666
1667
1668 /**************************************************************************
1669 * CountClipboardFormats (MACDRV.@)
1670 */
1671 INT CDECL macdrv_CountClipboardFormats(void)
1672 {
1673 CFMutableSetRef seen_formats;
1674 CFArrayRef types;
1675 CFIndex count;
1676 CFIndex i;
1677 INT ret = 0;
1678
1679 TRACE("()\n");
1680 check_clipboard_ownership(NULL);
1681
1682 seen_formats = CFSetCreateMutable(NULL, 0, NULL);
1683 if (!seen_formats)
1684 {
1685 WARN("Failed to allocate set to track seen formats\n");
1686 return 0;
1687 }
1688
1689 types = macdrv_copy_pasteboard_types(NULL);
1690 if (!types)
1691 {
1692 WARN("Failed to copy pasteboard types\n");
1693 CFRelease(seen_formats);
1694 return 0;
1695 }
1696
1697 count = CFArrayGetCount(types);
1698 TRACE("got %ld types\n", count);
1699
1700 for (i = 0; i < count; i++)
1701 {
1702 CFStringRef type = CFArrayGetValueAtIndex(types, i);
1703 WINE_CLIPFORMAT* format;
1704
1705 format = NULL;
1706 while ((format = format_for_type(format, type)))
1707 {
1708 TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1709
1710 if (!CFSetContainsValue(seen_formats, (void*)format->format_id))
1711 {
1712 ret++;
1713 CFSetAddValue(seen_formats, (void*)format->format_id);
1714 }
1715 }
1716 }
1717
1718 CFRelease(types);
1719 CFRelease(seen_formats);
1720 TRACE(" -> %d\n", ret);
1721 return ret;
1722 }
1723
1724
1725 /**************************************************************************
1726 * EmptyClipboard (MACDRV.@)
1727 *
1728 * Empty cached clipboard data.
1729 */
1730 void CDECL macdrv_EmptyClipboard(BOOL keepunowned)
1731 {
1732 TRACE("keepunowned %d\n", keepunowned);
1733 macdrv_clear_pasteboard();
1734 }
1735
1736
1737 /**************************************************************************
1738 * EndClipboardUpdate (MACDRV.@)
1739 */
1740 void CDECL macdrv_EndClipboardUpdate(void)
1741 {
1742 TRACE("()\n");
1743 check_clipboard_ownership(NULL);
1744 }
1745
1746
1747 /**************************************************************************
1748 * EnumClipboardFormats (MACDRV.@)
1749 */
1750 UINT CDECL macdrv_EnumClipboardFormats(UINT prev_format)
1751 {
1752 CFIndex count;
1753 CFIndex i;
1754 UINT ret = 0;
1755
1756 TRACE("prev_format %s\n", debugstr_format(prev_format));
1757 check_clipboard_ownership(NULL);
1758
1759 if (prev_format)
1760 {
1761 CFArrayRef formats = macdrv_copy_pasteboard_formats(NULL);
1762 if (formats)
1763 {
1764 count = CFArrayGetCount(formats);
1765 i = CFArrayGetFirstIndexOfValue(formats, CFRangeMake(0, count), (void*)prev_format);
1766 if (i != kCFNotFound && i + 1 < count)
1767 ret = (UINT)CFArrayGetValueAtIndex(formats, i + 1);
1768
1769 CFRelease(formats);
1770 }
1771 }
1772 else
1773 {
1774 CFArrayRef types = macdrv_copy_pasteboard_types(NULL);
1775 if (types)
1776 {
1777 count = CFArrayGetCount(types);
1778 TRACE("got %ld types\n", count);
1779
1780 if (count)
1781 {
1782 CFStringRef type = CFArrayGetValueAtIndex(types, 0);
1783 WINE_CLIPFORMAT *format = format_for_type(NULL, type);
1784
1785 ret = format ? format->format_id : 0;
1786 }
1787
1788 CFRelease(types);
1789 }
1790 else
1791 WARN("Failed to copy pasteboard types\n");
1792 }
1793
1794 TRACE(" -> %u\n", ret);
1795 return ret;
1796 }
1797
1798
1799 /**************************************************************************
1800 * GetClipboardData (MACDRV.@)
1801 */
1802 HANDLE CDECL macdrv_GetClipboardData(UINT desired_format)
1803 {
1804 check_clipboard_ownership(NULL);
1805
1806 return macdrv_get_pasteboard_data(NULL, desired_format);
1807 }
1808
1809
1810 /**************************************************************************
1811 * IsClipboardFormatAvailable (MACDRV.@)
1812 */
1813 BOOL CDECL macdrv_IsClipboardFormatAvailable(UINT desired_format)
1814 {
1815 check_clipboard_ownership(NULL);
1816 return macdrv_pasteboard_has_format(NULL, desired_format);
1817 }
1818
1819
1820 /**************************************************************************
1821 * SetClipboardData (MACDRV.@)
1822 */
1823 BOOL CDECL macdrv_SetClipboardData(UINT format_id, HANDLE data, BOOL owner)
1824 {
1825 HWND hwnd_owner;
1826 macdrv_window window;
1827 WINE_CLIPFORMAT *format;
1828 CFDataRef cfdata = NULL;
1829
1830 check_clipboard_ownership(&hwnd_owner);
1831 window = macdrv_get_cocoa_window(GetAncestor(hwnd_owner, GA_ROOT), FALSE);
1832 TRACE("format_id %s data %p owner %d hwnd_owner %p window %p)\n", debugstr_format(format_id), data, owner, hwnd_owner, window);
1833
1834 /* Find the "natural" format for this format_id (the one which isn't
1835 synthesized from another type). */
1836 LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
1837 if (format->format_id == format_id && !format->synthesized) break;
1838
1839 if (&format->entry == &format_list && !(format = insert_clipboard_format(format_id, NULL)))
1840 {
1841 WARN("Failed to register clipboard format %s\n", debugstr_format(format_id));
1842 return FALSE;
1843 }
1844
1845 /* Export the data to the Mac pasteboard. */
1846 if (data)
1847 {
1848 if (!format->export_func || !(cfdata = format->export_func(data)))
1849 {
1850 WARN("Failed to export %s data to type %s\n", debugstr_format(format_id), debugstr_cf(format->type));
1851 return FALSE;
1852 }
1853 }
1854
1855 if (macdrv_set_pasteboard_data(format->type, cfdata, window))
1856 TRACE("Set pasteboard data for type %s: %s\n", debugstr_cf(format->type), debugstr_cf(cfdata));
1857 else
1858 {
1859 WARN("Failed to set pasteboard data for type %s: %s\n", debugstr_cf(format->type), debugstr_cf(cfdata));
1860 if (cfdata) CFRelease(cfdata);
1861 return FALSE;
1862 }
1863
1864 if (cfdata) CFRelease(cfdata);
1865
1866 /* Find any other formats for this format_id (the exportable synthesized ones). */
1867 LIST_FOR_EACH_ENTRY(format, &format_list, WINE_CLIPFORMAT, entry)
1868 {
1869 if (format->format_id == format_id && format->synthesized && format->export_func)
1870 {
1871 /* We have a synthesized format for this format ID. Add its type to the pasteboard. */
1872 TRACE("Synthesized from format %s: type %s\n", debugstr_format(format_id), debugstr_cf(format->type));
1873
1874 if (data)
1875 {
1876 cfdata = format->export_func(data);
1877 if (!cfdata)
1878 {
1879 WARN("Failed to export %s data to type %s\n", debugstr_format(format->format_id), debugstr_cf(format->type));
1880 continue;
1881 }
1882 }
1883 else
1884 cfdata = NULL;
1885
1886 if (macdrv_set_pasteboard_data(format->type, cfdata, window))
1887 TRACE(" ... set pasteboard data: %s\n", debugstr_cf(cfdata));
1888 else
1889 WARN(" ... failed to set pasteboard data: %s\n", debugstr_cf(cfdata));
1890
1891 if (cfdata) CFRelease(cfdata);
1892 }
1893 }
1894
1895 if (data)
1896 {
1897 /* FIXME: According to MSDN, the caller is entitled to lock and read from
1898 data until CloseClipboard is called. So, we should defer this cleanup. */
1899 if ((format_id >= CF_GDIOBJFIRST && format_id <= CF_GDIOBJLAST) ||
1900 format_id == CF_BITMAP ||
1901 format_id == CF_DIB ||
1902 format_id == CF_PALETTE)
1903 {
1904 DeleteObject(data);
1905 }
1906 else if (format_id == CF_METAFILEPICT)
1907 {
1908 DeleteMetaFile(((METAFILEPICT *)GlobalLock(data))->hMF);
1909 GlobalFree(data);
1910 }
1911 else if (format_id == CF_ENHMETAFILE)
1912 {
1913 DeleteEnhMetaFile(data);
1914 }
1915 else if (format_id < CF_PRIVATEFIRST || CF_PRIVATELAST < format_id)
1916 {
1917 GlobalFree(data);
1918 }
1919 }
1920
1921 return TRUE;
1922 }
1923
1924
1925 /**************************************************************************
1926 * MACDRV Private Clipboard Exports
1927 **************************************************************************/
1928
1929
1930 /**************************************************************************
1931 * macdrv_clipboard_process_attach
1932 */
1933 void macdrv_clipboard_process_attach(void)
1934 {
1935 UINT i;
1936 WINE_CLIPFORMAT *format;
1937
1938 /* Register built-in formats */
1939 for (i = 0; i < sizeof(builtin_format_ids)/sizeof(builtin_format_ids[0]); i++)
1940 {
1941 if (!(format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format)))) break;
1942 format->format_id = builtin_format_ids[i].id;
1943 format->type = CFRetain(builtin_format_ids[i].type);
1944 format->import_func = builtin_format_ids[i].import;
1945 format->export_func = builtin_format_ids[i].export;
1946 format->synthesized = builtin_format_ids[i].synthesized;
1947 list_add_tail(&format_list, &format->entry);
1948 }
1949
1950 /* Register known mappings between Windows formats and Mac types */
1951 for (i = 0; i < sizeof(builtin_format_names)/sizeof(builtin_format_names[0]); i++)
1952 {
1953 if (!(format = HeapAlloc(GetProcessHeap(), 0, sizeof(*format)))) break;
1954 format->format_id = RegisterClipboardFormatW(builtin_format_names[i].name);
1955 format->type = CFRetain(builtin_format_names[i].type);
1956 format->import_func = builtin_format_names[i].import;
1957 format->export_func = builtin_format_names[i].export;
1958 format->synthesized = FALSE;
1959 list_add_tail(&format_list, &format->entry);
1960 }
1961 }
1962
1963
1964 /**************************************************************************
1965 * query_pasteboard_data
1966 */
1967 BOOL query_pasteboard_data(HWND hwnd, CFStringRef type)
1968 {
1969 BOOL ret = FALSE;
1970 CLIPBOARDINFO cbinfo;
1971 WINE_CLIPFORMAT* format;
1972 CFArrayRef types = NULL;
1973 CFRange range;
1974
1975 TRACE("hwnd %p type %s\n", hwnd, debugstr_cf(type));
1976
1977 if (get_clipboard_info(&cbinfo))
1978 hwnd = cbinfo.hwnd_owner;
1979
1980 format = NULL;
1981 while ((format = format_for_type(format, type)))
1982 {
1983 WINE_CLIPFORMAT* base_format;
1984
1985 TRACE("for type %s got format %p/%s\n", debugstr_cf(type), format, debugstr_format(format->format_id));
1986
1987 if (!format->synthesized)
1988 {
1989 TRACE("Sending WM_RENDERFORMAT message for format %s to hwnd %p\n", debugstr_format(format->format_id), hwnd);
1990 SendMessageW(hwnd, WM_RENDERFORMAT, format->format_id, 0);
1991 ret = TRUE;
1992 goto done;
1993 }
1994
1995 if (!types)
1996 {
1997 types = macdrv_copy_pasteboard_types(NULL);
1998 if (!types)
1999 {
2000 WARN("Failed to copy pasteboard types\n");
2001 break;
2002 }
2003
2004 range = CFRangeMake(0, CFArrayGetCount(types));
2005 }
2006
2007 /* The type maps to a synthesized format. Now look up what type that format maps to natively
2008 (not synthesized). For example, if type is "public.utf8-plain-text", then this format may
2009 have an ID of CF_TEXT. From CF_TEXT, we want to find "org.winehq.builtin.text" to see if
2010 that type is present in the pasteboard. If it is, then the app must have promised it and
2011 we can ask it to render it. (If it had put it on the clipboard immediately, then the
2012 pasteboard would also have data for "public.utf8-plain-text" and we wouldn't be here.) If
2013 "org.winehq.builtin.text" is not on the pasteboard, then one of the other text formats is
2014 presumably responsible for the promise that we're trying to satisfy, so we keep looking. */
2015 LIST_FOR_EACH_ENTRY(base_format, &format_list, WINE_CLIPFORMAT, entry)
2016 {
2017 if (base_format->format_id == format->format_id && !base_format->synthesized &&
2018 CFArrayContainsValue(types, range, base_format->type))
2019 {
2020 TRACE("Sending WM_RENDERFORMAT message for format %s to hwnd %p\n", debugstr_format(base_format->format_id), hwnd);
2021 SendMessageW(hwnd, WM_RENDERFORMAT, base_format->format_id, 0);
2022 ret = TRUE;
2023 goto done;
2024 }
2025 }
2026 }
2027
2028 done:
2029 if (types) CFRelease(types);
2030
2031 return ret;
2032 }
Windows API implementation