1 /*
2 * XDND handler code
3 *
4 * Copyright 2003 Ulrich Czekalla
5 * Copyright 2007 Damjan Jovanovic
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <string.h>
26 #ifdef HAVE_UNISTD_H
27 # include <unistd.h>
28 #endif
29 #include <stdarg.h>
30 #include <stdio.h>
31
32 #define NONAMELESSUNION
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "wingdi.h"
37 #include "winuser.h"
38
39 #define COBJMACROS
40 #include "x11drv.h"
41 #include "shlobj.h" /* DROPFILES */
42 #include "oleidl.h"
43 #include "objidl.h"
44
45 #include "wine/unicode.h"
46 #include "wine/debug.h"
47 #include "wine/list.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(xdnd);
50
51 /* Maximum wait time for selection notify */
52 #define SELECTION_RETRIES 500 /* wait for .1 seconds */
53 #define SELECTION_WAIT 1000 /* us */
54
55 typedef struct tagXDNDDATA
56 {
57 int cf_win;
58 Atom cf_xdnd;
59 void *data;
60 unsigned int size;
61 struct list entry;
62 } XDNDDATA, *LPXDNDDATA;
63
64 static struct list xdndData = LIST_INIT(xdndData);
65 static POINT XDNDxy = { 0, 0 };
66 static IDataObject XDNDDataObject;
67 static BOOL XDNDAccepted = FALSE;
68 static DWORD XDNDDropEffect = DROPEFFECT_NONE;
69 /* the last window the mouse was over */
70 static HWND XDNDLastTargetWnd;
71 /* might be a ancestor of XDNDLastTargetWnd */
72 static HWND XDNDLastDropTargetWnd;
73
74 static void X11DRV_XDND_InsertXDNDData(int property, int format, void* data, unsigned int len);
75 static int X11DRV_XDND_DeconstructTextURIList(int property, void* data, int len);
76 static int X11DRV_XDND_DeconstructTextPlain(int property, void* data, int len);
77 static int X11DRV_XDND_DeconstructTextHTML(int property, void* data, int len);
78 static int X11DRV_XDND_MapFormat(unsigned int property, unsigned char *data, int len);
79 static void X11DRV_XDND_ResolveProperty(Display *display, Window xwin, Time tm,
80 Atom *types, unsigned long *count);
81 static void X11DRV_XDND_SendDropFiles(HWND hwnd);
82 static void X11DRV_XDND_FreeDragDropOp(void);
83 static unsigned int X11DRV_XDND_UnixToDos(char** lpdest, char* lpsrc, int len);
84 static WCHAR* X11DRV_XDND_URIToDOS(char *encodedURI);
85
86 static CRITICAL_SECTION xdnd_cs;
87 static CRITICAL_SECTION_DEBUG critsect_debug =
88 {
89 0, 0, &xdnd_cs,
90 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
91 0, 0, { (DWORD_PTR)(__FILE__ ": xdnd_cs") }
92 };
93 static CRITICAL_SECTION xdnd_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
94
95
96 /* Based on functions in dlls/ole32/ole2.c */
97 static HANDLE get_droptarget_local_handle(HWND hwnd)
98 {
99 static const WCHAR prop_marshalleddroptarget[] =
100 {'W','i','n','e','M','a','r','s','h','a','l','l','e','d','D','r','o','p','T','a','r','g','e','t',0};
101 HANDLE handle;
102 HANDLE local_handle = 0;
103
104 handle = GetPropW(hwnd, prop_marshalleddroptarget);
105 if (handle)
106 {
107 DWORD pid;
108 HANDLE process;
109
110 GetWindowThreadProcessId(hwnd, &pid);
111 process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
112 if (process)
113 {
114 DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
115 CloseHandle(process);
116 }
117 }
118 return local_handle;
119 }
120
121 static HRESULT create_stream_from_map(HANDLE map, IStream **stream)
122 {
123 HRESULT hr = E_OUTOFMEMORY;
124 HGLOBAL hmem;
125 void *data;
126 MEMORY_BASIC_INFORMATION info;
127
128 data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
129 if(!data) return hr;
130
131 VirtualQuery(data, &info, sizeof(info));
132 TRACE("size %d\n", (int)info.RegionSize);
133
134 hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
135 if(hmem)
136 {
137 memcpy(GlobalLock(hmem), data, info.RegionSize);
138 GlobalUnlock(hmem);
139 hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
140 }
141 UnmapViewOfFile(data);
142 return hr;
143 }
144
145 static IDropTarget* get_droptarget_pointer(HWND hwnd)
146 {
147 IDropTarget *droptarget = NULL;
148 HANDLE map;
149 IStream *stream;
150
151 map = get_droptarget_local_handle(hwnd);
152 if(!map) return NULL;
153
154 if(SUCCEEDED(create_stream_from_map(map, &stream)))
155 {
156 CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
157 IStream_Release(stream);
158 }
159 CloseHandle(map);
160 return droptarget;
161 }
162
163 /**************************************************************************
164 * X11DRV_XDND_XdndActionToDROPEFFECT
165 */
166 static DWORD X11DRV_XDND_XdndActionToDROPEFFECT(long action)
167 {
168 /* In Windows, nothing but the given effects is allowed.
169 * In X the given action is just a hint, and you can always
170 * XdndActionCopy and XdndActionPrivate, so be more permissive. */
171 if (action == x11drv_atom(XdndActionCopy))
172 return DROPEFFECT_COPY;
173 else if (action == x11drv_atom(XdndActionMove))
174 return DROPEFFECT_MOVE | DROPEFFECT_COPY;
175 else if (action == x11drv_atom(XdndActionLink))
176 return DROPEFFECT_LINK | DROPEFFECT_COPY;
177 else if (action == x11drv_atom(XdndActionAsk))
178 /* FIXME: should we somehow ask the user what to do here? */
179 return DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK;
180 FIXME("unknown action %ld, assuming DROPEFFECT_COPY\n", action);
181 return DROPEFFECT_COPY;
182 }
183
184 /**************************************************************************
185 * X11DRV_XDND_DROPEFFECTToXdndAction
186 */
187 static long X11DRV_XDND_DROPEFFECTToXdndAction(DWORD effect)
188 {
189 if (effect == DROPEFFECT_COPY)
190 return x11drv_atom(XdndActionCopy);
191 else if (effect == DROPEFFECT_MOVE)
192 return x11drv_atom(XdndActionMove);
193 else if (effect == DROPEFFECT_LINK)
194 return x11drv_atom(XdndActionLink);
195 FIXME("unknown drop effect %u, assuming XdndActionCopy\n", effect);
196 return x11drv_atom(XdndActionCopy);
197 }
198
199 /**************************************************************************
200 * X11DRV_XDND_EnterEvent
201 *
202 * Handle an XdndEnter event.
203 */
204 void X11DRV_XDND_EnterEvent( HWND hWnd, XClientMessageEvent *event )
205 {
206 int version;
207 Atom *xdndtypes;
208 unsigned long count = 0;
209
210 version = (event->data.l[1] & 0xFF000000) >> 24;
211 TRACE("ver(%d) check-XdndTypeList(%ld) data=%ld,%ld,%ld,%ld,%ld\n",
212 version, (event->data.l[1] & 1),
213 event->data.l[0], event->data.l[1], event->data.l[2],
214 event->data.l[3], event->data.l[4]);
215
216 if (version > WINE_XDND_VERSION)
217 {
218 TRACE("Ignores unsupported version\n");
219 return;
220 }
221
222 XDNDAccepted = FALSE;
223
224 /* If the source supports more than 3 data types we retrieve
225 * the entire list. */
226 if (event->data.l[1] & 1)
227 {
228 Atom acttype;
229 int actfmt;
230 unsigned long bytesret;
231
232 /* Request supported formats from source window */
233 wine_tsx11_lock();
234 XGetWindowProperty(event->display, event->data.l[0], x11drv_atom(XdndTypeList),
235 0, 65535, FALSE, AnyPropertyType, &acttype, &actfmt, &count,
236 &bytesret, (unsigned char**)&xdndtypes);
237 wine_tsx11_unlock();
238 }
239 else
240 {
241 count = 3;
242 xdndtypes = (Atom*) &event->data.l[2];
243 }
244
245 if (TRACE_ON(xdnd))
246 {
247 unsigned int i = 0;
248
249 wine_tsx11_lock();
250 for (; i < count; i++)
251 {
252 if (xdndtypes[i] != 0)
253 {
254 char * pn = XGetAtomName(event->display, xdndtypes[i]);
255 TRACE("XDNDEnterAtom %ld: %s\n", xdndtypes[i], pn);
256 XFree(pn);
257 }
258 }
259 wine_tsx11_unlock();
260 }
261
262 /* Do a one-time data read and cache results */
263 X11DRV_XDND_ResolveProperty(event->display, event->window,
264 event->data.l[1], xdndtypes, &count);
265
266 if (event->data.l[1] & 1)
267 XFree(xdndtypes);
268 }
269
270 /**************************************************************************
271 * X11DRV_XDND_PositionEvent
272 *
273 * Handle an XdndPosition event.
274 */
275 void X11DRV_XDND_PositionEvent( HWND hWnd, XClientMessageEvent *event )
276 {
277 XClientMessageEvent e;
278 int accept = 0; /* Assume we're not accepting */
279 IDropTarget *dropTarget = NULL;
280 DWORD effect;
281 POINTL pointl;
282 HWND targetWindow;
283 HRESULT hr;
284
285 XDNDxy.x = event->data.l[2] >> 16;
286 XDNDxy.y = event->data.l[2] & 0xFFFF;
287 XDNDxy.x += virtual_screen_rect.left;
288 XDNDxy.y += virtual_screen_rect.top;
289 targetWindow = WindowFromPoint(XDNDxy);
290
291 pointl.x = XDNDxy.x;
292 pointl.y = XDNDxy.y;
293 effect = X11DRV_XDND_XdndActionToDROPEFFECT(event->data.l[4]);
294
295 if (!XDNDAccepted || XDNDLastTargetWnd != targetWindow)
296 {
297 /* Notify OLE of DragEnter. Result determines if we accept */
298 HWND dropTargetWindow;
299
300 if (XDNDLastDropTargetWnd)
301 {
302 dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
303 if (dropTarget)
304 {
305 hr = IDropTarget_DragLeave(dropTarget);
306 if (FAILED(hr))
307 WARN("IDropTarget_DragLeave failed, error 0x%08X\n", hr);
308 IDropTarget_Release(dropTarget);
309 }
310 }
311 dropTargetWindow = targetWindow;
312 do
313 {
314 dropTarget = get_droptarget_pointer(dropTargetWindow);
315 } while (dropTarget == NULL && (dropTargetWindow = GetParent(dropTargetWindow)) != NULL);
316 XDNDLastTargetWnd = targetWindow;
317 XDNDLastDropTargetWnd = dropTargetWindow;
318 if (dropTarget)
319 {
320 hr = IDropTarget_DragEnter(dropTarget, &XDNDDataObject,
321 MK_LBUTTON, pointl, &effect);
322 if (SUCCEEDED(hr))
323 {
324 if (effect != DROPEFFECT_NONE)
325 {
326 XDNDAccepted = TRUE;
327 TRACE("the application accepted the drop\n");
328 }
329 else
330 TRACE("the application refused the drop\n");
331 }
332 else
333 WARN("IDropTarget_DragEnter failed, error 0x%08X\n", hr);
334 IDropTarget_Release(dropTarget);
335 }
336 }
337 if (XDNDAccepted && XDNDLastTargetWnd == targetWindow)
338 {
339 /* If drag accepted notify OLE of DragOver */
340 dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
341 if (dropTarget)
342 {
343 hr = IDropTarget_DragOver(dropTarget, MK_LBUTTON, pointl, &effect);
344 if (SUCCEEDED(hr))
345 XDNDDropEffect = effect;
346 else
347 WARN("IDropTarget_DragOver failed, error 0x%08X\n", hr);
348 IDropTarget_Release(dropTarget);
349 }
350 }
351
352 if (XDNDAccepted)
353 accept = 1;
354 if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
355 accept = 1;
356
357 TRACE("action req: %ld accept(%d) at x(%d),y(%d)\n",
358 event->data.l[4], accept, XDNDxy.x, XDNDxy.y);
359
360 /*
361 * Let source know if we're accepting the drop by
362 * sending a status message.
363 */
364 e.type = ClientMessage;
365 e.display = event->display;
366 e.window = event->data.l[0];
367 e.message_type = x11drv_atom(XdndStatus);
368 e.format = 32;
369 e.data.l[0] = event->window;
370 e.data.l[1] = accept;
371 e.data.l[2] = 0; /* Empty Rect */
372 e.data.l[3] = 0; /* Empty Rect */
373 if (accept)
374 e.data.l[4] = X11DRV_XDND_DROPEFFECTToXdndAction(effect);
375 else
376 e.data.l[4] = None;
377 wine_tsx11_lock();
378 XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
379 wine_tsx11_unlock();
380 }
381
382 /**************************************************************************
383 * X11DRV_XDND_DropEvent
384 *
385 * Handle an XdndDrop event.
386 */
387 void X11DRV_XDND_DropEvent( HWND hWnd, XClientMessageEvent *event )
388 {
389 XClientMessageEvent e;
390 IDropTarget *dropTarget;
391
392 TRACE("\n");
393
394 /* If we have a HDROP type we send a WM_ACCEPTFILES.*/
395 if (GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES)
396 X11DRV_XDND_SendDropFiles( hWnd );
397
398 /* Notify OLE of Drop */
399 dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
400 if (dropTarget)
401 {
402 HRESULT hr;
403 POINTL pointl;
404 DWORD effect = XDNDDropEffect;
405
406 pointl.x = XDNDxy.x;
407 pointl.y = XDNDxy.y;
408 hr = IDropTarget_Drop(dropTarget, &XDNDDataObject, MK_LBUTTON,
409 pointl, &effect);
410 if (SUCCEEDED(hr))
411 {
412 if (effect != DROPEFFECT_NONE)
413 TRACE("drop succeeded\n");
414 else
415 TRACE("the application refused the drop\n");
416 }
417 else
418 WARN("drop failed, error 0x%08X\n", hr);
419 IDropTarget_Release(dropTarget);
420 }
421
422 X11DRV_XDND_FreeDragDropOp();
423
424 /* Tell the target we are finished. */
425 memset(&e, 0, sizeof(e));
426 e.type = ClientMessage;
427 e.display = event->display;
428 e.window = event->data.l[0];
429 e.message_type = x11drv_atom(XdndFinished);
430 e.format = 32;
431 e.data.l[0] = event->window;
432 wine_tsx11_lock();
433 XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
434 wine_tsx11_unlock();
435 }
436
437 /**************************************************************************
438 * X11DRV_XDND_LeaveEvent
439 *
440 * Handle an XdndLeave event.
441 */
442 void X11DRV_XDND_LeaveEvent( HWND hWnd, XClientMessageEvent *event )
443 {
444 IDropTarget *dropTarget;
445
446 TRACE("DND Operation canceled\n");
447
448 /* Notify OLE of DragLeave */
449 dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
450 if (dropTarget)
451 {
452 HRESULT hr = IDropTarget_DragLeave(dropTarget);
453 if (FAILED(hr))
454 WARN("IDropTarget_DragLeave failed, error 0x%08X\n", hr);
455 IDropTarget_Release(dropTarget);
456 }
457
458 X11DRV_XDND_FreeDragDropOp();
459 }
460
461
462 /**************************************************************************
463 * X11DRV_XDND_ResolveProperty
464 *
465 * Resolve all MIME types to windows clipboard formats. All data is cached.
466 */
467 static void X11DRV_XDND_ResolveProperty(Display *display, Window xwin, Time tm,
468 Atom *types, unsigned long *count)
469 {
470 unsigned int i, j;
471 BOOL res;
472 XEvent xe;
473 Atom acttype;
474 int actfmt;
475 unsigned long bytesret, icount;
476 int entries = 0;
477 unsigned char* data = NULL;
478 XDNDDATA *current, *next;
479 BOOL haveHDROP = FALSE;
480
481 TRACE("count(%ld)\n", *count);
482
483 X11DRV_XDND_FreeDragDropOp(); /* Clear previously cached data */
484
485 for (i = 0; i < *count; i++)
486 {
487 TRACE("requesting atom %ld from xwin %ld\n", types[i], xwin);
488
489 if (types[i] == 0)
490 continue;
491
492 wine_tsx11_lock();
493 XConvertSelection(display, x11drv_atom(XdndSelection), types[i],
494 x11drv_atom(XdndTarget), xwin, /*tm*/CurrentTime);
495 wine_tsx11_unlock();
496
497 /*
498 * Wait for SelectionNotify
499 */
500 for (j = 0; j < SELECTION_RETRIES; j++)
501 {
502 wine_tsx11_lock();
503 res = XCheckTypedWindowEvent(display, xwin, SelectionNotify, &xe);
504 wine_tsx11_unlock();
505 if (res && xe.xselection.selection == x11drv_atom(XdndSelection)) break;
506
507 usleep(SELECTION_WAIT);
508 }
509
510 if (xe.xselection.property == None)
511 continue;
512
513 wine_tsx11_lock();
514 XGetWindowProperty(display, xwin, x11drv_atom(XdndTarget), 0, 65535, FALSE,
515 AnyPropertyType, &acttype, &actfmt, &icount, &bytesret, &data);
516 wine_tsx11_unlock();
517
518 entries += X11DRV_XDND_MapFormat(types[i], data, get_property_size( actfmt, icount ));
519 wine_tsx11_lock();
520 XFree(data);
521 wine_tsx11_unlock();
522 }
523
524 /* On Windows when there is a CF_HDROP, there are no other CF_ formats.
525 * foobar2000 relies on this (spaces -> %20's without it).
526 */
527 LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
528 {
529 if (current->cf_win == CF_HDROP)
530 {
531 haveHDROP = TRUE;
532 break;
533 }
534 }
535 if (haveHDROP)
536 {
537 LIST_FOR_EACH_ENTRY_SAFE(current, next, &xdndData, XDNDDATA, entry)
538 {
539 if (current->cf_win != CF_HDROP && current->cf_win < CF_MAX)
540 {
541 list_remove(¤t->entry);
542 HeapFree(GetProcessHeap(), 0, current->data);
543 HeapFree(GetProcessHeap(), 0, current);
544 --entries;
545 }
546 }
547 }
548
549 *count = entries;
550 }
551
552
553 /**************************************************************************
554 * X11DRV_XDND_InsertXDNDData
555 *
556 * Cache available XDND property
557 */
558 static void X11DRV_XDND_InsertXDNDData(int property, int format, void* data, unsigned int len)
559 {
560 LPXDNDDATA current = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(XDNDDATA));
561
562 if (current)
563 {
564 EnterCriticalSection(&xdnd_cs);
565 current->cf_xdnd = property;
566 current->cf_win = format;
567 current->data = data;
568 current->size = len;
569 list_add_tail(&xdndData, ¤t->entry);
570 LeaveCriticalSection(&xdnd_cs);
571 }
572 }
573
574
575 /**************************************************************************
576 * X11DRV_XDND_MapFormat
577 *
578 * Map XDND MIME format to windows clipboard format.
579 */
580 static int X11DRV_XDND_MapFormat(unsigned int property, unsigned char *data, int len)
581 {
582 void* xdata;
583 int count = 0;
584
585 TRACE("%d: %s\n", property, data);
586
587 /* Always include the raw type */
588 xdata = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
589 memcpy(xdata, data, len);
590 X11DRV_XDND_InsertXDNDData(property, property, xdata, len);
591 count++;
592
593 if (property == x11drv_atom(text_uri_list))
594 count += X11DRV_XDND_DeconstructTextURIList(property, data, len);
595 else if (property == x11drv_atom(text_plain))
596 count += X11DRV_XDND_DeconstructTextPlain(property, data, len);
597 else if (property == x11drv_atom(text_html))
598 count += X11DRV_XDND_DeconstructTextHTML(property, data, len);
599
600 return count;
601 }
602
603
604 /**************************************************************************
605 * X11DRV_XDND_DeconstructTextURIList
606 *
607 * Interpret text/uri-list data and add records to <dndfmt> linked list
608 */
609 static int X11DRV_XDND_DeconstructTextURIList(int property, void* data, int len)
610 {
611 char *uriList = data;
612 char *uri;
613 WCHAR *path;
614
615 WCHAR *out = NULL;
616 int size = 0;
617 int capacity = 4096;
618
619 int count = 0;
620 int start = 0;
621 int end = 0;
622
623 out = HeapAlloc(GetProcessHeap(), 0, capacity * sizeof(WCHAR));
624 if (out == NULL)
625 return 0;
626
627 while (end < len)
628 {
629 while (end < len && uriList[end] != '\r')
630 ++end;
631 if (end < (len - 1) && uriList[end+1] != '\n')
632 {
633 WARN("URI list line doesn't end in \\r\\n\n");
634 break;
635 }
636
637 uri = HeapAlloc(GetProcessHeap(), 0, end - start + 1);
638 if (uri == NULL)
639 break;
640 lstrcpynA(uri, &uriList[start], end - start + 1);
641 path = X11DRV_XDND_URIToDOS(uri);
642 TRACE("converted URI %s to DOS path %s\n", debugstr_a(uri), debugstr_w(path));
643 HeapFree(GetProcessHeap(), 0, uri);
644
645 if (path)
646 {
647 int pathSize = strlenW(path) + 1;
648 if (pathSize > capacity-size)
649 {
650 capacity = 2*capacity + pathSize;
651 out = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, out, (capacity + 1)*sizeof(WCHAR));
652 if (out == NULL)
653 goto done;
654 }
655 memcpy(&out[size], path, pathSize * sizeof(WCHAR));
656 size += pathSize;
657 done:
658 HeapFree(GetProcessHeap(), 0, path);
659 if (out == NULL)
660 break;
661 }
662
663 start = end + 2;
664 end = start;
665 }
666 if (out && end >= len)
667 {
668 DROPFILES *dropFiles;
669 dropFiles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DROPFILES) + (size + 1)*sizeof(WCHAR));
670 if (dropFiles)
671 {
672 dropFiles->pFiles = sizeof(DROPFILES);
673 dropFiles->pt.x = XDNDxy.x;
674 dropFiles->pt.y = XDNDxy.y;
675 dropFiles->fNC = 0;
676 dropFiles->fWide = TRUE;
677 out[size] = '\0';
678 memcpy(((char*)dropFiles) + dropFiles->pFiles, out, (size + 1)*sizeof(WCHAR));
679 X11DRV_XDND_InsertXDNDData(property, CF_HDROP, dropFiles, sizeof(DROPFILES) + (size + 1)*sizeof(WCHAR));
680 count = 1;
681 }
682 }
683 HeapFree(GetProcessHeap(), 0, out);
684 return count;
685 }
686
687
688 /**************************************************************************
689 * X11DRV_XDND_DeconstructTextPlain
690 *
691 * Interpret text/plain Data and add records to <dndfmt> linked list
692 */
693 static int X11DRV_XDND_DeconstructTextPlain(int property, void* data, int len)
694 {
695 char* dostext;
696
697 /* Always supply plain text */
698 X11DRV_XDND_UnixToDos(&dostext, data, len);
699 X11DRV_XDND_InsertXDNDData(property, CF_TEXT, dostext, strlen(dostext));
700
701 TRACE("CF_TEXT (%d): %s\n", CF_TEXT, dostext);
702
703 return 1;
704 }
705
706
707 /**************************************************************************
708 * X11DRV_XDND_DeconstructTextHTML
709 *
710 * Interpret text/html data and add records to <dndfmt> linked list
711 */
712 static int X11DRV_XDND_DeconstructTextHTML(int property, void* data, int len)
713 {
714 char* dostext;
715
716 X11DRV_XDND_UnixToDos(&dostext, data, len);
717
718 X11DRV_XDND_InsertXDNDData(property,
719 RegisterClipboardFormatA("UniformResourceLocator"), dostext, strlen(dostext));
720
721 TRACE("UniformResourceLocator: %s\n", dostext);
722
723 return 1;
724 }
725
726
727 /**************************************************************************
728 * X11DRV_XDND_SendDropFiles
729 */
730 static void X11DRV_XDND_SendDropFiles(HWND hwnd)
731 {
732 LPXDNDDATA current = NULL;
733 BOOL found = FALSE;
734
735 EnterCriticalSection(&xdnd_cs);
736
737 /* Find CF_HDROP type if any */
738 LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
739 {
740 if (current->cf_win == CF_HDROP)
741 {
742 found = TRUE;
743 break;
744 }
745 }
746
747 if (found)
748 {
749 DROPFILES *lpDrop = current->data;
750
751 if (lpDrop)
752 {
753 lpDrop->pt.x = XDNDxy.x;
754 lpDrop->pt.y = XDNDxy.y;
755
756 TRACE("Sending WM_DROPFILES: hWnd(0x%p) %p(%s)\n", hwnd,
757 ((char*)lpDrop) + lpDrop->pFiles, debugstr_w((WCHAR*)(((char*)lpDrop) + lpDrop->pFiles)));
758
759 PostMessageW(hwnd, WM_DROPFILES, (WPARAM)lpDrop, 0L);
760 }
761 }
762
763 LeaveCriticalSection(&xdnd_cs);
764 }
765
766
767 /**************************************************************************
768 * X11DRV_XDND_FreeDragDropOp
769 */
770 static void X11DRV_XDND_FreeDragDropOp(void)
771 {
772 LPXDNDDATA next;
773 LPXDNDDATA current;
774
775 TRACE("\n");
776
777 EnterCriticalSection(&xdnd_cs);
778
779 /** Free data cache */
780 LIST_FOR_EACH_ENTRY_SAFE(current, next, &xdndData, XDNDDATA, entry)
781 {
782 list_remove(¤t->entry);
783 HeapFree(GetProcessHeap(), 0, current);
784 }
785
786 XDNDxy.x = XDNDxy.y = 0;
787 XDNDLastTargetWnd = NULL;
788 XDNDLastDropTargetWnd = NULL;
789 XDNDAccepted = FALSE;
790
791 LeaveCriticalSection(&xdnd_cs);
792 }
793
794
795
796 /**************************************************************************
797 * X11DRV_XDND_UnixToDos
798 */
799 static unsigned int X11DRV_XDND_UnixToDos(char** lpdest, char* lpsrc, int len)
800 {
801 int i;
802 unsigned int destlen, lines;
803
804 for (i = 0, lines = 0; i <= len; i++)
805 {
806 if (lpsrc[i] == '\n')
807 lines++;
808 }
809
810 destlen = len + lines + 1;
811
812 if (lpdest)
813 {
814 char* lpstr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, destlen);
815 for (i = 0, lines = 0; i <= len; i++)
816 {
817 if (lpsrc[i] == '\n')
818 lpstr[++lines + i] = '\r';
819 lpstr[lines + i] = lpsrc[i];
820 }
821
822 *lpdest = lpstr;
823 }
824
825 return lines;
826 }
827
828
829 /**************************************************************************
830 * X11DRV_XDND_URIToDOS
831 */
832 static WCHAR* X11DRV_XDND_URIToDOS(char *encodedURI)
833 {
834 WCHAR *ret = NULL;
835 int i;
836 int j = 0;
837 char *uri = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, strlen(encodedURI) + 1);
838 if (uri == NULL)
839 return NULL;
840 for (i = 0; encodedURI[i]; ++i)
841 {
842 if (encodedURI[i] == '%')
843 {
844 if (encodedURI[i+1] && encodedURI[i+2])
845 {
846 char buffer[3];
847 int number;
848 buffer[0] = encodedURI[i+1];
849 buffer[1] = encodedURI[i+2];
850 buffer[2] = '\0';
851 sscanf(buffer, "%x", &number);
852 uri[j++] = number;
853 i += 2;
854 }
855 else
856 {
857 WARN("invalid URI encoding in %s\n", debugstr_a(encodedURI));
858 HeapFree(GetProcessHeap(), 0, uri);
859 return NULL;
860 }
861 }
862 else
863 uri[j++] = encodedURI[i];
864 }
865
866 /* Read http://www.freedesktop.org/wiki/Draganddropwarts and cry... */
867 if (strncmp(uri, "file:/", 6) == 0)
868 {
869 if (uri[6] == '/')
870 {
871 if (uri[7] == '/')
872 {
873 /* file:///path/to/file (nautilus, thunar) */
874 ret = wine_get_dos_file_name(&uri[7]);
875 }
876 else if (uri[7])
877 {
878 /* file://hostname/path/to/file (X file drag spec) */
879 char hostname[256];
880 char *path = strchr(&uri[7], '/');
881 if (path)
882 {
883 *path = '\0';
884 if (strcmp(&uri[7], "localhost") == 0)
885 {
886 *path = '/';
887 ret = wine_get_dos_file_name(path);
888 }
889 else if (gethostname(hostname, sizeof(hostname)) == 0)
890 {
891 if (strcmp(hostname, &uri[7]) == 0)
892 {
893 *path = '/';
894 ret = wine_get_dos_file_name(path);
895 }
896 }
897 }
898 }
899 }
900 else if (uri[6])
901 {
902 /* file:/path/to/file (konqueror) */
903 ret = wine_get_dos_file_name(&uri[5]);
904 }
905 }
906 HeapFree(GetProcessHeap(), 0, uri);
907 return ret;
908 }
909
910
911 /**************************************************************************
912 * X11DRV_XDND_DescribeClipboardFormat
913 */
914 static void X11DRV_XDND_DescribeClipboardFormat(int cfFormat, char *buffer, int size)
915 {
916 #define D(x) case x: lstrcpynA(buffer, #x, size); return;
917 switch (cfFormat)
918 {
919 D(CF_TEXT)
920 D(CF_BITMAP)
921 D(CF_METAFILEPICT)
922 D(CF_SYLK)
923 D(CF_DIF)
924 D(CF_TIFF)
925 D(CF_OEMTEXT)
926 D(CF_DIB)
927 D(CF_PALETTE)
928 D(CF_PENDATA)
929 D(CF_RIFF)
930 D(CF_WAVE)
931 D(CF_UNICODETEXT)
932 D(CF_ENHMETAFILE)
933 D(CF_HDROP)
934 D(CF_LOCALE)
935 D(CF_DIBV5)
936 }
937 #undef D
938
939 if (CF_PRIVATEFIRST <= cfFormat && cfFormat <= CF_PRIVATELAST)
940 {
941 lstrcpynA(buffer, "some private object", size);
942 return;
943 }
944 if (CF_GDIOBJFIRST <= cfFormat && cfFormat <= CF_GDIOBJLAST)
945 {
946 lstrcpynA(buffer, "some GDI object", size);
947 return;
948 }
949
950 GetClipboardFormatNameA(cfFormat, buffer, size);
951 }
952
953
954 /* The IDataObject singleton we feed to OLE follows */
955
956 static HRESULT WINAPI XDNDDATAOBJECT_QueryInterface(IDataObject *dataObject,
957 REFIID riid, void **ppvObject)
958 {
959 TRACE("(%p, %s, %p)\n", dataObject, debugstr_guid(riid), ppvObject);
960 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDataObject))
961 {
962 *ppvObject = dataObject;
963 IDataObject_AddRef(dataObject);
964 return S_OK;
965 }
966 *ppvObject = NULL;
967 return E_NOINTERFACE;
968 }
969
970 static ULONG WINAPI XDNDDATAOBJECT_AddRef(IDataObject *dataObject)
971 {
972 TRACE("(%p)\n", dataObject);
973 return 2;
974 }
975
976 static ULONG WINAPI XDNDDATAOBJECT_Release(IDataObject *dataObject)
977 {
978 TRACE("(%p)\n", dataObject);
979 return 1;
980 }
981
982 static HRESULT WINAPI XDNDDATAOBJECT_GetData(IDataObject *dataObject,
983 FORMATETC *formatEtc,
984 STGMEDIUM *pMedium)
985 {
986 HRESULT hr;
987 char formatDesc[1024];
988
989 TRACE("(%p, %p, %p)\n", dataObject, formatEtc, pMedium);
990 X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat,
991 formatDesc, sizeof(formatDesc));
992 TRACE("application is looking for %s\n", formatDesc);
993
994 hr = IDataObject_QueryGetData(dataObject, formatEtc);
995 if (SUCCEEDED(hr))
996 {
997 XDNDDATA *current;
998 LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
999 {
1000 if (current->cf_win == formatEtc->cfFormat)
1001 {
1002 pMedium->tymed = TYMED_HGLOBAL;
1003 pMedium->u.hGlobal = HeapAlloc(GetProcessHeap(), 0, current->size);
1004 if (pMedium->u.hGlobal == NULL)
1005 return E_OUTOFMEMORY;
1006 memcpy(pMedium->u.hGlobal, current->data, current->size);
1007 pMedium->pUnkForRelease = 0;
1008 return S_OK;
1009 }
1010 }
1011 }
1012 return hr;
1013 }
1014
1015 static HRESULT WINAPI XDNDDATAOBJECT_GetDataHere(IDataObject *dataObject,
1016 FORMATETC *formatEtc,
1017 STGMEDIUM *pMedium)
1018 {
1019 FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, pMedium);
1020 return DATA_E_FORMATETC;
1021 }
1022
1023 static HRESULT WINAPI XDNDDATAOBJECT_QueryGetData(IDataObject *dataObject,
1024 FORMATETC *formatEtc)
1025 {
1026 char formatDesc[1024];
1027 XDNDDATA *current;
1028
1029 TRACE("(%p, %p={.tymed=0x%x, .dwAspect=%d, .cfFormat=%d}\n",
1030 dataObject, formatEtc, formatEtc->tymed, formatEtc->dwAspect, formatEtc->cfFormat);
1031 X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat, formatDesc, sizeof(formatDesc));
1032
1033 if (formatEtc->tymed && !(formatEtc->tymed & TYMED_HGLOBAL))
1034 {
1035 FIXME("only HGLOBAL medium types supported right now\n");
1036 return DV_E_TYMED;
1037 }
1038 if (formatEtc->dwAspect != DVASPECT_CONTENT)
1039 {
1040 FIXME("only the content aspect is supported right now\n");
1041 return E_NOTIMPL;
1042 }
1043
1044 LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
1045 {
1046 if (current->cf_win == formatEtc->cfFormat)
1047 {
1048 TRACE("application found %s\n", formatDesc);
1049 return S_OK;
1050 }
1051 }
1052 TRACE("application didn't find %s\n", formatDesc);
1053 return DV_E_FORMATETC;
1054 }
1055
1056 static HRESULT WINAPI XDNDDATAOBJECT_GetCanonicalFormatEtc(IDataObject *dataObject,
1057 FORMATETC *formatEtc,
1058 FORMATETC *formatEtcOut)
1059 {
1060 FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, formatEtcOut);
1061 formatEtcOut->ptd = NULL;
1062 return E_NOTIMPL;
1063 }
1064
1065 static HRESULT WINAPI XDNDDATAOBJECT_SetData(IDataObject *dataObject,
1066 FORMATETC *formatEtc,
1067 STGMEDIUM *pMedium, BOOL fRelease)
1068 {
1069 FIXME("(%p, %p, %p, %s): stub\n", dataObject, formatEtc,
1070 pMedium, fRelease?"TRUE":"FALSE");
1071 return E_NOTIMPL;
1072 }
1073
1074 static HRESULT WINAPI XDNDDATAOBJECT_EnumFormatEtc(IDataObject *dataObject,
1075 DWORD dwDirection,
1076 IEnumFORMATETC **ppEnumFormatEtc)
1077 {
1078 DWORD count;
1079 FORMATETC *formats;
1080
1081 TRACE("(%p, %u, %p)\n", dataObject, dwDirection, ppEnumFormatEtc);
1082
1083 if (dwDirection != DATADIR_GET)
1084 {
1085 FIXME("only the get direction is implemented\n");
1086 return E_NOTIMPL;
1087 }
1088
1089 count = list_count(&xdndData);
1090 formats = HeapAlloc(GetProcessHeap(), 0, count * sizeof(FORMATETC));
1091 if (formats)
1092 {
1093 XDNDDATA *current;
1094 DWORD i = 0;
1095 HRESULT hr;
1096 LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
1097 {
1098 formats[i].cfFormat = current->cf_win;
1099 formats[i].ptd = NULL;
1100 formats[i].dwAspect = DVASPECT_CONTENT;
1101 formats[i].lindex = -1;
1102 formats[i].tymed = TYMED_HGLOBAL;
1103 i++;
1104 }
1105 hr = SHCreateStdEnumFmtEtc(count, formats, ppEnumFormatEtc);
1106 HeapFree(GetProcessHeap(), 0, formats);
1107 return hr;
1108 }
1109 else
1110 return E_OUTOFMEMORY;
1111 }
1112
1113 static HRESULT WINAPI XDNDDATAOBJECT_DAdvise(IDataObject *dataObject,
1114 FORMATETC *formatEtc, DWORD advf,
1115 IAdviseSink *adviseSink,
1116 DWORD *pdwConnection)
1117 {
1118 FIXME("(%p, %p, %u, %p, %p): stub\n", dataObject, formatEtc, advf,
1119 adviseSink, pdwConnection);
1120 return OLE_E_ADVISENOTSUPPORTED;
1121 }
1122
1123 static HRESULT WINAPI XDNDDATAOBJECT_DUnadvise(IDataObject *dataObject,
1124 DWORD dwConnection)
1125 {
1126 FIXME("(%p, %u): stub\n", dataObject, dwConnection);
1127 return OLE_E_ADVISENOTSUPPORTED;
1128 }
1129
1130 static HRESULT WINAPI XDNDDATAOBJECT_EnumDAdvise(IDataObject *dataObject,
1131 IEnumSTATDATA **pEnumAdvise)
1132 {
1133 FIXME("(%p, %p): stub\n", dataObject, pEnumAdvise);
1134 return OLE_E_ADVISENOTSUPPORTED;
1135 }
1136
1137 static IDataObjectVtbl xdndDataObjectVtbl =
1138 {
1139 XDNDDATAOBJECT_QueryInterface,
1140 XDNDDATAOBJECT_AddRef,
1141 XDNDDATAOBJECT_Release,
1142 XDNDDATAOBJECT_GetData,
1143 XDNDDATAOBJECT_GetDataHere,
1144 XDNDDATAOBJECT_QueryGetData,
1145 XDNDDATAOBJECT_GetCanonicalFormatEtc,
1146 XDNDDATAOBJECT_SetData,
1147 XDNDDATAOBJECT_EnumFormatEtc,
1148 XDNDDATAOBJECT_DAdvise,
1149 XDNDDATAOBJECT_DUnadvise,
1150 XDNDDATAOBJECT_EnumDAdvise
1151 };
1152
1153 static IDataObject XDNDDataObject = { &xdndDataObjectVtbl };
1154
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.