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 "shellapi.h"
  42 #include "shlobj.h"  /* DROPFILES */
  43 #include "oleidl.h"
  44 #include "objidl.h"
  45
  46 #include "wine/unicode.h"
  47 #include "wine/debug.h"
  48 #include "wine/list.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(xdnd);
  51
  52 typedef struct tagXDNDDATA
  53 {
  54     int cf_win;
  55     Atom cf_xdnd;
  56     HANDLE contents;
  57     struct list entry;
  58 } XDNDDATA, *LPXDNDDATA;
  59
  60 static struct list xdndData = LIST_INIT(xdndData);
  61 static POINT XDNDxy = { 0, 0 };
  62 static IDataObject XDNDDataObject;
  63 static BOOL XDNDAccepted = FALSE;
  64 static DWORD XDNDDropEffect = DROPEFFECT_NONE;
  65 /* the last window the mouse was over */
  66 static HWND XDNDLastTargetWnd;
  67 /* might be an ancestor of XDNDLastTargetWnd */
  68 static HWND XDNDLastDropTargetWnd;
  69
  70 static void X11DRV_XDND_InsertXDNDData( Atom property, UINT format, HANDLE contents );
  71 static void X11DRV_XDND_ResolveProperty(Display *display, Window xwin, Time tm,
  72     Atom *types, unsigned long count);
  73 static BOOL X11DRV_XDND_HasHDROP(void);
  74 static HRESULT X11DRV_XDND_SendDropFiles(HWND hwnd);
  75 static void X11DRV_XDND_FreeDragDropOp(void);
  76
  77 static CRITICAL_SECTION xdnd_cs;
  78 static CRITICAL_SECTION_DEBUG critsect_debug =
  79 {
  80     0, 0, &xdnd_cs,
  81     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  82       0, 0, { (DWORD_PTR)(__FILE__ ": xdnd_cs") }
  83 };
  84 static CRITICAL_SECTION xdnd_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
  85
  86
  87 /* Based on functions in dlls/ole32/ole2.c */
  88 static HANDLE get_droptarget_local_handle(HWND hwnd)
  89 {
  90     static const WCHAR prop_marshalleddroptarget[] =
  91         {'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};
  92     HANDLE handle;
  93     HANDLE local_handle = 0;
  94
  95     handle = GetPropW(hwnd, prop_marshalleddroptarget);
  96     if (handle)
  97     {
  98         DWORD pid;
  99         HANDLE process;
 100
 101         GetWindowThreadProcessId(hwnd, &pid);
 102         process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
 103         if (process)
 104         {
 105             DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
 106             CloseHandle(process);
 107         }
 108     }
 109     return local_handle;
 110 }
 111
 112 static HRESULT create_stream_from_map(HANDLE map, IStream **stream)
 113 {
 114     HRESULT hr = E_OUTOFMEMORY;
 115     HGLOBAL hmem;
 116     void *data;
 117     MEMORY_BASIC_INFORMATION info;
 118
 119     data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 120     if(!data) return hr;
 121
 122     VirtualQuery(data, &info, sizeof(info));
 123     TRACE("size %d\n", (int)info.RegionSize);
 124
 125     hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
 126     if(hmem)
 127     {
 128         memcpy(GlobalLock(hmem), data, info.RegionSize);
 129         GlobalUnlock(hmem);
 130         hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
 131     }
 132     UnmapViewOfFile(data);
 133     return hr;
 134 }
 135
 136 static IDropTarget* get_droptarget_pointer(HWND hwnd)
 137 {
 138     IDropTarget *droptarget = NULL;
 139     HANDLE map;
 140     IStream *stream;
 141
 142     map = get_droptarget_local_handle(hwnd);
 143     if(!map) return NULL;
 144
 145     if(SUCCEEDED(create_stream_from_map(map, &stream)))
 146     {
 147         CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
 148         IStream_Release(stream);
 149     }
 150     CloseHandle(map);
 151     return droptarget;
 152 }
 153
 154 /**************************************************************************
 155  * X11DRV_XDND_XdndActionToDROPEFFECT
 156  */
 157 static DWORD X11DRV_XDND_XdndActionToDROPEFFECT(long action)
 158 {
 159     /* In Windows, nothing but the given effects is allowed.
 160      * In X the given action is just a hint, and you can always
 161      * XdndActionCopy and XdndActionPrivate, so be more permissive. */
 162     if (action == x11drv_atom(XdndActionCopy))
 163         return DROPEFFECT_COPY;
 164     else if (action == x11drv_atom(XdndActionMove))
 165         return DROPEFFECT_MOVE | DROPEFFECT_COPY;
 166     else if (action == x11drv_atom(XdndActionLink))
 167         return DROPEFFECT_LINK | DROPEFFECT_COPY;
 168     else if (action == x11drv_atom(XdndActionAsk))
 169         /* FIXME: should we somehow ask the user what to do here? */
 170         return DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK;
 171     FIXME("unknown action %ld, assuming DROPEFFECT_COPY\n", action);
 172     return DROPEFFECT_COPY;
 173 }
 174
 175 /**************************************************************************
 176  * X11DRV_XDND_DROPEFFECTToXdndAction
 177  */
 178 static long X11DRV_XDND_DROPEFFECTToXdndAction(DWORD effect)
 179 {
 180     if (effect == DROPEFFECT_COPY)
 181         return x11drv_atom(XdndActionCopy);
 182     else if (effect == DROPEFFECT_MOVE)
 183         return x11drv_atom(XdndActionMove);
 184     else if (effect == DROPEFFECT_LINK)
 185         return x11drv_atom(XdndActionLink);
 186     FIXME("unknown drop effect %u, assuming XdndActionCopy\n", effect);
 187     return x11drv_atom(XdndActionCopy);
 188 }
 189
 190 /**************************************************************************
 191  * X11DRV_XDND_EnterEvent
 192  *
 193  * Handle an XdndEnter event.
 194  */
 195 void X11DRV_XDND_EnterEvent( HWND hWnd, XClientMessageEvent *event )
 196 {
 197     int version;
 198     Atom *xdndtypes;
 199     unsigned long count = 0;
 200
 201     version = (event->data.l[1] & 0xFF000000) >> 24;
 202     TRACE("ver(%d) check-XdndTypeList(%ld) data=%ld,%ld,%ld,%ld,%ld\n",
 203           version, (event->data.l[1] & 1),
 204           event->data.l[0], event->data.l[1], event->data.l[2],
 205           event->data.l[3], event->data.l[4]);
 206
 207     if (version > WINE_XDND_VERSION)
 208     {
 209         ERR("ignoring unsupported XDND version %d\n", version);
 210         return;
 211     }
 212
 213     XDNDAccepted = FALSE;
 214
 215     /* If the source supports more than 3 data types we retrieve
 216      * the entire list. */
 217     if (event->data.l[1] & 1)
 218     {
 219         Atom acttype;
 220         int actfmt;
 221         unsigned long bytesret;
 222
 223         /* Request supported formats from source window */
 224         XGetWindowProperty(event->display, event->data.l[0], x11drv_atom(XdndTypeList),
 225                            0, 65535, FALSE, AnyPropertyType, &acttype, &actfmt, &count,
 226                            &bytesret, (unsigned char**)&xdndtypes);
 227     }
 228     else
 229     {
 230         count = 3;
 231         xdndtypes = (Atom*) &event->data.l[2];
 232     }
 233
 234     if (TRACE_ON(xdnd))
 235     {
 236         unsigned int i;
 237
 238         for (i = 0; i < count; i++)
 239         {
 240             if (xdndtypes[i] != 0)
 241             {
 242                 char * pn = XGetAtomName(event->display, xdndtypes[i]);
 243                 TRACE("XDNDEnterAtom %ld: %s\n", xdndtypes[i], pn);
 244                 XFree(pn);
 245             }
 246         }
 247     }
 248
 249     /* Do a one-time data read and cache results */
 250     X11DRV_XDND_ResolveProperty(event->display, event->window,
 251                                 event->data.l[1], xdndtypes, count);
 252
 253     if (event->data.l[1] & 1)
 254         XFree(xdndtypes);
 255 }
 256
 257 /**************************************************************************
 258  * X11DRV_XDND_PositionEvent
 259  *
 260  * Handle an XdndPosition event.
 261  */
 262 void X11DRV_XDND_PositionEvent( HWND hWnd, XClientMessageEvent *event )
 263 {
 264     XClientMessageEvent e;
 265     int accept = 0; /* Assume we're not accepting */
 266     IDropTarget *dropTarget = NULL;
 267     DWORD effect;
 268     POINTL pointl;
 269     HWND targetWindow;
 270     HRESULT hr;
 271
 272     XDNDxy = root_to_virtual_screen( event->data.l[2] >> 16, event->data.l[2] & 0xFFFF );
 273     targetWindow = WindowFromPoint(XDNDxy);
 274
 275     pointl.x = XDNDxy.x;
 276     pointl.y = XDNDxy.y;
 277     effect = X11DRV_XDND_XdndActionToDROPEFFECT(event->data.l[4]);
 278
 279     if (!XDNDAccepted || XDNDLastTargetWnd != targetWindow)
 280     {
 281         /* Notify OLE of DragEnter. Result determines if we accept */
 282         HWND dropTargetWindow;
 283
 284         if (XDNDAccepted && XDNDLastDropTargetWnd)
 285         {
 286             dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
 287             if (dropTarget)
 288             {
 289                 hr = IDropTarget_DragLeave(dropTarget);
 290                 if (FAILED(hr))
 291                     WARN("IDropTarget_DragLeave failed, error 0x%08X\n", hr);
 292                 IDropTarget_Release(dropTarget);
 293             }
 294         }
 295         dropTargetWindow = targetWindow;
 296         do
 297         {
 298             dropTarget = get_droptarget_pointer(dropTargetWindow);
 299         } while (dropTarget == NULL && (dropTargetWindow = GetParent(dropTargetWindow)) != NULL);
 300         XDNDLastTargetWnd = targetWindow;
 301         XDNDLastDropTargetWnd = dropTargetWindow;
 302         if (dropTarget)
 303         {
 304             DWORD effect_ignore = effect;
 305             hr = IDropTarget_DragEnter(dropTarget, &XDNDDataObject,
 306                                        MK_LBUTTON, pointl, &effect_ignore);
 307             if (hr == S_OK)
 308             {
 309                 XDNDAccepted = TRUE;
 310                 TRACE("the application accepted the drop (effect = %d)\n", effect_ignore);
 311             }
 312             else
 313             {
 314                 XDNDAccepted = FALSE;
 315                 WARN("IDropTarget_DragEnter failed, error 0x%08X\n", hr);
 316             }
 317             IDropTarget_Release(dropTarget);
 318         }
 319     }
 320     if (XDNDAccepted && XDNDLastTargetWnd == targetWindow)
 321     {
 322         /* If drag accepted notify OLE of DragOver */
 323         dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
 324         if (dropTarget)
 325         {
 326             hr = IDropTarget_DragOver(dropTarget, MK_LBUTTON, pointl, &effect);
 327             if (hr == S_OK)
 328                 XDNDDropEffect = effect;
 329             else
 330                 WARN("IDropTarget_DragOver failed, error 0x%08X\n", hr);
 331             IDropTarget_Release(dropTarget);
 332         }
 333     }
 334
 335     if (XDNDAccepted)
 336         accept = 1;
 337     else if ((GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES) &&
 338             X11DRV_XDND_HasHDROP())
 339     {
 340         accept = 1;
 341         effect = DROPEFFECT_COPY;
 342     }
 343
 344     TRACE("actionRequested(%ld) accept(%d) chosen(0x%x) at x(%d),y(%d)\n",
 345           event->data.l[4], accept, effect, XDNDxy.x, XDNDxy.y);
 346
 347     /*
 348      * Let source know if we're accepting the drop by
 349      * sending a status message.
 350      */
 351     e.type = ClientMessage;
 352     e.display = event->display;
 353     e.window = event->data.l[0];
 354     e.message_type = x11drv_atom(XdndStatus);
 355     e.format = 32;
 356     e.data.l[0] = event->window;
 357     e.data.l[1] = accept;
 358     e.data.l[2] = 0; /* Empty Rect */
 359     e.data.l[3] = 0; /* Empty Rect */
 360     if (accept)
 361         e.data.l[4] = X11DRV_XDND_DROPEFFECTToXdndAction(effect);
 362     else
 363         e.data.l[4] = None;
 364     XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
 365 }
 366
 367 /**************************************************************************
 368  * X11DRV_XDND_DropEvent
 369  *
 370  * Handle an XdndDrop event.
 371  */
 372 void X11DRV_XDND_DropEvent( HWND hWnd, XClientMessageEvent *event )
 373 {
 374     XClientMessageEvent e;
 375     IDropTarget *dropTarget;
 376     DWORD effect = XDNDDropEffect;
 377     int accept = 0; /* Assume we're not accepting */
 378     BOOL drop_file = TRUE;
 379
 380     /* Notify OLE of Drop */
 381     if (XDNDAccepted)
 382     {
 383         dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
 384         if (dropTarget && effect!=DROPEFFECT_NONE)
 385         {
 386             HRESULT hr;
 387             POINTL pointl;
 388
 389             pointl.x = XDNDxy.x;
 390             pointl.y = XDNDxy.y;
 391             hr = IDropTarget_Drop(dropTarget, &XDNDDataObject, MK_LBUTTON,
 392                                   pointl, &effect);
 393             if (hr == S_OK)
 394             {
 395                 if (effect != DROPEFFECT_NONE)
 396                 {
 397                     TRACE("drop succeeded\n");
 398                     accept = 1;
 399                     drop_file = FALSE;
 400                 }
 401                 else
 402                     TRACE("the application refused the drop\n");
 403             }
 404             else if (FAILED(hr))
 405                 WARN("drop failed, error 0x%08X\n", hr);
 406             else
 407             {
 408                 WARN("drop returned 0x%08X\n", hr);
 409                 drop_file = FALSE;
 410             }
 411             IDropTarget_Release(dropTarget);
 412         }
 413         else if (dropTarget)
 414         {
 415             HRESULT hr = IDropTarget_DragLeave(dropTarget);
 416             if (FAILED(hr))
 417                 WARN("IDropTarget_DragLeave failed, error 0x%08X\n", hr);
 418             IDropTarget_Release(dropTarget);
 419         }
 420     }
 421
 422     if (drop_file)
 423     {
 424         /* Only send WM_DROPFILES if Drop didn't succeed or DROPEFFECT_NONE was set.
 425          * Doing both causes winamp to duplicate the dropped files (#29081) */
 426         if ((GetWindowLongW( hWnd, GWL_EXSTYLE ) & WS_EX_ACCEPTFILES) &&
 427                 X11DRV_XDND_HasHDROP())
 428         {
 429             HRESULT hr = X11DRV_XDND_SendDropFiles( hWnd );
 430             if (SUCCEEDED(hr))
 431             {
 432                 accept = 1;
 433                 effect = DROPEFFECT_COPY;
 434             }
 435         }
 436     }
 437
 438     TRACE("effectRequested(0x%x) accept(%d) performed(0x%x) at x(%d),y(%d)\n",
 439           XDNDDropEffect, accept, effect, XDNDxy.x, XDNDxy.y);
 440
 441     X11DRV_XDND_FreeDragDropOp();
 442
 443     /* Tell the target we are finished. */
 444     memset(&e, 0, sizeof(e));
 445     e.type = ClientMessage;
 446     e.display = event->display;
 447     e.window = event->data.l[0];
 448     e.message_type = x11drv_atom(XdndFinished);
 449     e.format = 32;
 450     e.data.l[0] = event->window;
 451     e.data.l[1] = accept;
 452     if (accept)
 453         e.data.l[2] = X11DRV_XDND_DROPEFFECTToXdndAction(effect);
 454     else
 455         e.data.l[2] = None;
 456     XSendEvent(event->display, event->data.l[0], False, NoEventMask, (XEvent*)&e);
 457 }
 458
 459 /**************************************************************************
 460  * X11DRV_XDND_LeaveEvent
 461  *
 462  * Handle an XdndLeave event.
 463  */
 464 void X11DRV_XDND_LeaveEvent( HWND hWnd, XClientMessageEvent *event )
 465 {
 466     IDropTarget *dropTarget;
 467
 468     TRACE("DND Operation canceled\n");
 469
 470     /* Notify OLE of DragLeave */
 471     if (XDNDAccepted)
 472     {
 473         dropTarget = get_droptarget_pointer(XDNDLastDropTargetWnd);
 474         if (dropTarget)
 475         {
 476             HRESULT hr = IDropTarget_DragLeave(dropTarget);
 477             if (FAILED(hr))
 478                 WARN("IDropTarget_DragLeave failed, error 0x%08X\n", hr);
 479             IDropTarget_Release(dropTarget);
 480         }
 481     }
 482
 483     X11DRV_XDND_FreeDragDropOp();
 484 }
 485
 486
 487 /**************************************************************************
 488  * X11DRV_XDND_ResolveProperty
 489  *
 490  * Resolve all MIME types to windows clipboard formats. All data is cached.
 491  */
 492 static void X11DRV_XDND_ResolveProperty(Display *display, Window xwin, Time tm,
 493                                         Atom *types, unsigned long count)
 494 {
 495     XDNDDATA *current, *next;
 496     BOOL haveHDROP = FALSE;
 497
 498     TRACE("count(%ld)\n", count);
 499
 500     X11DRV_XDND_FreeDragDropOp(); /* Clear previously cached data */
 501
 502     X11DRV_CLIPBOARD_ImportSelection( display, xwin, x11drv_atom(XdndSelection),
 503                                       types, count, X11DRV_XDND_InsertXDNDData );
 504
 505     /* On Windows when there is a CF_HDROP, there are no other CF_ formats.
 506      * foobar2000 relies on this (spaces -> %20's without it).
 507      */
 508     LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 509     {
 510         if (current->cf_win == CF_HDROP)
 511         {
 512             haveHDROP = TRUE;
 513             break;
 514         }
 515     }
 516     if (haveHDROP)
 517     {
 518         LIST_FOR_EACH_ENTRY_SAFE(current, next, &xdndData, XDNDDATA, entry)
 519         {
 520             if (current->cf_win != CF_HDROP && current->cf_win < CF_MAX)
 521             {
 522                 list_remove(&current->entry);
 523                 GlobalFree(current->contents);
 524                 HeapFree(GetProcessHeap(), 0, current);
 525             }
 526         }
 527     }
 528 }
 529
 530
 531 /**************************************************************************
 532  * X11DRV_XDND_InsertXDNDData
 533  *
 534  * Cache available XDND property
 535  */
 536 static void X11DRV_XDND_InsertXDNDData( Atom property, UINT format, HANDLE contents )
 537 {
 538     LPXDNDDATA current = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(XDNDDATA));
 539
 540     if (current)
 541     {
 542         EnterCriticalSection(&xdnd_cs);
 543         current->cf_xdnd = property;
 544         current->cf_win = format;
 545         current->contents = contents;
 546         list_add_tail(&xdndData, &current->entry);
 547         LeaveCriticalSection(&xdnd_cs);
 548     }
 549 }
 550
 551
 552 /**************************************************************************
 553  * X11DRV_XDND_HasHDROP
 554  */
 555 static BOOL X11DRV_XDND_HasHDROP(void)
 556 {
 557     LPXDNDDATA current = NULL;
 558     BOOL found = FALSE;
 559
 560     EnterCriticalSection(&xdnd_cs);
 561
 562     /* Find CF_HDROP type if any */
 563     LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 564     {
 565         if (current->cf_win == CF_HDROP)
 566         {
 567             found = TRUE;
 568             break;
 569         }
 570     }
 571
 572     LeaveCriticalSection(&xdnd_cs);
 573
 574     return found;
 575 }
 576
 577 /**************************************************************************
 578  * X11DRV_XDND_SendDropFiles
 579  */
 580 static HRESULT X11DRV_XDND_SendDropFiles(HWND hwnd)
 581 {
 582     HRESULT hr;
 583     LPXDNDDATA current = NULL;
 584     BOOL found = FALSE;
 585
 586     EnterCriticalSection(&xdnd_cs);
 587
 588     LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 589     {
 590          if (current->cf_win == CF_HDROP)
 591          {
 592              found = TRUE;
 593              break;
 594          }
 595     }
 596     if (found)
 597     {
 598         HGLOBAL dropHandle = GlobalAlloc(GMEM_FIXED, GlobalSize(current->contents));
 599         if (dropHandle)
 600         {
 601             DROPFILES *lpDrop = GlobalLock(dropHandle);
 602             memcpy(lpDrop, GlobalLock(current->contents), GlobalSize(current->contents));
 603             GlobalUnlock(current->contents);
 604             lpDrop->pt.x = XDNDxy.x;
 605             lpDrop->pt.y = XDNDxy.y;
 606             lpDrop->fNC  = !ScreenToClient(hwnd, &lpDrop->pt);
 607             TRACE("Sending WM_DROPFILES: hWnd=0x%p, fNC=%d, x=%d, y=%d, files=%p(%s)\n", hwnd,
 608                     lpDrop->fNC, lpDrop->pt.x, lpDrop->pt.y, ((char*)lpDrop) + lpDrop->pFiles,
 609                     debugstr_w((WCHAR*)(((char*)lpDrop) + lpDrop->pFiles)));
 610             GlobalUnlock(dropHandle);
 611             if (PostMessageW(hwnd, WM_DROPFILES, (WPARAM)dropHandle, 0))
 612                 hr = S_OK;
 613             else
 614             {
 615                 hr = HRESULT_FROM_WIN32(GetLastError());
 616                 GlobalFree(dropHandle);
 617             }
 618         }
 619         else
 620             hr = HRESULT_FROM_WIN32(GetLastError());
 621     }
 622     else
 623         hr = E_FAIL;
 624
 625     LeaveCriticalSection(&xdnd_cs);
 626
 627     return hr;
 628 }
 629
 630
 631 /**************************************************************************
 632  * X11DRV_XDND_FreeDragDropOp
 633  */
 634 static void X11DRV_XDND_FreeDragDropOp(void)
 635 {
 636     LPXDNDDATA next;
 637     LPXDNDDATA current;
 638
 639     TRACE("\n");
 640
 641     EnterCriticalSection(&xdnd_cs);
 642
 643     /** Free data cache */
 644     LIST_FOR_EACH_ENTRY_SAFE(current, next, &xdndData, XDNDDATA, entry)
 645     {
 646         list_remove(&current->entry);
 647         GlobalFree(current->contents);
 648         HeapFree(GetProcessHeap(), 0, current);
 649     }
 650
 651     XDNDxy.x = XDNDxy.y = 0;
 652     XDNDLastTargetWnd = NULL;
 653     XDNDLastDropTargetWnd = NULL;
 654     XDNDAccepted = FALSE;
 655
 656     LeaveCriticalSection(&xdnd_cs);
 657 }
 658
 659
 660 /**************************************************************************
 661  * X11DRV_XDND_DescribeClipboardFormat
 662  */
 663 static void X11DRV_XDND_DescribeClipboardFormat(int cfFormat, char *buffer, int size)
 664 {
 665 #define D(x) case x: lstrcpynA(buffer, #x, size); return;
 666     switch (cfFormat)
 667     {
 668         D(CF_TEXT)
 669         D(CF_BITMAP)
 670         D(CF_METAFILEPICT)
 671         D(CF_SYLK)
 672         D(CF_DIF)
 673         D(CF_TIFF)
 674         D(CF_OEMTEXT)
 675         D(CF_DIB)
 676         D(CF_PALETTE)
 677         D(CF_PENDATA)
 678         D(CF_RIFF)
 679         D(CF_WAVE)
 680         D(CF_UNICODETEXT)
 681         D(CF_ENHMETAFILE)
 682         D(CF_HDROP)
 683         D(CF_LOCALE)
 684         D(CF_DIBV5)
 685     }
 686 #undef D
 687
 688     if (CF_PRIVATEFIRST <= cfFormat && cfFormat <= CF_PRIVATELAST)
 689     {
 690         lstrcpynA(buffer, "some private object", size);
 691         return;
 692     }
 693     if (CF_GDIOBJFIRST <= cfFormat && cfFormat <= CF_GDIOBJLAST)
 694     {
 695         lstrcpynA(buffer, "some GDI object", size);
 696         return;
 697     }
 698
 699     GetClipboardFormatNameA(cfFormat, buffer, size);
 700 }
 701
 702
 703 /* The IDataObject singleton we feed to OLE follows */
 704
 705 static HRESULT WINAPI XDNDDATAOBJECT_QueryInterface(IDataObject *dataObject,
 706                                                     REFIID riid, void **ppvObject)
 707 {
 708     TRACE("(%p, %s, %p)\n", dataObject, debugstr_guid(riid), ppvObject);
 709     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDataObject))
 710     {
 711         *ppvObject = dataObject;
 712         IDataObject_AddRef(dataObject);
 713         return S_OK;
 714     }
 715     *ppvObject = NULL;
 716     return E_NOINTERFACE;
 717 }
 718
 719 static ULONG WINAPI XDNDDATAOBJECT_AddRef(IDataObject *dataObject)
 720 {
 721     TRACE("(%p)\n", dataObject);
 722     return 2;
 723 }
 724
 725 static ULONG WINAPI XDNDDATAOBJECT_Release(IDataObject *dataObject)
 726 {
 727     TRACE("(%p)\n", dataObject);
 728     return 1;
 729 }
 730
 731 static HRESULT WINAPI XDNDDATAOBJECT_GetData(IDataObject *dataObject,
 732                                              FORMATETC *formatEtc,
 733                                              STGMEDIUM *pMedium)
 734 {
 735     HRESULT hr;
 736     char formatDesc[1024];
 737
 738     TRACE("(%p, %p, %p)\n", dataObject, formatEtc, pMedium);
 739     X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat,
 740         formatDesc, sizeof(formatDesc));
 741     TRACE("application is looking for %s\n", formatDesc);
 742
 743     hr = IDataObject_QueryGetData(dataObject, formatEtc);
 744     if (SUCCEEDED(hr))
 745     {
 746         XDNDDATA *current;
 747         LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 748         {
 749             if (current->cf_win == formatEtc->cfFormat)
 750             {
 751                 pMedium->tymed = TYMED_HGLOBAL;
 752                 pMedium->u.hGlobal = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, GlobalSize(current->contents));
 753                 if (pMedium->u.hGlobal == NULL)
 754                     return E_OUTOFMEMORY;
 755                 memcpy(GlobalLock(pMedium->u.hGlobal), GlobalLock(current->contents), GlobalSize(current->contents));
 756                 GlobalUnlock(pMedium->u.hGlobal);
 757                 GlobalUnlock(current->contents);
 758                 pMedium->pUnkForRelease = 0;
 759                 return S_OK;
 760             }
 761         }
 762     }
 763     return hr;
 764 }
 765
 766 static HRESULT WINAPI XDNDDATAOBJECT_GetDataHere(IDataObject *dataObject,
 767                                                  FORMATETC *formatEtc,
 768                                                  STGMEDIUM *pMedium)
 769 {
 770     FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, pMedium);
 771     return DATA_E_FORMATETC;
 772 }
 773
 774 static HRESULT WINAPI XDNDDATAOBJECT_QueryGetData(IDataObject *dataObject,
 775                                                   FORMATETC *formatEtc)
 776 {
 777     char formatDesc[1024];
 778     XDNDDATA *current;
 779
 780     TRACE("(%p, %p={.tymed=0x%x, .dwAspect=%d, .cfFormat=%d}\n",
 781         dataObject, formatEtc, formatEtc->tymed, formatEtc->dwAspect, formatEtc->cfFormat);
 782     X11DRV_XDND_DescribeClipboardFormat(formatEtc->cfFormat, formatDesc, sizeof(formatDesc));
 783
 784     if (formatEtc->tymed && !(formatEtc->tymed & TYMED_HGLOBAL))
 785     {
 786         FIXME("only HGLOBAL medium types supported right now\n");
 787         return DV_E_TYMED;
 788     }
 789     if (formatEtc->dwAspect != DVASPECT_CONTENT)
 790     {
 791         FIXME("only the content aspect is supported right now\n");
 792         return E_NOTIMPL;
 793     }
 794
 795     LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 796     {
 797         if (current->cf_win == formatEtc->cfFormat)
 798         {
 799             TRACE("application found %s\n", formatDesc);
 800             return S_OK;
 801         }
 802     }
 803     TRACE("application didn't find %s\n", formatDesc);
 804     return DV_E_FORMATETC;
 805 }
 806
 807 static HRESULT WINAPI XDNDDATAOBJECT_GetCanonicalFormatEtc(IDataObject *dataObject,
 808                                                            FORMATETC *formatEtc,
 809                                                            FORMATETC *formatEtcOut)
 810 {
 811     FIXME("(%p, %p, %p): stub\n", dataObject, formatEtc, formatEtcOut);
 812     formatEtcOut->ptd = NULL;
 813     return E_NOTIMPL;
 814 }
 815
 816 static HRESULT WINAPI XDNDDATAOBJECT_SetData(IDataObject *dataObject,
 817                                              FORMATETC *formatEtc,
 818                                              STGMEDIUM *pMedium, BOOL fRelease)
 819 {
 820     FIXME("(%p, %p, %p, %s): stub\n", dataObject, formatEtc,
 821         pMedium, fRelease?"TRUE":"FALSE");
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI XDNDDATAOBJECT_EnumFormatEtc(IDataObject *dataObject,
 826                                                    DWORD dwDirection,
 827                                                    IEnumFORMATETC **ppEnumFormatEtc)
 828 {
 829     DWORD count;
 830     FORMATETC *formats;
 831
 832     TRACE("(%p, %u, %p)\n", dataObject, dwDirection, ppEnumFormatEtc);
 833
 834     if (dwDirection != DATADIR_GET)
 835     {
 836         FIXME("only the get direction is implemented\n");
 837         return E_NOTIMPL;
 838     }
 839
 840     count = list_count(&xdndData);
 841     formats = HeapAlloc(GetProcessHeap(), 0, count * sizeof(FORMATETC));
 842     if (formats)
 843     {
 844         XDNDDATA *current;
 845         DWORD i = 0;
 846         HRESULT hr;
 847         LIST_FOR_EACH_ENTRY(current, &xdndData, XDNDDATA, entry)
 848         {
 849             formats[i].cfFormat = current->cf_win;
 850             formats[i].ptd = NULL;
 851             formats[i].dwAspect = DVASPECT_CONTENT;
 852             formats[i].lindex = -1;
 853             formats[i].tymed = TYMED_HGLOBAL;
 854             i++;
 855         }
 856         hr = SHCreateStdEnumFmtEtc(count, formats, ppEnumFormatEtc);
 857         HeapFree(GetProcessHeap(), 0, formats);
 858         return hr;
 859     }
 860     else
 861         return E_OUTOFMEMORY;
 862 }
 863
 864 static HRESULT WINAPI XDNDDATAOBJECT_DAdvise(IDataObject *dataObject,
 865                                              FORMATETC *formatEtc, DWORD advf,
 866                                              IAdviseSink *adviseSink,
 867                                              DWORD *pdwConnection)
 868 {
 869     FIXME("(%p, %p, %u, %p, %p): stub\n", dataObject, formatEtc, advf,
 870         adviseSink, pdwConnection);
 871     return OLE_E_ADVISENOTSUPPORTED;
 872 }
 873
 874 static HRESULT WINAPI XDNDDATAOBJECT_DUnadvise(IDataObject *dataObject,
 875                                                DWORD dwConnection)
 876 {
 877     FIXME("(%p, %u): stub\n", dataObject, dwConnection);
 878     return OLE_E_ADVISENOTSUPPORTED;
 879 }
 880
 881 static HRESULT WINAPI XDNDDATAOBJECT_EnumDAdvise(IDataObject *dataObject,
 882                                                  IEnumSTATDATA **pEnumAdvise)
 883 {
 884     FIXME("(%p, %p): stub\n", dataObject, pEnumAdvise);
 885     return OLE_E_ADVISENOTSUPPORTED;
 886 }
 887
 888 static IDataObjectVtbl xdndDataObjectVtbl =
 889 {
 890     XDNDDATAOBJECT_QueryInterface,
 891     XDNDDATAOBJECT_AddRef,
 892     XDNDDATAOBJECT_Release,
 893     XDNDDATAOBJECT_GetData,
 894     XDNDDATAOBJECT_GetDataHere,
 895     XDNDDATAOBJECT_QueryGetData,
 896     XDNDDATAOBJECT_GetCanonicalFormatEtc,
 897     XDNDDATAOBJECT_SetData,
 898     XDNDDATAOBJECT_EnumFormatEtc,
 899     XDNDDATAOBJECT_DAdvise,
 900     XDNDDATAOBJECT_DUnadvise,
 901     XDNDDATAOBJECT_EnumDAdvise
 902 };
 903
 904 static IDataObject XDNDDataObject = { &xdndDataObjectVtbl };