mciavi: MCI_OPEN @NNNN should use an open AVIFile/Stream handle.
[wine] / dlls / winex11.drv / xdnd.c
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(&current->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, &current->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(&current->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 };