dlls/winemac.drv/dragdrop.c

   1 /*
   2  * MACDRV Drag and drop code
   3  *
   4  * Copyright 2003 Ulrich Czekalla
   5  * Copyright 2007 Damjan Jovanovic
   6  * Copyright 2013 Ken Thomases for CodeWeavers Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "macdrv_dll.h"
  26
  27 #define COBJMACROS
  28 #include "objidl.h"
  29 #include "shellapi.h"
  30 #include "shlobj.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(dragdrop);
  34
  35
  36 static IDataObject *active_data_object;
  37 static HWND last_droptarget_hwnd;
  38
  39
  40 typedef struct
  41 {
  42     IDataObject IDataObject_iface;
  43     LONG        ref;
  44     UINT64      pasteboard;
  45 } DragDropDataObject;
  46
  47
  48 /**************************************************************************
  49  *              debugstr_format
  50  */
  51 static const char *debugstr_format(UINT id)
  52 {
  53     WCHAR buffer[256];
  54
  55     if (GetClipboardFormatNameW(id, buffer, 256))
  56         return wine_dbg_sprintf("0x%04x %s", id, debugstr_w(buffer));
  57
  58     switch (id)
  59     {
  60 #define BUILTIN(id) case id: return #id;
  61     BUILTIN(CF_TEXT)
  62     BUILTIN(CF_BITMAP)
  63     BUILTIN(CF_METAFILEPICT)
  64     BUILTIN(CF_SYLK)
  65     BUILTIN(CF_DIF)
  66     BUILTIN(CF_TIFF)
  67     BUILTIN(CF_OEMTEXT)
  68     BUILTIN(CF_DIB)
  69     BUILTIN(CF_PALETTE)
  70     BUILTIN(CF_PENDATA)
  71     BUILTIN(CF_RIFF)
  72     BUILTIN(CF_WAVE)
  73     BUILTIN(CF_UNICODETEXT)
  74     BUILTIN(CF_ENHMETAFILE)
  75     BUILTIN(CF_HDROP)
  76     BUILTIN(CF_LOCALE)
  77     BUILTIN(CF_DIBV5)
  78     BUILTIN(CF_OWNERDISPLAY)
  79     BUILTIN(CF_DSPTEXT)
  80     BUILTIN(CF_DSPBITMAP)
  81     BUILTIN(CF_DSPMETAFILEPICT)
  82     BUILTIN(CF_DSPENHMETAFILE)
  83 #undef BUILTIN
  84     default: return wine_dbg_sprintf("0x%04x", id);
  85     }
  86 }
  87
  88 static inline DragDropDataObject *impl_from_IDataObject(IDataObject *iface)
  89 {
  90     return CONTAINING_RECORD(iface, DragDropDataObject, IDataObject_iface);
  91 }
  92
  93
  94 static HANDLE get_pasteboard_data(UINT64 pasteboard, UINT desired_format)
  95 {
  96     struct dnd_get_data_params params = { .handle = pasteboard, .format = desired_format, .size = 2048 };
  97     HANDLE handle;
  98     NTSTATUS status;
  99
 100     for (;;)
 101     {
 102         if (!(handle = GlobalAlloc(GMEM_FIXED, params.size))) return 0;
 103         params.data = GlobalLock(handle);
 104         status = MACDRV_CALL(dnd_get_data, &params);
 105         GlobalUnlock(handle);
 106         if (!status) return GlobalReAlloc(handle, params.size, GMEM_MOVEABLE);
 107         GlobalFree(handle);
 108         if (status != STATUS_BUFFER_OVERFLOW) return 0;
 109     }
 110 }
 111
 112 static HRESULT WINAPI dddo_QueryInterface(IDataObject* iface, REFIID riid, LPVOID *ppvObj)
 113 {
 114     DragDropDataObject *This = impl_from_IDataObject(iface);
 115
 116     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppvObj);
 117
 118     if (IsEqualIID(riid, &IID_IUnknown) || (IsEqualIID(riid, &IID_IDataObject)))
 119     {
 120         *ppvObj = iface;
 121         IDataObject_AddRef(iface);
 122         return S_OK;
 123     }
 124
 125     *ppvObj = NULL;
 126     return E_NOINTERFACE;
 127 }
 128
 129
 130 static ULONG WINAPI dddo_AddRef(IDataObject* iface)
 131 {
 132     DragDropDataObject *This = impl_from_IDataObject(iface);
 133     ULONG refCount = InterlockedIncrement(&This->ref);
 134
 135     TRACE("(%p)->(count=%lu)\n", This, refCount - 1);
 136
 137     return refCount;
 138 }
 139
 140
 141 static ULONG WINAPI dddo_Release(IDataObject* iface)
 142 {
 143     DragDropDataObject *This = impl_from_IDataObject(iface);
 144     ULONG refCount = InterlockedDecrement(&This->ref);
 145
 146     TRACE("(%p)->(count=%lu)\n", This, refCount + 1);
 147     if (refCount)
 148         return refCount;
 149
 150     TRACE("-- destroying DragDropDataObject (%p)\n", This);
 151     MACDRV_CALL(dnd_release, &This->pasteboard);
 152     HeapFree(GetProcessHeap(), 0, This);
 153     return 0;
 154 }
 155
 156
 157 static HRESULT WINAPI dddo_GetData(IDataObject* iface, FORMATETC* formatEtc, STGMEDIUM* medium)
 158 {
 159     DragDropDataObject *This = impl_from_IDataObject(iface);
 160     HRESULT hr;
 161
 162     TRACE("This %p formatEtc %s\n", This, debugstr_format(formatEtc->cfFormat));
 163
 164     hr = IDataObject_QueryGetData(iface, formatEtc);
 165     if (SUCCEEDED(hr))
 166     {
 167         medium->tymed = TYMED_HGLOBAL;
 168         medium->hGlobal = get_pasteboard_data(This->pasteboard, formatEtc->cfFormat);
 169         medium->pUnkForRelease = NULL;
 170         hr = medium->hGlobal ? S_OK : E_OUTOFMEMORY;
 171     }
 172
 173     return hr;
 174 }
 175
 176
 177 static HRESULT WINAPI dddo_GetDataHere(IDataObject* iface, FORMATETC* formatEtc,
 178                                        STGMEDIUM* medium)
 179 {
 180     FIXME("iface %p formatEtc %p medium %p; stub\n", iface, formatEtc, medium);
 181     return DATA_E_FORMATETC;
 182 }
 183
 184
 185 static HRESULT WINAPI dddo_QueryGetData(IDataObject* iface, FORMATETC* formatEtc)
 186 {
 187     DragDropDataObject *This = impl_from_IDataObject(iface);
 188     struct dnd_have_format_params params;
 189     HRESULT hr = DV_E_FORMATETC;
 190
 191     TRACE("This %p formatEtc %p={.tymed=0x%lx, .dwAspect=%ld, .cfFormat=%s}\n",
 192           This, formatEtc, formatEtc->tymed, formatEtc->dwAspect,
 193           debugstr_format(formatEtc->cfFormat));
 194
 195     if (formatEtc->tymed && !(formatEtc->tymed & TYMED_HGLOBAL))
 196     {
 197         FIXME("only HGLOBAL medium types supported right now\n");
 198         return DV_E_TYMED;
 199     }
 200     if (formatEtc->dwAspect != DVASPECT_CONTENT)
 201     {
 202         FIXME("only the content aspect is supported right now\n");
 203         return E_NOTIMPL;
 204     }
 205
 206     params.handle = This->pasteboard;
 207     params.format = formatEtc->cfFormat;
 208     if (MACDRV_CALL(dnd_have_format, &params))
 209         hr = S_OK;
 210
 211     TRACE(" -> 0x%lx\n", hr);
 212     return hr;
 213 }
 214
 215
 216 static HRESULT WINAPI dddo_GetConicalFormatEtc(IDataObject* iface, FORMATETC* formatEtc,
 217                                                FORMATETC* formatEtcOut)
 218 {
 219     DragDropDataObject *This = impl_from_IDataObject(iface);
 220
 221     TRACE("This %p formatEtc %p={.tymed=0x%lx, .dwAspect=%ld, .cfFormat=%s}\n",
 222           This, formatEtc, formatEtc->tymed, formatEtc->dwAspect,
 223           debugstr_format(formatEtc->cfFormat));
 224
 225     *formatEtcOut = *formatEtc;
 226     formatEtcOut->ptd = NULL;
 227     return DATA_S_SAMEFORMATETC;
 228 }
 229
 230
 231 static HRESULT WINAPI dddo_SetData(IDataObject* iface, FORMATETC* formatEtc,
 232                                    STGMEDIUM* medium, BOOL fRelease)
 233 {
 234     DragDropDataObject *This = impl_from_IDataObject(iface);
 235
 236     TRACE("This %p formatEtc %p={.tymed=0x%lx, .dwAspect=%ld, .cfFormat=%s} medium %p fRelease %d\n",
 237           This, formatEtc, formatEtc->tymed, formatEtc->dwAspect,
 238           debugstr_format(formatEtc->cfFormat), medium, fRelease);
 239
 240     return E_NOTIMPL;
 241 }
 242
 243
 244 static HRESULT WINAPI dddo_EnumFormatEtc(IDataObject* iface, DWORD direction,
 245                                          IEnumFORMATETC** enumFormatEtc)
 246 {
 247     DragDropDataObject *This = impl_from_IDataObject(iface);
 248     struct dnd_get_formats_params params;
 249     UINT count;
 250     HRESULT hr;
 251
 252     TRACE("This %p direction %lu enumFormatEtc %p\n", This, direction, enumFormatEtc);
 253
 254     if (direction != DATADIR_GET)
 255     {
 256         WARN("only the get direction is implemented\n");
 257         return E_NOTIMPL;
 258     }
 259
 260     params.handle = This->pasteboard;
 261     count = MACDRV_CALL(dnd_get_formats, &params);
 262     if (count)
 263     {
 264         FORMATETC *formatEtcs = HeapAlloc(GetProcessHeap(), 0, count * sizeof(FORMATETC));
 265         if (formatEtcs)
 266         {
 267             INT i;
 268
 269             for (i = 0; i < count; i++)
 270             {
 271                 formatEtcs[i].cfFormat = params.formats[i];
 272                 formatEtcs[i].ptd = NULL;
 273                 formatEtcs[i].dwAspect = DVASPECT_CONTENT;
 274                 formatEtcs[i].lindex = -1;
 275                 formatEtcs[i].tymed = TYMED_HGLOBAL;
 276             }
 277
 278             hr = SHCreateStdEnumFmtEtc(count, formatEtcs, enumFormatEtc);
 279             HeapFree(GetProcessHeap(), 0, formatEtcs);
 280         }
 281         else
 282             hr = E_OUTOFMEMORY;
 283     }
 284     else
 285         hr = SHCreateStdEnumFmtEtc(0, NULL, enumFormatEtc);
 286
 287     TRACE(" -> 0x%lx\n", hr);
 288     return hr;
 289 }
 290
 291
 292 static HRESULT WINAPI dddo_DAdvise(IDataObject* iface, FORMATETC* formatEtc, DWORD advf,
 293                                    IAdviseSink* pAdvSink, DWORD* pdwConnection)
 294 {
 295     FIXME("(%p, %p, %lu, %p, %p): stub\n", iface, formatEtc, advf,
 296           pAdvSink, pdwConnection);
 297     return OLE_E_ADVISENOTSUPPORTED;
 298 }
 299
 300
 301 static HRESULT WINAPI dddo_DUnadvise(IDataObject* iface, DWORD dwConnection)
 302 {
 303     FIXME("(%p, %lu): stub\n", iface, dwConnection);
 304     return OLE_E_ADVISENOTSUPPORTED;
 305 }
 306
 307
 308 static HRESULT WINAPI dddo_EnumDAdvise(IDataObject* iface, IEnumSTATDATA** pEnumAdvise)
 309 {
 310     FIXME("(%p, %p): stub\n", iface, pEnumAdvise);
 311     return OLE_E_ADVISENOTSUPPORTED;
 312 }
 313
 314
 315 static const IDataObjectVtbl dovt =
 316 {
 317     dddo_QueryInterface,
 318     dddo_AddRef,
 319     dddo_Release,
 320     dddo_GetData,
 321     dddo_GetDataHere,
 322     dddo_QueryGetData,
 323     dddo_GetConicalFormatEtc,
 324     dddo_SetData,
 325     dddo_EnumFormatEtc,
 326     dddo_DAdvise,
 327     dddo_DUnadvise,
 328     dddo_EnumDAdvise
 329 };
 330
 331
 332 static IDataObject *create_data_object_for_pasteboard(UINT64 pasteboard)
 333 {
 334     DragDropDataObject *dddo;
 335
 336     dddo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dddo));
 337     if (!dddo)
 338         return NULL;
 339
 340     dddo->ref = 1;
 341     dddo->IDataObject_iface.lpVtbl = &dovt;
 342     dddo->pasteboard = pasteboard;
 343     MACDRV_CALL(dnd_retain, &dddo->pasteboard);
 344
 345     return &dddo->IDataObject_iface;
 346 }
 347
 348
 349 /* Based on functions in dlls/ole32/ole2.c */
 350 static HANDLE get_droptarget_local_handle(HWND hwnd)
 351 {
 352     static const WCHAR prop_marshalleddroptarget[] =
 353         {'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};
 354     HANDLE handle;
 355     HANDLE local_handle = 0;
 356
 357     handle = GetPropW(hwnd, prop_marshalleddroptarget);
 358     if (handle)
 359     {
 360         DWORD pid;
 361         HANDLE process;
 362
 363         GetWindowThreadProcessId(hwnd, &pid);
 364         process = OpenProcess(PROCESS_DUP_HANDLE, FALSE, pid);
 365         if (process)
 366         {
 367             DuplicateHandle(process, handle, GetCurrentProcess(), &local_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
 368             CloseHandle(process);
 369         }
 370     }
 371     return local_handle;
 372 }
 373
 374
 375 static HRESULT create_stream_from_map(HANDLE map, IStream **stream)
 376 {
 377     HRESULT hr = E_OUTOFMEMORY;
 378     HGLOBAL hmem;
 379     void *data;
 380     MEMORY_BASIC_INFORMATION info;
 381
 382     data = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 383     if(!data) return hr;
 384
 385     VirtualQuery(data, &info, sizeof(info));
 386     TRACE("size %d\n", (int)info.RegionSize);
 387
 388     hmem = GlobalAlloc(GMEM_MOVEABLE, info.RegionSize);
 389     if(hmem)
 390     {
 391         memcpy(GlobalLock(hmem), data, info.RegionSize);
 392         GlobalUnlock(hmem);
 393         hr = CreateStreamOnHGlobal(hmem, TRUE, stream);
 394     }
 395     UnmapViewOfFile(data);
 396     return hr;
 397 }
 398
 399
 400 static IDropTarget* get_droptarget_pointer(HWND hwnd)
 401 {
 402     IDropTarget *droptarget = NULL;
 403     HANDLE map;
 404     IStream *stream;
 405
 406     map = get_droptarget_local_handle(hwnd);
 407     if(!map) return NULL;
 408
 409     if(SUCCEEDED(create_stream_from_map(map, &stream)))
 410     {
 411         CoUnmarshalInterface(stream, &IID_IDropTarget, (void**)&droptarget);
 412         IStream_Release(stream);
 413     }
 414     CloseHandle(map);
 415     return droptarget;
 416 }
 417
 418
 419 /**************************************************************************
 420  *              macdrv_dnd_query_drop
 421  */
 422 NTSTATUS WINAPI macdrv_dnd_query_drop(void *arg, ULONG size)
 423 {
 424     struct dnd_query_drop_params *params = arg;
 425     IDropTarget *droptarget;
 426     BOOL ret = FALSE;
 427     POINT pt;
 428
 429     TRACE("win %x x,y %d,%d effect %x pasteboard %s\n", params->hwnd, params->x, params->y,
 430           params->effect, wine_dbgstr_longlong(params->handle));
 431
 432     pt.x = params->x;
 433     pt.y = params->y;
 434
 435     droptarget = get_droptarget_pointer(last_droptarget_hwnd);
 436     if (droptarget)
 437     {
 438         HRESULT hr;
 439         POINTL pointl;
 440         DWORD effect = params->effect;
 441
 442         if (!active_data_object)
 443         {
 444             WARN("shouldn't happen: no active IDataObject\n");
 445             active_data_object = create_data_object_for_pasteboard(params->handle);
 446         }
 447
 448         pointl.x = pt.x;
 449         pointl.y = pt.y;
 450         TRACE("Drop hwnd %p droptarget %p pointl (%ld,%ld) effect 0x%08lx\n", last_droptarget_hwnd,
 451               droptarget, pointl.x, pointl.y, effect);
 452         hr = IDropTarget_Drop(droptarget, active_data_object, MK_LBUTTON, pointl, &effect);
 453         if (SUCCEEDED(hr))
 454         {
 455             if (effect != DROPEFFECT_NONE)
 456             {
 457                 TRACE("drop succeeded\n");
 458                 ret = TRUE;
 459             }
 460             else
 461                 TRACE("the application refused the drop\n");
 462         }
 463         else
 464             WARN("drop failed, error 0x%08lx\n", hr);
 465         IDropTarget_Release(droptarget);
 466     }
 467     else
 468     {
 469         HWND hwnd = WindowFromPoint(pt);
 470         while (hwnd && !(GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_ACCEPTFILES))
 471             hwnd = GetParent(hwnd);
 472         if (hwnd)
 473         {
 474             HDROP hdrop = get_pasteboard_data(params->handle, CF_HDROP);
 475             DROPFILES *dropfiles = GlobalLock(hdrop);
 476             if (dropfiles)
 477             {
 478                 RECT rect;
 479                 dropfiles->pt.x = pt.x;
 480                 dropfiles->pt.y = pt.y;
 481                 dropfiles->fNC  = !(ScreenToClient(hwnd, &dropfiles->pt) &&
 482                                     GetClientRect(hwnd, &rect) &&
 483                                     PtInRect(&rect, dropfiles->pt));
 484
 485                 TRACE("sending WM_DROPFILES: hwnd %p nc %d pt %s %s\n", hwnd,
 486                       dropfiles->fNC, wine_dbgstr_point(&dropfiles->pt),
 487                       debugstr_w((WCHAR*)((char*)dropfiles + dropfiles->pFiles)));
 488
 489                 GlobalUnlock(hdrop);
 490
 491                 ret = PostMessageW(hwnd, WM_DROPFILES, (WPARAM)hdrop, 0L);
 492                 /* hdrop is owned by the message and freed when the recipient calls DragFinish(). */
 493             }
 494
 495             if (!ret) GlobalFree(hdrop);
 496         }
 497     }
 498
 499     if (active_data_object) IDataObject_Release(active_data_object);
 500     active_data_object = NULL;
 501     last_droptarget_hwnd = NULL;
 502     return ret;
 503 }
 504
 505
 506 /**************************************************************************
 507  *              macdrv_dnd_query_exited
 508  */
 509 NTSTATUS WINAPI macdrv_dnd_query_exited(void *arg, ULONG size)
 510 {
 511     struct dnd_query_exited_params *params = arg;
 512     HWND hwnd = UlongToHandle(params->hwnd);
 513     IDropTarget *droptarget;
 514
 515     TRACE("win %p\n", hwnd);
 516
 517     droptarget = get_droptarget_pointer(last_droptarget_hwnd);
 518     if (droptarget)
 519     {
 520         HRESULT hr;
 521
 522         TRACE("DragLeave hwnd %p droptarget %p\n", last_droptarget_hwnd, droptarget);
 523         hr = IDropTarget_DragLeave(droptarget);
 524         if (FAILED(hr))
 525             WARN("IDropTarget_DragLeave failed, error 0x%08lx\n", hr);
 526         IDropTarget_Release(droptarget);
 527     }
 528
 529     if (active_data_object) IDataObject_Release(active_data_object);
 530     active_data_object = NULL;
 531     last_droptarget_hwnd = NULL;
 532
 533     return TRUE;
 534 }
 535
 536
 537 /**************************************************************************
 538  *              query_drag_operation
 539  */
 540 NTSTATUS WINAPI macdrv_dnd_query_drag(void *arg, ULONG size)
 541 {
 542     struct dnd_query_drag_params *params = arg;
 543     HWND hwnd = UlongToHandle(params->hwnd);
 544     BOOL ret = FALSE;
 545     POINT pt;
 546     DWORD effect;
 547     IDropTarget *droptarget;
 548     HRESULT hr;
 549
 550     TRACE("win %p x,y %d,%d effect %x pasteboard %s\n", hwnd, params->x, params->y,
 551           params->effect, wine_dbgstr_longlong(params->handle));
 552
 553     pt.x = params->x;
 554     pt.y = params->y;
 555     effect = params->effect;
 556
 557     /* Instead of the top-level window we got in the query, start with the deepest
 558        child under the cursor.  Travel up the hierarchy looking for a window that
 559        has an associated IDropTarget. */
 560     hwnd = WindowFromPoint(pt);
 561     do
 562     {
 563         droptarget = get_droptarget_pointer(hwnd);
 564     } while (!droptarget && (hwnd = GetParent(hwnd)));
 565
 566     if (last_droptarget_hwnd != hwnd)
 567     {
 568         if (last_droptarget_hwnd)
 569         {
 570             IDropTarget *old_droptarget = get_droptarget_pointer(last_droptarget_hwnd);
 571             if (old_droptarget)
 572             {
 573                 TRACE("DragLeave hwnd %p droptarget %p\n", last_droptarget_hwnd, old_droptarget);
 574                 hr = IDropTarget_DragLeave(old_droptarget);
 575                 if (FAILED(hr))
 576                     WARN("IDropTarget_DragLeave failed, error 0x%08lx\n", hr);
 577                 IDropTarget_Release(old_droptarget);
 578             }
 579         }
 580
 581         last_droptarget_hwnd = hwnd;
 582
 583         if (droptarget)
 584         {
 585             POINTL pointl = { pt.x, pt.y };
 586
 587             if (!active_data_object)
 588                 active_data_object = create_data_object_for_pasteboard(params->handle);
 589
 590             TRACE("DragEnter hwnd %p droptarget %p\n", hwnd, droptarget);
 591             hr = IDropTarget_DragEnter(droptarget, active_data_object, MK_LBUTTON,
 592                                        pointl, &effect);
 593             if (SUCCEEDED(hr))
 594             {
 595                 TRACE("    effect %ld\n", effect);
 596                 ret = TRUE;
 597             }
 598             else
 599                 WARN("IDropTarget_DragEnter failed, error 0x%08lx\n", hr);
 600             IDropTarget_Release(droptarget);
 601         }
 602     }
 603     else if (droptarget)
 604     {
 605         POINTL pointl = { pt.x, pt.y };
 606
 607         TRACE("DragOver hwnd %p droptarget %p\n", hwnd, droptarget);
 608         hr = IDropTarget_DragOver(droptarget, MK_LBUTTON, pointl, &effect);
 609         if (SUCCEEDED(hr))
 610         {
 611             TRACE("    effect %ld\n", effect);
 612             ret = TRUE;
 613         }
 614         else
 615             WARN("IDropTarget_DragOver failed, error 0x%08lx\n", hr);
 616         IDropTarget_Release(droptarget);
 617     }
 618
 619     if (!ret)
 620     {
 621         hwnd = WindowFromPoint(pt);
 622         while (hwnd && !(GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_ACCEPTFILES))
 623             hwnd = GetParent(hwnd);
 624         if (hwnd)
 625         {
 626             FORMATETC formatEtc;
 627
 628             if (!active_data_object)
 629                 active_data_object = create_data_object_for_pasteboard(params->handle);
 630
 631             formatEtc.cfFormat = CF_HDROP;
 632             formatEtc.ptd = NULL;
 633             formatEtc.dwAspect = DVASPECT_CONTENT;
 634             formatEtc.lindex = -1;
 635             formatEtc.tymed = TYMED_HGLOBAL;
 636             if (SUCCEEDED(IDataObject_QueryGetData(active_data_object, &formatEtc)))
 637             {
 638                 TRACE("WS_EX_ACCEPTFILES hwnd %p\n", hwnd);
 639                 effect = DROPEFFECT_COPY | DROPEFFECT_LINK;
 640                 ret = TRUE;
 641             }
 642         }
 643     }
 644
 645     TRACE(" -> %s\n", ret ? "TRUE" : "FALSE");
 646     return ret ? effect : 0;
 647 }