/* GDK - The GIMP Drawing Kit * Copyright (C) 1995-1999 Peter Mattis, Spencer Kimball and Josh MacDonald * Copyright (C) 2001 Archaeopteryx Software Inc. * Copyright (C) 1998-2002 Tor Lillqvist * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see <http://www.gnu.org/licenses/>. */ /* * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS * file for a list of people on the GTK+ Team. See the ChangeLog * files for a list of changes. These files are distributed with * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ #include "config.h" #include <string.h> #include <io.h> #include <fcntl.h> /* * Comment from the old OLE2 DND code that is being merged in. Note * that this comment might not fully reflect reality as the code * obviously will have to be modified in this merge. Especially the * talk about supporting other than UTF-8 text is bogus, that will not * happen. * * Support for OLE-2 drag and drop added at Archaeopteryx Software, 2001 * For more information, contact Stephan R.A. Deibel (sdeibel@archaeopteryx.com) * * Notes on implementation: * * This is a first pass at OLE2 support. It only supports text and unicode text * data types, and file list dnd (which is handled seperately as it predates OLE2 * both in this implementation and on Windows in general). * * As such, the data type conversion from gdk selection targets to OLE2 CF_* data * type specifiers is partially hardwired. Fixing this is complicated by (a) the * fact that the widget’s declared selection types aren’t accessible in calls here * that need to declare the corresponding OLE2 data types, and (b) there isn’t a * 1-1 correspondence between gdk target types and OLE2 types. The former needs * some redesign in gtk dnd (something a gdk/gtk expert should do; I have tried * and failed!). As an example of the latter: gdk STRING, TEXT, COMPOUND_TEXT map * to CF_TEXT, CF_OEMTEXT, and CF_UNICODETEXT but as a group and with conversions * necessary for various combinations. Currently, the code here (and in * gdkdnd-win32.c) can handle gdk STRING and TEXT but not COMPOUND_TEXT, and OLE2 * CF_TEXT and CF_UNICODETEXT but not CF_OEMTEXT. The necessary conversions are * supplied by the implementation here. * * Note that in combination with another hack originated by Archaeopteryx * Software, the text conversions here may go to utf-8 unicode as the standard * within-gtk target or to single-byte ascii when the USE_ACP_TEXT compilation * flag is TRUE. This mode was added to support applications that aren’t using * utf-8 across the gtk/gdk API but instead use single-byte ascii according to * the current Windows code page. See gdkim-win32.c for more info on that. * */ /* The mingw.org compiler does not export GUIDS in it's import library. To work * around that, define INITGUID to have the GUIDS declared. */ #if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) #define INITGUID #endif #include "gdkdnd.h" #include "gdkproperty.h" #include "gdkinternals.h" #include "gdkprivate-win32.h" #include "gdkwin32.h" #include "gdkwin32dnd.h" #include "gdk/gdkdndprivate.h" #include <ole2.h> #include <shlobj.h> #include <shlguid.h> #include <gdk/gdk.h> #include <glib/gstdio.h> typedef enum { GDK_DRAG_STATUS_DRAG, GDK_DRAG_STATUS_MOTION_WAIT, GDK_DRAG_STATUS_ACTION_WAIT, GDK_DRAG_STATUS_DROP } GdkDragStatus; struct _GdkWin32DragContext { GdkDragContext context; guint drag_status : 4; /* Current status of drag */ guint drop_failed : 1; /* Whether the drop was unsuccessful */ POINT ole2_dnd_last_pt; /* Coordinates from last event */ DWORD ole2_dnd_last_key_state; /* Key state from last event */ gboolean ole2_dnd_being_finalized; gint ole2_dnd_ref_count; IUnknown *ole2_dnd_iface; }; struct _GdkWin32DragContextClass { GdkDragContextClass parent_class; }; static GList *contexts; static GdkDragContext *current_dest_drag = NULL; static gboolean use_ole2_dnd = FALSE; G_DEFINE_TYPE (GdkWin32DragContext, gdk_win32_drag_context, GDK_TYPE_DRAG_CONTEXT) static void gdk_win32_drag_context_init (GdkWin32DragContext *context) { if (!use_ole2_dnd) { contexts = g_list_prepend (contexts, context); } else { context->ole2_dnd_being_finalized = FALSE; context->ole2_dnd_ref_count = 1; context->ole2_dnd_iface = NULL; } GDK_NOTE (DND, g_print ("gdk_drag_context_init %p\n", context)); } static void gdk_win32_drag_context_finalize (GObject *object) { GdkDragContext *context; GdkWin32DragContext *context_win32; GDK_NOTE (DND, g_print ("gdk_drag_context_finalize %p\n", object)); g_return_if_fail (GDK_IS_WIN32_DRAG_CONTEXT (object)); context = GDK_DRAG_CONTEXT (object); context_win32 = GDK_WIN32_DRAG_CONTEXT (object); if (!use_ole2_dnd) { contexts = g_list_remove (contexts, context); if (context == current_dest_drag) current_dest_drag = NULL; } else { if (context_win32->ole2_dnd_iface) { context_win32->ole2_dnd_being_finalized = TRUE; context_win32->ole2_dnd_iface->lpVtbl->Release (context_win32->ole2_dnd_iface); context_win32->ole2_dnd_iface = NULL; } } G_OBJECT_CLASS (gdk_win32_drag_context_parent_class)->finalize (object); } /* Drag Contexts */ static GdkDragContext * gdk_drag_context_new (GdkDisplay *display) { GdkWin32DragContext *context_win32; GdkDragContext *context; context_win32 = g_object_new (GDK_TYPE_WIN32_DRAG_CONTEXT, NULL); context = GDK_DRAG_CONTEXT(context_win32); gdk_drag_context_set_device (context, gdk_seat_get_pointer (gdk_display_get_default_seat (display))); return context; } static GdkDragContext * gdk_drag_context_find (gboolean is_source, GdkWindow *source, GdkWindow *dest) { GList *tmp_list = contexts; GdkDragContext *context; while (tmp_list) { context = (GdkDragContext *)tmp_list->data; if ((!context->is_source == !is_source) && ((source == NULL) || (context->source_window && (context->source_window == source))) && ((dest == NULL) || (context->dest_window && (context->dest_window == dest)))) return context; tmp_list = tmp_list->next; } return NULL; } #define PRINT_GUID(guid) \ g_print ("%.08lx-%.04x-%.04x-%.02x%.02x-%.02x%.02x%.02x%.02x%.02x%.02x", \ ((gulong *) guid)[0], \ ((gushort *) guid)[2], \ ((gushort *) guid)[3], \ ((guchar *) guid)[8], \ ((guchar *) guid)[9], \ ((guchar *) guid)[10], \ ((guchar *) guid)[11], \ ((guchar *) guid)[12], \ ((guchar *) guid)[13], \ ((guchar *) guid)[14], \ ((guchar *) guid)[15]); static FORMATETC *formats; static int nformats; typedef struct { IDropTarget idt; GdkDragContext *context; } target_drag_context; typedef struct { IDropSource ids; GdkDragContext *context; } source_drag_context; typedef struct { IDataObject ido; int ref_count; GdkDragContext *context; } data_object; typedef struct { IEnumFORMATETC ief; int ref_count; int ix; } enum_formats; static source_drag_context *pending_src_context = NULL; static IDataObject *dnd_data = NULL; static enum_formats *enum_formats_new (void); /* map windows -> target drag contexts. The table * owns a ref to both objects. */ static GHashTable* target_ctx_for_window = NULL; static ULONG STDMETHODCALLTYPE idroptarget_addref (LPDROPTARGET This) { target_drag_context *ctx = (target_drag_context *) This; GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (ctx->context); int ref_count = ++context_win32->ole2_dnd_ref_count; GDK_NOTE (DND, g_print ("idroptarget_addref %p %d\n", This, ref_count)); g_object_ref (G_OBJECT (ctx->context)); return ref_count; } static HRESULT STDMETHODCALLTYPE idroptarget_queryinterface (LPDROPTARGET This, REFIID riid, LPVOID *ppvObject) { GDK_NOTE (DND, { g_print ("idroptarget_queryinterface %p ", This); PRINT_GUID (riid); }); *ppvObject = NULL; if (IsEqualGUID (riid, &IID_IUnknown)) { GDK_NOTE (DND, g_print ("...IUnknown S_OK\n")); idroptarget_addref (This); *ppvObject = This; return S_OK; } else if (IsEqualGUID (riid, &IID_IDropTarget)) { GDK_NOTE (DND, g_print ("...IDropTarget S_OK\n")); idroptarget_addref (This); *ppvObject = This; return S_OK; } else { GDK_NOTE (DND, g_print ("...E_NOINTERFACE\n")); return E_NOINTERFACE; } } static ULONG STDMETHODCALLTYPE idroptarget_release (LPDROPTARGET This) { target_drag_context *ctx = (target_drag_context *) This; GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (ctx->context); int ref_count = --context_win32->ole2_dnd_ref_count; GDK_NOTE (DND, g_print ("idroptarget_release %p %d\n", This, ref_count)); if (!context_win32->ole2_dnd_being_finalized) g_object_unref (G_OBJECT (ctx->context)); if (ref_count == 0) g_free (This); return ref_count; } #if 0 static GdkAtom cf_to_atom (CLIPFORMAT cf) { switch (cf) { case CF_UNICODETEXT: return _utf8_string; case CF_HDROP: return _text_uri_list; case CF_DIB: return _image_bmp; } if (cf == _cf_url) return _text_uri_list; if (cf == _cf_html_format || cf == _cf_text_html) return _text_html; return GDK_NONE; } #endif static GdkDragAction get_suggested_action (DWORD grfKeyState) { /* This is the yucky Windows standard: Force link action if both * Control and Alt are down, copy if Control is down alone, move if * Alt is down alone, or use default of move within the app or copy * when origin of the drag is in another app. */ if (grfKeyState & MK_CONTROL && grfKeyState & MK_SHIFT) return GDK_ACTION_LINK; /* Link action not supported */ else if (grfKeyState & MK_CONTROL) return GDK_ACTION_COPY; else if (grfKeyState & MK_ALT) return GDK_ACTION_MOVE; #if 0 /* Default is always copy for now */ else if (_dnd_source_state == GDK_WIN32_DND_DRAGGING) return GDK_ACTION_MOVE; #endif else return GDK_ACTION_COPY; /* Any way to determine when to add in DROPEFFECT_SCROLL? */ } /* Process pending events -- we don't want to service non-GUI events * forever so do one iteration and then do more only if there’s a * pending GDK event. */ static void process_pending_events (GdkDisplay *display) { g_main_context_iteration (NULL, FALSE); while (_gdk_event_queue_find_first (display)) g_main_context_iteration (NULL, FALSE); } static DWORD drop_effect_for_action (GdkDragAction action) { switch (action) { case GDK_ACTION_MOVE: return DROPEFFECT_MOVE; case GDK_ACTION_LINK: return DROPEFFECT_LINK; case GDK_ACTION_COPY: return DROPEFFECT_COPY; default: return DROPEFFECT_NONE; } } static void dnd_event_put (GdkEventType type, GdkDragContext *context, const POINTL pt, gboolean to_dest_window) { GdkEvent *e; e = gdk_event_new (type); if (to_dest_window) e->dnd.window = context->dest_window; else e->dnd.window = context->source_window; e->dnd.send_event = FALSE; e->dnd.context = g_object_ref (context); e->dnd.time = GDK_CURRENT_TIME; e->dnd.x_root = pt.x + _gdk_offset_x; e->dnd.y_root = pt.x + _gdk_offset_y; if (e->dnd.window != NULL) g_object_ref (e->dnd.window); gdk_event_set_device (e, gdk_drag_context_get_device (context)); gdk_event_set_seat (e, gdk_device_get_seat (gdk_drag_context_get_device (context))); GDK_NOTE (EVENTS, _gdk_win32_print_event (e)); gdk_event_put (e); gdk_event_free (e); } static HRESULT STDMETHODCALLTYPE idroptarget_dragenter (LPDROPTARGET This, LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect) { target_drag_context *ctx = (target_drag_context *) This; GDK_NOTE (DND, g_print ("idroptarget_dragenter %p S_OK\n", This)); ctx->context->suggested_action = get_suggested_action (grfKeyState); dnd_event_put (GDK_DRAG_ENTER, ctx->context, pt, TRUE); process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); *pdwEffect = drop_effect_for_action (ctx->context->action); /* Assume that target can accept the data: In fact it may fail but * we are not really set up to query the target! */ return S_OK; } static HRESULT STDMETHODCALLTYPE idroptarget_dragover (LPDROPTARGET This, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect) { target_drag_context *ctx = (target_drag_context *) This; GDK_NOTE (DND, g_print ("idroptarget_dragover %p S_OK\n", This)); ctx->context->suggested_action = get_suggested_action (grfKeyState); dnd_event_put (GDK_DRAG_MOTION, ctx->context, pt, TRUE); process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); *pdwEffect = drop_effect_for_action (ctx->context->action); return S_OK; } static HRESULT STDMETHODCALLTYPE idroptarget_dragleave (LPDROPTARGET This) { target_drag_context *ctx = (target_drag_context *) This; POINTL pt = { 0, 0 }; GDK_NOTE (DND, g_print ("idroptarget_dragleave %p S_OK\n", This)); dnd_event_put (GDK_DRAG_LEAVE, ctx->context, pt, TRUE); process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); return S_OK; } static HRESULT STDMETHODCALLTYPE idroptarget_drop (LPDROPTARGET This, LPDATAOBJECT pDataObj, DWORD grfKeyState, POINTL pt, LPDWORD pdwEffect) { target_drag_context *ctx = (target_drag_context *) This; GDK_NOTE (DND, g_print ("idroptarget_drop %p ", This)); if (pDataObj == NULL) { GDK_NOTE (DND, g_print ("E_POINTER\n")); return E_POINTER; } dnd_data = pDataObj; ctx->context->suggested_action = get_suggested_action (grfKeyState); dnd_event_put (GDK_DROP_START, ctx->context, pt, TRUE); process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); dnd_data = NULL; /* Notify OLE of copy or move */ if (_dnd_target_state != GDK_WIN32_DND_DROPPED) *pdwEffect = DROPEFFECT_NONE; else *pdwEffect = drop_effect_for_action (ctx->context->action); GDK_NOTE (DND, g_print ("S_OK\n")); return S_OK; } static ULONG STDMETHODCALLTYPE idropsource_addref (LPDROPSOURCE This) { source_drag_context *ctx = (source_drag_context *) This; GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (ctx->context); int ref_count = ++context_win32->ole2_dnd_ref_count; GDK_NOTE (DND, g_print ("idropsource_addref %p %d\n", This, ref_count)); g_object_ref (G_OBJECT (ctx->context)); return ref_count; } static HRESULT STDMETHODCALLTYPE idropsource_queryinterface (LPDROPSOURCE This, REFIID riid, LPVOID *ppvObject) { GDK_NOTE (DND, { g_print ("idropsource_queryinterface %p ", This); PRINT_GUID (riid); }); *ppvObject = NULL; if (IsEqualGUID (riid, &IID_IUnknown)) { GDK_NOTE (DND, g_print ("...IUnknown S_OK\n")); idropsource_addref (This); *ppvObject = This; return S_OK; } else if (IsEqualGUID (riid, &IID_IDropSource)) { GDK_NOTE (DND, g_print ("...IDropSource S_OK\n")); idropsource_addref (This); *ppvObject = This; return S_OK; } else { GDK_NOTE (DND, g_print ("...E_NOINTERFACE\n")); return E_NOINTERFACE; } } static ULONG STDMETHODCALLTYPE idropsource_release (LPDROPSOURCE This) { source_drag_context *ctx = (source_drag_context *) This; GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (ctx->context); int ref_count = --context_win32->ole2_dnd_ref_count; GDK_NOTE (DND, g_print ("idropsource_release %p %d\n", This, ref_count)); if (!context_win32->ole2_dnd_being_finalized) g_object_unref (G_OBJECT (ctx->context)); if (ref_count == 0) g_free (This); return ref_count; } /* Emit GDK events for any changes in mouse events or control key * state since the last recorded state. Return true if any events * have been emitted and false otherwise. */ static gboolean send_change_events (GdkDragContext *context, DWORD key_state, gboolean esc_pressed) { GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (context); POINT pt; gboolean changed = FALSE; HWND hwnd = GDK_WINDOW_HWND (context->source_window); LPARAM lparam; WPARAM wparam; if (!API_CALL (GetCursorPos, (&pt))) return FALSE; if (!API_CALL (ScreenToClient, (hwnd, &pt))) return FALSE; if (pt.x != context_win32->ole2_dnd_last_pt.x || pt.y != context_win32->ole2_dnd_last_pt.y || key_state != context_win32->ole2_dnd_last_key_state) { lparam = MAKELPARAM (pt.x, pt.y); wparam = key_state; if (pt.x != context_win32->ole2_dnd_last_pt.x || pt.y != context_win32->ole2_dnd_last_pt.y) { GDK_NOTE (DND, g_print ("Sending WM_MOUSEMOVE (%ld,%ld)\n", pt.x, pt.y)); SendMessage (hwnd, WM_MOUSEMOVE, wparam, lparam); } if ((key_state & MK_LBUTTON) != (context_win32->ole2_dnd_last_key_state & MK_LBUTTON)) { if (key_state & MK_LBUTTON) SendMessage (hwnd, WM_LBUTTONDOWN, wparam, lparam); else SendMessage (hwnd, WM_LBUTTONUP, wparam, lparam); } if ((key_state & MK_MBUTTON) != (context_win32->ole2_dnd_last_key_state & MK_MBUTTON)) { if (key_state & MK_MBUTTON) SendMessage (hwnd, WM_MBUTTONDOWN, wparam, lparam); else SendMessage (hwnd, WM_MBUTTONUP, wparam, lparam); } if ((key_state & MK_RBUTTON) != (context_win32->ole2_dnd_last_key_state & MK_RBUTTON)) { if (key_state & MK_RBUTTON) SendMessage (hwnd, WM_RBUTTONDOWN, wparam, lparam); else SendMessage (hwnd, WM_RBUTTONUP, wparam, lparam); } if ((key_state & MK_CONTROL) != (context_win32->ole2_dnd_last_key_state & MK_CONTROL)) { if (key_state & MK_CONTROL) SendMessage (hwnd, WM_KEYDOWN, VK_CONTROL, 0); else SendMessage (hwnd, WM_KEYUP, VK_CONTROL, 0); } if ((key_state & MK_SHIFT) != (context_win32->ole2_dnd_last_key_state & MK_SHIFT)) { if (key_state & MK_CONTROL) SendMessage (hwnd, WM_KEYDOWN, VK_SHIFT, 0); else SendMessage (hwnd, WM_KEYUP, VK_SHIFT, 0); } changed = TRUE; context_win32->ole2_dnd_last_key_state = key_state; context_win32->ole2_dnd_last_pt = pt; } if (esc_pressed) { GDK_NOTE (DND, g_print ("Sending a escape key down message to %p\n", hwnd)); SendMessage (hwnd, WM_KEYDOWN, VK_ESCAPE, 0); changed = TRUE; } return changed; } static HRESULT STDMETHODCALLTYPE idropsource_querycontinuedrag (LPDROPSOURCE This, BOOL fEscapePressed, DWORD grfKeyState) { source_drag_context *ctx = (source_drag_context *) This; GDK_NOTE (DND, g_print ("idropsource_querycontinuedrag %p ", This)); if (send_change_events (ctx->context, grfKeyState, fEscapePressed)) process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); if (_dnd_source_state == GDK_WIN32_DND_DROPPED) { GDK_NOTE (DND, g_print ("DRAGDROP_S_DROP\n")); return DRAGDROP_S_DROP; } else if (_dnd_source_state == GDK_WIN32_DND_NONE) { GDK_NOTE (DND, g_print ("DRAGDROP_S_CANCEL\n")); return DRAGDROP_S_CANCEL; } else { GDK_NOTE (DND, g_print ("S_OK\n")); return S_OK; } } static HRESULT STDMETHODCALLTYPE idropsource_givefeedback (LPDROPSOURCE This, DWORD dwEffect) { source_drag_context *ctx = (source_drag_context *) This; GdkDragAction suggested_action; GDK_NOTE (DND, g_print ("idropsource_givefeedback %p DRAGDROP_S_USEDEFAULTCURSORS\n", This)); if (dwEffect == DROPEFFECT_MOVE) suggested_action = GDK_ACTION_MOVE; else suggested_action = GDK_ACTION_COPY; ctx->context->action = suggested_action; if (dwEffect == DROPEFFECT_NONE) { if (ctx->context->dest_window != NULL) { g_object_unref (ctx->context->dest_window); ctx->context->dest_window = NULL; } } else { if (ctx->context->dest_window == NULL) ctx->context->dest_window = g_object_ref (gdk_get_default_root_window ()); } return DRAGDROP_S_USEDEFAULTCURSORS; } static ULONG STDMETHODCALLTYPE idataobject_addref (LPDATAOBJECT This) { data_object *dobj = (data_object *) This; int ref_count = ++dobj->ref_count; GDK_NOTE (DND, g_print ("idataobject_addref %p %d\n", This, ref_count)); return ref_count; } static HRESULT STDMETHODCALLTYPE idataobject_queryinterface (LPDATAOBJECT This, REFIID riid, LPVOID *ppvObject) { GDK_NOTE (DND, { g_print ("idataobject_queryinterface %p ", This); PRINT_GUID (riid); }); *ppvObject = NULL; if (IsEqualGUID (riid, &IID_IUnknown)) { GDK_NOTE (DND, g_print ("...IUnknown S_OK\n")); idataobject_addref (This); *ppvObject = This; return S_OK; } else if (IsEqualGUID (riid, &IID_IDataObject)) { GDK_NOTE (DND, g_print ("...IDataObject S_OK\n")); idataobject_addref (This); *ppvObject = This; return S_OK; } else { GDK_NOTE (DND, g_print ("...E_NOINTERFACE\n")); return E_NOINTERFACE; } } static ULONG STDMETHODCALLTYPE idataobject_release (LPDATAOBJECT This) { data_object *dobj = (data_object *) This; int ref_count = --dobj->ref_count; GDK_NOTE (DND, g_print ("idataobject_release %p %d\n", This, ref_count)); if (ref_count == 0) g_free (This); return ref_count; } static HRESULT query (LPDATAOBJECT This, LPFORMATETC pFormatEtc) { int i; if (!pFormatEtc) return DV_E_FORMATETC; if (pFormatEtc->lindex != -1) return DV_E_LINDEX; if ((pFormatEtc->tymed & TYMED_HGLOBAL) == 0) return DV_E_TYMED; if ((pFormatEtc->dwAspect & DVASPECT_CONTENT) == 0) return DV_E_DVASPECT; for (i = 0; i < nformats; i++) if (pFormatEtc->cfFormat == formats[i].cfFormat) return S_OK; return DV_E_FORMATETC; } static FORMATETC *active_pFormatEtc = NULL; static STGMEDIUM *active_pMedium = NULL; static HRESULT STDMETHODCALLTYPE idataobject_getdata (LPDATAOBJECT This, LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) { data_object *ctx = (data_object *) This; HRESULT hr; GdkEvent e; GDK_NOTE (DND, g_print ("idataobject_getdata %p %s ", This, _gdk_win32_cf_to_string (pFormatEtc->cfFormat))); /* Check whether we can provide requested format */ hr = query (This, pFormatEtc); if (hr != S_OK) return hr; /* Append a GDK_SELECTION_GET event and then hope the app sets the * property associated with the _gdk_ole2_dnd atom */ active_pFormatEtc = pFormatEtc; active_pMedium = pMedium; e.type = GDK_SELECTION_REQUEST; e.selection.window = ctx->context->source_window; e.selection.send_event = FALSE; /* ??? */ /* FIXME: Should really both selection and property be _gdk_ole2_dnd? */ e.selection.selection = _gdk_ole2_dnd; /* FIXME: Target? */ e.selection.target = _utf8_string; e.selection.property = _gdk_ole2_dnd; e.selection.time = GDK_CURRENT_TIME; g_object_ref (e.selection.window); GDK_NOTE (EVENTS, _gdk_win32_print_event (&e)); gdk_event_put (&e); process_pending_events (gdk_device_get_display (gdk_drag_context_get_device (ctx->context))); active_pFormatEtc = NULL; active_pMedium = NULL; if (pMedium->hGlobal == NULL) { return E_UNEXPECTED; } return S_OK; } static HRESULT STDMETHODCALLTYPE idataobject_getdatahere (LPDATAOBJECT This, LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium) { GDK_NOTE (DND, g_print ("idataobject_getdatahere %p %s E_UNEXPECTED\n", This, _gdk_win32_cf_to_string (pFormatEtc->cfFormat))); return E_UNEXPECTED; } static HRESULT STDMETHODCALLTYPE idataobject_querygetdata (LPDATAOBJECT This, LPFORMATETC pFormatEtc) { HRESULT hr; hr = query (This, pFormatEtc); #define CASE(x) case x: g_print (#x) GDK_NOTE (DND, { g_print ("idataobject_querygetdata %p %s \n", This, _gdk_win32_cf_to_string (pFormatEtc->cfFormat)); switch (hr) { CASE (DV_E_FORMATETC); CASE (DV_E_LINDEX); CASE (DV_E_TYMED); CASE (DV_E_DVASPECT); CASE (S_OK); default: g_print ("%#lx", hr); } }); return hr; } static HRESULT STDMETHODCALLTYPE idataobject_getcanonicalformatetc (LPDATAOBJECT This, LPFORMATETC pFormatEtcIn, LPFORMATETC pFormatEtcOut) { GDK_NOTE (DND, g_print ("idataobject_getcanonicalformatetc %p E_UNEXPECTED\n", This)); return E_UNEXPECTED; } static HRESULT STDMETHODCALLTYPE idataobject_setdata (LPDATAOBJECT This, LPFORMATETC pFormatEtc, LPSTGMEDIUM pMedium, BOOL fRelease) { GDK_NOTE (DND, g_print ("idataobject_setdata %p %s E_UNEXPECTED\n", This, _gdk_win32_cf_to_string (pFormatEtc->cfFormat))); return E_UNEXPECTED; } static HRESULT STDMETHODCALLTYPE idataobject_enumformatetc (LPDATAOBJECT This, DWORD dwDirection, LPENUMFORMATETC *ppEnumFormatEtc) { GDK_NOTE (DND, g_print ("idataobject_enumformatetc %p ", This)); if (dwDirection != DATADIR_GET) { GDK_NOTE (DND, g_print ("E_NOTIMPL\n")); return E_NOTIMPL; } *ppEnumFormatEtc = &enum_formats_new ()->ief; GDK_NOTE (DND, g_print ("%p S_OK\n", *ppEnumFormatEtc)); return S_OK; } static HRESULT STDMETHODCALLTYPE idataobject_dadvise (LPDATAOBJECT This, LPFORMATETC pFormatetc, DWORD advf, LPADVISESINK pAdvSink, DWORD *pdwConnection) { GDK_NOTE (DND, g_print ("idataobject_dadvise %p E_NOTIMPL\n", This)); return E_NOTIMPL; } static HRESULT STDMETHODCALLTYPE idataobject_dunadvise (LPDATAOBJECT This, DWORD dwConnection) { GDK_NOTE (DND, g_print ("idataobject_dunadvise %p E_NOTIMPL\n", This)); return E_NOTIMPL; } static HRESULT STDMETHODCALLTYPE idataobject_enumdadvise (LPDATAOBJECT This, LPENUMSTATDATA *ppenumAdvise) { GDK_NOTE (DND, g_print ("idataobject_enumdadvise %p OLE_E_ADVISENOTSUPPORTED\n", This)); return OLE_E_ADVISENOTSUPPORTED; } static ULONG STDMETHODCALLTYPE ienumformatetc_addref (LPENUMFORMATETC This) { enum_formats *en = (enum_formats *) This; int ref_count = ++en->ref_count; GDK_NOTE (DND, g_print ("ienumformatetc_addref %p %d\n", This, ref_count)); return ref_count; } static HRESULT STDMETHODCALLTYPE ienumformatetc_queryinterface (LPENUMFORMATETC This, REFIID riid, LPVOID *ppvObject) { GDK_NOTE (DND, { g_print ("ienumformatetc_queryinterface %p", This); PRINT_GUID (riid); }); *ppvObject = NULL; if (IsEqualGUID (riid, &IID_IUnknown)) { GDK_NOTE (DND, g_print ("...IUnknown S_OK\n")); ienumformatetc_addref (This); *ppvObject = This; return S_OK; } else if (IsEqualGUID (riid, &IID_IEnumFORMATETC)) { GDK_NOTE (DND, g_print ("...IEnumFORMATETC S_OK\n")); ienumformatetc_addref (This); *ppvObject = This; return S_OK; } else { GDK_NOTE (DND, g_print ("...E_NOINTERFACE\n")); return E_NOINTERFACE; } } static ULONG STDMETHODCALLTYPE ienumformatetc_release (LPENUMFORMATETC This) { enum_formats *en = (enum_formats *) This; int ref_count = --en->ref_count; GDK_NOTE (DND, g_print ("ienumformatetc_release %p %d\n", This, ref_count)); if (ref_count == 0) g_free (This); return ref_count; } static HRESULT STDMETHODCALLTYPE ienumformatetc_next (LPENUMFORMATETC This, ULONG celt, LPFORMATETC elts, ULONG *nelt) { enum_formats *en = (enum_formats *) This; ULONG i, n; GDK_NOTE (DND, g_print ("ienumformatetc_next %p %d %ld ", This, en->ix, celt)); n = 0; for (i = 0; i < celt; i++) { if (en->ix >= nformats) break; elts[i] = formats[en->ix++]; n++; } if (nelt != NULL) *nelt = n; GDK_NOTE (DND, g_print ("%s\n", (n == celt) ? "S_OK" : "S_FALSE")); if (n == celt) return S_OK; else return S_FALSE; } static HRESULT STDMETHODCALLTYPE ienumformatetc_skip (LPENUMFORMATETC This, ULONG celt) { enum_formats *en = (enum_formats *) This; GDK_NOTE (DND, g_print ("ienumformatetc_skip %p %d %ld S_OK\n", This, en->ix, celt)); en->ix += celt; return S_OK; } static HRESULT STDMETHODCALLTYPE ienumformatetc_reset (LPENUMFORMATETC This) { enum_formats *en = (enum_formats *) This; GDK_NOTE (DND, g_print ("ienumformatetc_reset %p S_OK\n", This)); en->ix = 0; return S_OK; } static HRESULT STDMETHODCALLTYPE ienumformatetc_clone (LPENUMFORMATETC This, LPENUMFORMATETC *ppEnumFormatEtc) { enum_formats *en = (enum_formats *) This; enum_formats *new; GDK_NOTE (DND, g_print ("ienumformatetc_clone %p S_OK\n", This)); new = enum_formats_new (); new->ix = en->ix; *ppEnumFormatEtc = &new->ief; return S_OK; } static IDropTargetVtbl idt_vtbl = { idroptarget_queryinterface, idroptarget_addref, idroptarget_release, idroptarget_dragenter, idroptarget_dragover, idroptarget_dragleave, idroptarget_drop }; static IDropSourceVtbl ids_vtbl = { idropsource_queryinterface, idropsource_addref, idropsource_release, idropsource_querycontinuedrag, idropsource_givefeedback }; static IDataObjectVtbl ido_vtbl = { idataobject_queryinterface, idataobject_addref, idataobject_release, idataobject_getdata, idataobject_getdatahere, idataobject_querygetdata, idataobject_getcanonicalformatetc, idataobject_setdata, idataobject_enumformatetc, idataobject_dadvise, idataobject_dunadvise, idataobject_enumdadvise }; static IEnumFORMATETCVtbl ief_vtbl = { ienumformatetc_queryinterface, ienumformatetc_addref, ienumformatetc_release, ienumformatetc_next, ienumformatetc_skip, ienumformatetc_reset, ienumformatetc_clone }; static target_drag_context * target_context_new (GdkWindow *window) { GdkDragContext *context; GdkWin32DragContext *context_win32; target_drag_context *result; context = gdk_drag_context_new (gdk_window_get_display (window)); context_win32 = GDK_WIN32_DRAG_CONTEXT (context); result = g_new0 (target_drag_context, 1); result->context = context; result->idt.lpVtbl = &idt_vtbl; result->context->protocol = GDK_DRAG_PROTO_OLE2; result->context->is_source = FALSE; result->context->source_window = NULL; result->context->dest_window = window; g_object_ref (window); /* FIXME: context->targets? */ result->context->actions = GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE; result->context->suggested_action = GDK_ACTION_MOVE; result->context->action = GDK_ACTION_MOVE; context_win32->ole2_dnd_iface = (IUnknown *) &result->idt; idroptarget_addref (&result->idt); GDK_NOTE (DND, g_print ("target_context_new: %p\n", result)); return result; } static source_drag_context * source_context_new (GdkWindow *window, GList *targets) { GdkDragContext *context; GdkWin32DragContext *context_win32; source_drag_context *result; context = gdk_drag_context_new (gdk_window_get_display (window)); context_win32 = GDK_WIN32_DRAG_CONTEXT (context); result = g_new0 (source_drag_context, 1); result->context = context; result->ids.lpVtbl = &ids_vtbl; result->context->protocol = GDK_DRAG_PROTO_OLE2; result->context->is_source = TRUE; result->context->source_window = window; g_object_ref (window); result->context->dest_window = NULL; result->context->targets = g_list_copy (targets); context_win32->ole2_dnd_iface = (IUnknown *) &result->ids; idropsource_addref (&result->ids); GDK_NOTE (DND, g_print ("source_context_new: %p\n", result)); return result; } static data_object * data_object_new (GdkDragContext *context) { data_object *result; result = g_new0 (data_object, 1); result->ido.lpVtbl = &ido_vtbl; result->ref_count = 1; result->context = context; GDK_NOTE (DND, g_print ("data_object_new: %p\n", result)); return result; } static enum_formats * enum_formats_new (void) { enum_formats *result; result = g_new0 (enum_formats, 1); result->ief.lpVtbl = &ief_vtbl; result->ref_count = 1; result->ix = 0; return result; } void _gdk_win32_ole2_dnd_property_change (GdkAtom type, gint format, const guchar *data, gint nelements) { if (use_ole2_dnd) { HGLOBAL hdata = NULL; if (active_pFormatEtc == NULL || active_pMedium == NULL) return; /* Set up the data buffer for wide character text request */ if (active_pFormatEtc->cfFormat == CF_UNICODETEXT) { gunichar2 *wdata; glong wlen; wdata = g_utf8_to_utf16 ((const char *) data, -1, NULL, &wlen, NULL); hdata = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (wlen + 1) * 2); if (hdata) { wchar_t *ptr = (wchar_t *) GlobalLock(hdata); memcpy (ptr, wdata, (wlen + 1) * 2); GlobalUnlock(hdata); } g_free (wdata); } else g_warning ("Only text handled for now"); /* Pack up data */ active_pMedium->tymed = TYMED_HGLOBAL; active_pMedium->hGlobal = hdata; active_pMedium->pUnkForRelease = 0; } } /* From MS Knowledge Base article Q130698 */ static gboolean resolve_link (HWND hWnd, wchar_t *link, gchar **lpszPath) { WIN32_FILE_ATTRIBUTE_DATA wfad; HRESULT hr; IShellLinkW *pslW = NULL; IPersistFile *ppf = NULL; /* Check if the file is empty first because IShellLink::Resolve for * some reason succeeds with an empty file and returns an empty * "link target". (#524151) */ if (!GetFileAttributesExW (link, GetFileExInfoStandard, &wfad) || (wfad.nFileSizeHigh == 0 && wfad.nFileSizeLow == 0)) return FALSE; /* Assume failure to start with: */ *lpszPath = 0; /* Call CoCreateInstance to obtain the IShellLink interface * pointer. This call fails if CoInitialize is not called, so it is * assumed that CoInitialize has been called. */ hr = CoCreateInstance (&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID *)&pslW); if (SUCCEEDED (hr)) { /* The IShellLink interface supports the IPersistFile * interface. Get an interface pointer to it. */ hr = pslW->lpVtbl->QueryInterface (pslW, &IID_IPersistFile, (LPVOID *) &ppf); } if (SUCCEEDED (hr)) { /* Load the file. */ hr = ppf->lpVtbl->Load (ppf, link, STGM_READ); } if (SUCCEEDED (hr)) { /* Resolve the link by calling the Resolve() * interface function. */ hr = pslW->lpVtbl->Resolve (pslW, hWnd, SLR_ANY_MATCH | SLR_NO_UI); } if (SUCCEEDED (hr)) { wchar_t wtarget[MAX_PATH]; hr = pslW->lpVtbl->GetPath (pslW, wtarget, MAX_PATH, NULL, 0); if (SUCCEEDED (hr)) *lpszPath = g_utf16_to_utf8 (wtarget, -1, NULL, NULL, NULL); } if (ppf) ppf->lpVtbl->Release (ppf); if (pslW) pslW->lpVtbl->Release (pslW); return SUCCEEDED (hr); } #if 0 /* Check for filenames like C:\Users\tml\AppData\Local\Temp\d5qtkvvs.bmp */ static gboolean filename_looks_tempish (const char *filename) { char *dirname; char *p; const char *q; gboolean retval = FALSE; dirname = g_path_get_dirname (filename); p = dirname; q = g_get_tmp_dir (); while (*p && *q && ((G_IS_DIR_SEPARATOR (*p) && G_IS_DIR_SEPARATOR (*q)) || g_ascii_tolower (*p) == g_ascii_tolower (*q))) p++, q++; if (!*p && !*q) retval = TRUE; g_free (dirname); return retval; } static gboolean close_it (gpointer data) { close (GPOINTER_TO_INT (data)); return FALSE; } #endif static GdkFilterReturn gdk_dropfiles_filter (GdkXEvent *xev, GdkEvent *event, gpointer data) { GdkDragContext *context; GString *result; MSG *msg = (MSG *) xev; HANDLE hdrop; POINT pt; gint nfiles, i; gchar *fileName, *linkedFile; if (msg->message == WM_DROPFILES) { GDK_NOTE (DND, g_print ("WM_DROPFILES: %p\n", msg->hwnd)); context = gdk_drag_context_new (gdk_window_get_display (event->any.window)); context->protocol = GDK_DRAG_PROTO_WIN32_DROPFILES; context->is_source = FALSE; context->source_window = gdk_get_default_root_window (); g_object_ref (context->source_window); context->dest_window = event->any.window; g_object_ref (context->dest_window); /* WM_DROPFILES drops are always file names */ context->targets = g_list_append (NULL, _text_uri_list); context->actions = GDK_ACTION_COPY; context->suggested_action = GDK_ACTION_COPY; current_dest_drag = context; event->dnd.type = GDK_DROP_START; event->dnd.context = current_dest_drag; gdk_event_set_device (event, gdk_drag_context_get_device (current_dest_drag)); gdk_event_set_seat (event, gdk_device_get_seat (gdk_drag_context_get_device (current_dest_drag))); hdrop = (HANDLE) msg->wParam; DragQueryPoint (hdrop, &pt); ClientToScreen (msg->hwnd, &pt); event->dnd.x_root = pt.x + _gdk_offset_x; event->dnd.y_root = pt.y + _gdk_offset_y; event->dnd.time = _gdk_win32_get_next_tick (msg->time); nfiles = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0); result = g_string_new (NULL); for (i = 0; i < nfiles; i++) { gchar *uri; wchar_t wfn[MAX_PATH]; DragQueryFileW (hdrop, i, wfn, MAX_PATH); fileName = g_utf16_to_utf8 (wfn, -1, NULL, NULL, NULL); /* Resolve shortcuts */ if (resolve_link (msg->hwnd, wfn, &linkedFile)) { uri = g_filename_to_uri (linkedFile, NULL, NULL); if (uri != NULL) { g_string_append (result, uri); GDK_NOTE (DND, g_print ("... %s link to %s: %s\n", fileName, linkedFile, uri)); g_free (uri); } g_free (fileName); fileName = linkedFile; } else { uri = g_filename_to_uri (fileName, NULL, NULL); if (uri != NULL) { g_string_append (result, uri); GDK_NOTE (DND, g_print ("... %s: %s\n", fileName, uri)); g_free (uri); } } #if 0 /* Awful hack to recognize temp files corresponding to * images dragged from Firefox... Open the file right here * so that it is less likely that Firefox manages to delete * it before the GTK+-using app (typically GIMP) has opened * it. * * Not compiled in for now, because it means images dragged * from Firefox would stay around in the temp folder which * is not what Firefox intended. I don't feel comfortable * with that, both from a geenral sanity point of view, and * from a privacy point of view. It's better to wait for * Firefox to fix the problem, for instance by deleting the * temp file after a longer delay, or to wait until we * implement the OLE2_DND... */ if (filename_looks_tempish (fileName)) { int fd = g_open (fileName, _O_RDONLY|_O_BINARY, 0); if (fd == -1) { GDK_NOTE (DND, g_print ("Could not open %s, maybe an image dragged from Firefox that it already deleted\n", fileName)); } else { GDK_NOTE (DND, g_print ("Opened %s as %d so that Firefox won't delete it\n", fileName, fd)); g_timeout_add_seconds (1, close_it, GINT_TO_POINTER (fd)); } } #endif g_free (fileName); g_string_append (result, "\015\012"); } _gdk_dropfiles_store (result->str); g_string_free (result, FALSE); DragFinish (hdrop); return GDK_FILTER_TRANSLATE; } else return GDK_FILTER_CONTINUE; } static void add_format (GArray *fmts, CLIPFORMAT cf) { FORMATETC fmt; fmt.cfFormat = cf; fmt.ptd = NULL; fmt.dwAspect = DVASPECT_CONTENT; fmt.lindex = -1; fmt.tymed = TYMED_HGLOBAL; g_array_append_val (fmts, fmt); } void _gdk_dnd_init (void) { CoInitializeEx (NULL, COINIT_APARTMENTTHREADED); if (getenv ("GDK_WIN32_USE_EXPERIMENTAL_OLE2_DND")) use_ole2_dnd = TRUE; if (use_ole2_dnd) { HRESULT hr; GArray *fmts; hr = OleInitialize (NULL); if (! SUCCEEDED (hr)) g_error ("OleInitialize failed"); fmts = g_array_new (FALSE, FALSE, sizeof (FORMATETC)); /* The most important presumably */ add_format (fmts, CF_UNICODETEXT); /* Used for GTK+ internal DND, I think was the intent? Anyway, code below assumes * this is at index 1. */ add_format (fmts, CF_GDIOBJFIRST); add_format (fmts, CF_HDROP); add_format (fmts, _cf_png); add_format (fmts, CF_DIB); add_format (fmts, _cf_url); add_format (fmts, _cf_html_format); add_format (fmts, _cf_text_html); nformats = fmts->len; formats = (FORMATETC*) g_array_free (fmts, FALSE); target_ctx_for_window = g_hash_table_new (g_direct_hash, g_direct_equal); } } void _gdk_win32_dnd_exit (void) { if (use_ole2_dnd) { OleUninitialize (); } CoUninitialize (); } /* Source side */ static void local_send_leave (GdkDragContext *context, guint32 time) { GdkEvent *tmp_event; GDK_NOTE (DND, g_print ("local_send_leave: context=%p current_dest_drag=%p\n", context, current_dest_drag)); if ((current_dest_drag != NULL) && (current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) && (current_dest_drag->source_window == context->source_window)) { tmp_event = gdk_event_new (GDK_DRAG_LEAVE); tmp_event->dnd.window = g_object_ref (context->dest_window); /* Pass ownership of context to the event */ tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (current_dest_drag); tmp_event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */ gdk_event_set_device (tmp_event, gdk_drag_context_get_device (context)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (context))); current_dest_drag = NULL; GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } } static void local_send_enter (GdkDragContext *context, guint32 time) { GdkEvent *tmp_event; GdkDragContext *new_context; GDK_NOTE (DND, g_print ("local_send_enter: context=%p current_dest_drag=%p\n", context, current_dest_drag)); if (current_dest_drag != NULL) { g_object_unref (G_OBJECT (current_dest_drag)); current_dest_drag = NULL; } new_context = gdk_drag_context_new (gdk_window_get_display (context->source_window)); new_context->protocol = GDK_DRAG_PROTO_LOCAL; new_context->is_source = FALSE; new_context->source_window = context->source_window; g_object_ref (new_context->source_window); new_context->dest_window = context->dest_window; g_object_ref (new_context->dest_window); new_context->targets = g_list_copy (context->targets); gdk_window_set_events (new_context->source_window, gdk_window_get_events (new_context->source_window) | GDK_PROPERTY_CHANGE_MASK); new_context->actions = context->actions; tmp_event = gdk_event_new (GDK_DRAG_ENTER); tmp_event->dnd.window = g_object_ref (context->dest_window); tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (new_context); tmp_event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */ gdk_event_set_device (tmp_event, gdk_drag_context_get_device (context)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (context))); current_dest_drag = new_context; GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } static void local_send_motion (GdkDragContext *context, gint x_root, gint y_root, GdkDragAction action, guint32 time) { GdkEvent *tmp_event; GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (context); GDK_NOTE (DND, g_print ("local_send_motion: context=%p (%d,%d) current_dest_drag=%p\n", context, x_root, y_root, current_dest_drag)); if ((current_dest_drag != NULL) && (current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) && (current_dest_drag->source_window == context->source_window)) { GdkWin32DragContext *current_dest_drag_win32; tmp_event = gdk_event_new (GDK_DRAG_MOTION); tmp_event->dnd.window = g_object_ref (current_dest_drag->dest_window); tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (current_dest_drag); tmp_event->dnd.time = time; gdk_event_set_device (tmp_event, gdk_drag_context_get_device (current_dest_drag)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (current_dest_drag))); current_dest_drag->suggested_action = action; tmp_event->dnd.x_root = x_root; tmp_event->dnd.y_root = y_root; current_dest_drag_win32 = GDK_WIN32_DRAG_CONTEXT (current_dest_drag); current_dest_drag_win32->ole2_dnd_last_pt.x = x_root - _gdk_offset_x; current_dest_drag_win32->ole2_dnd_last_pt.y = y_root - _gdk_offset_y; context_win32->drag_status = GDK_DRAG_STATUS_MOTION_WAIT; GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } } static void local_send_drop (GdkDragContext *context, guint32 time) { GdkEvent *tmp_event; GDK_NOTE (DND, g_print ("local_send_drop: context=%p current_dest_drag=%p\n", context, current_dest_drag)); if ((current_dest_drag != NULL) && (current_dest_drag->protocol == GDK_DRAG_PROTO_LOCAL) && (current_dest_drag->source_window == context->source_window)) { GdkWin32DragContext *context_win32; /* Pass ownership of context to the event */ tmp_event = gdk_event_new (GDK_DROP_START); tmp_event->dnd.window = g_object_ref (current_dest_drag->dest_window); tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (current_dest_drag); tmp_event->dnd.time = GDK_CURRENT_TIME; gdk_event_set_device (tmp_event, gdk_drag_context_get_device (current_dest_drag)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (current_dest_drag))); context_win32 = GDK_WIN32_DRAG_CONTEXT (current_dest_drag); tmp_event->dnd.x_root = context_win32->ole2_dnd_last_pt.x + _gdk_offset_x; tmp_event->dnd.y_root = context_win32->ole2_dnd_last_pt.y + _gdk_offset_y; current_dest_drag = NULL; GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } } static void gdk_drag_do_leave (GdkDragContext *context, guint32 time) { if (context->dest_window) { GDK_NOTE (DND, g_print ("gdk_drag_do_leave\n")); if (!use_ole2_dnd) { if (context->protocol == GDK_DRAG_PROTO_LOCAL) local_send_leave (context, time); } g_object_unref (context->dest_window); context->dest_window = NULL; } } GdkDragContext * _gdk_win32_window_drag_begin (GdkWindow *window, GdkDevice *device, GList *targets, gint x_root, gint y_root) { if (!use_ole2_dnd) { GdkDragContext *new_context; g_return_val_if_fail (window != NULL, NULL); new_context = gdk_drag_context_new (gdk_window_get_display (window)); new_context->is_source = TRUE; new_context->source_window = window; g_object_ref (window); new_context->targets = g_list_copy (targets); new_context->actions = 0; return new_context; } else { source_drag_context *ctx; g_return_val_if_fail (window != NULL, NULL); GDK_NOTE (DND, g_print ("gdk_drag_begin\n")); ctx = source_context_new (window, targets); _dnd_source_state = GDK_WIN32_DND_PENDING; pending_src_context = ctx; g_object_ref (ctx->context); return ctx->context; } } void _gdk_win32_dnd_do_dragdrop (void) { if (use_ole2_dnd) { GdkDragContext* drag_ctx; GdkWin32DragContext *drag_ctx_win32; BYTE kbd_state[256]; data_object *dobj; HRESULT hr; DWORD dwEffect; #if 0 HGLOBAL global; STGMEDIUM medium; #endif if (pending_src_context == NULL) return; drag_ctx = pending_src_context->context; drag_ctx_win32 = GDK_WIN32_DRAG_CONTEXT (drag_ctx); dobj = data_object_new (drag_ctx); API_CALL (GetCursorPos, (&drag_ctx_win32->ole2_dnd_last_pt)); API_CALL (ScreenToClient, (GDK_WINDOW_HWND (drag_ctx->source_window), &drag_ctx_win32->ole2_dnd_last_pt)); drag_ctx_win32->ole2_dnd_last_key_state = 0; API_CALL (GetKeyboardState, (kbd_state)); if (kbd_state[VK_CONTROL]) drag_ctx_win32->ole2_dnd_last_key_state |= MK_CONTROL; if (kbd_state[VK_SHIFT]) drag_ctx_win32->ole2_dnd_last_key_state |= MK_SHIFT; if (kbd_state[VK_LBUTTON]) drag_ctx_win32->ole2_dnd_last_key_state |= MK_LBUTTON; if (kbd_state[VK_MBUTTON]) drag_ctx_win32->ole2_dnd_last_key_state |= MK_MBUTTON; if (kbd_state[VK_RBUTTON]) drag_ctx_win32->ole2_dnd_last_key_state |= MK_RBUTTON; #if 0 global = GlobalAlloc (GMEM_FIXED, sizeof (ctx)); memcpy (&global, ctx, sizeof (ctx)); medium.tymed = TYMED_HGLOBAL; medium.hGlobal = global; medium.pUnkForRelease = NULL; /* FIXME I wish I remember what I was thinking of here, i.e. what * the formats[1] signifies, i.e. the CF_GDIOBJFIRST FORMATETC? */ dobj->ido.lpVtbl->SetData (&dobj->ido, &formats[1], &medium, TRUE); #endif /* Start dragging with mainloop inside the OLE2 API. Exits only when done */ GDK_NOTE (DND, g_print ("Calling DoDragDrop\n")); _gdk_win32_begin_modal_call (); hr = DoDragDrop (&dobj->ido, &pending_src_context->ids, DROPEFFECT_COPY | DROPEFFECT_MOVE, &dwEffect); _gdk_win32_end_modal_call (); GDK_NOTE (DND, g_print ("DoDragDrop returned %s\n", (hr == DRAGDROP_S_DROP ? "DRAGDROP_S_DROP" : (hr == DRAGDROP_S_CANCEL ? "DRAGDROP_S_CANCEL" : (hr == E_UNEXPECTED ? "E_UNEXPECTED" : g_strdup_printf ("%#.8lx", hr)))))); /* Delete dnd selection after successful move */ if (hr == DRAGDROP_S_DROP && dwEffect == DROPEFFECT_MOVE) { GdkEvent tmp_event; tmp_event.type = GDK_SELECTION_REQUEST; tmp_event.selection.window = drag_ctx->source_window; tmp_event.selection.send_event = FALSE; tmp_event.selection.selection = _gdk_ole2_dnd; tmp_event.selection.target = _delete; tmp_event.selection.property = _gdk_ole2_dnd; /* ??? */ tmp_event.selection.time = GDK_CURRENT_TIME; /* ??? */ g_object_ref (tmp_event.selection.window); GDK_NOTE (EVENTS, _gdk_win32_print_event (&tmp_event)); gdk_event_put (&tmp_event); } #if 0 // Send a GDK_DROP_FINISHED to the source window GetCursorPos (&pt); ptl.x = pt.x; ptl.y = pt.y; if ( pending_src_context != NULL && pending_src_context->context != NULL && pending_src_context->context->source_window != NULL ) push_dnd_event (GDK_DROP_FINISHED, pending_src_context->context, ptl, FALSE); #endif dobj->ido.lpVtbl->Release (&dobj->ido); if (pending_src_context != NULL) { pending_src_context->ids.lpVtbl->Release (&pending_src_context->ids); pending_src_context = NULL; } } } /* Untested, may not work ... * ... but as of this writing is only used by exlusive X11 gtksocket.c */ GdkDragProtocol _gdk_win32_window_get_drag_protocol (GdkWindow *window, GdkWindow **target) { GdkDragProtocol protocol = GDK_DRAG_PROTO_NONE; if (gdk_window_get_window_type (window) != GDK_WINDOW_FOREIGN) { if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL) { if (use_ole2_dnd) protocol = GDK_DRAG_PROTO_OLE2; else protocol = GDK_DRAG_PROTO_LOCAL; } } if (target) { *target = NULL; } return protocol; } typedef struct { gint x; gint y; HWND ignore; HWND result; } find_window_enum_arg; static BOOL CALLBACK find_window_enum_proc (HWND hwnd, LPARAM lparam) { RECT rect; POINT tl, br; find_window_enum_arg *a = (find_window_enum_arg *) lparam; if (hwnd == a->ignore) return TRUE; if (!IsWindowVisible (hwnd)) return TRUE; tl.x = tl.y = 0; ClientToScreen (hwnd, &tl); GetClientRect (hwnd, &rect); br.x = rect.right; br.y = rect.bottom; ClientToScreen (hwnd, &br); if (a->x >= tl.x && a->y >= tl.y && a->x < br.x && a->y < br.y) { a->result = hwnd; return FALSE; } else return TRUE; } static GdkWindow * gdk_win32_drag_context_find_window (GdkDragContext *context, GdkWindow *drag_window, GdkScreen *screen, gint x_root, gint y_root, GdkDragProtocol *protocol) { GdkWindow *dest_window, *dw; find_window_enum_arg a; a.x = x_root - _gdk_offset_x; a.y = y_root - _gdk_offset_y; a.ignore = drag_window ? GDK_WINDOW_HWND (drag_window) : NULL; a.result = NULL; EnumWindows (find_window_enum_proc, (LPARAM) &a); if (a.result == NULL) dest_window = NULL; else { dw = gdk_win32_handle_table_lookup (a.result); if (dw) { dest_window = gdk_window_get_toplevel (dw); g_object_ref (dest_window); } else dest_window = gdk_win32_window_foreign_new_for_display (gdk_screen_get_display (screen), a.result); if (use_ole2_dnd) *protocol = GDK_DRAG_PROTO_OLE2; else if (context->source_window) *protocol = GDK_DRAG_PROTO_LOCAL; else *protocol = GDK_DRAG_PROTO_WIN32_DROPFILES; } GDK_NOTE (DND, g_print ("gdk_drag_find_window: %p %+d%+d: %p: %p %s\n", (drag_window ? GDK_WINDOW_HWND (drag_window) : NULL), x_root, y_root, a.result, (dest_window ? GDK_WINDOW_HWND (dest_window) : NULL), _gdk_win32_drag_protocol_to_string (*protocol))); return dest_window; } static gboolean gdk_win32_drag_context_drag_motion (GdkDragContext *context, GdkWindow *dest_window, GdkDragProtocol protocol, gint x_root, gint y_root, GdkDragAction suggested_action, GdkDragAction possible_actions, guint32 time) { GdkWin32DragContext *context_win32; g_return_val_if_fail (context != NULL, FALSE); context->actions = possible_actions; GDK_NOTE (DND, g_print ("gdk_drag_motion: %s suggested=%s, possible=%s\n" " context=%p:{actions=%s,suggested=%s,action=%s}\n", _gdk_win32_drag_protocol_to_string (protocol), _gdk_win32_drag_action_to_string (suggested_action), _gdk_win32_drag_action_to_string (possible_actions), context, _gdk_win32_drag_action_to_string (context->actions), _gdk_win32_drag_action_to_string (context->suggested_action), _gdk_win32_drag_action_to_string (context->action))); context_win32 = GDK_WIN32_DRAG_CONTEXT (context); if (!use_ole2_dnd) { if (context->dest_window == dest_window) { GdkDragContext *dest_context; dest_context = gdk_drag_context_find (FALSE, context->source_window, dest_window); if (dest_context) dest_context->actions = context->actions; context->suggested_action = suggested_action; } else { GdkEvent *tmp_event; /* Send a leave to the last destination */ gdk_drag_do_leave (context, time); context_win32->drag_status = GDK_DRAG_STATUS_DRAG; /* Check if new destination accepts drags, and which protocol */ if (dest_window) { context->dest_window = dest_window; g_object_ref (context->dest_window); context->protocol = protocol; switch (protocol) { case GDK_DRAG_PROTO_LOCAL: local_send_enter (context, time); break; default: break; } context->suggested_action = suggested_action; } else { context->dest_window = NULL; context->action = 0; } /* Push a status event, to let the client know that * the drag changed */ tmp_event = gdk_event_new (GDK_DRAG_STATUS); tmp_event->dnd.window = g_object_ref (context->source_window); /* We use this to signal a synthetic status. Perhaps * we should use an extra field... */ tmp_event->dnd.send_event = TRUE; tmp_event->dnd.context = g_object_ref (context); tmp_event->dnd.time = time; gdk_event_set_device (tmp_event, gdk_drag_context_get_device (context)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (context))); GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } /* Send a drag-motion event */ context_win32->ole2_dnd_last_pt.x = x_root - _gdk_offset_x; context_win32->ole2_dnd_last_pt.y = y_root - _gdk_offset_y; if (context->dest_window) { if (context_win32->drag_status == GDK_DRAG_STATUS_DRAG) { switch (context->protocol) { case GDK_DRAG_PROTO_LOCAL: local_send_motion (context, x_root, y_root, suggested_action, time); break; case GDK_DRAG_PROTO_NONE: g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_motion()"); break; default: break; } } else { GDK_NOTE (DND, g_print (" returning TRUE\n" " context=%p:{actions=%s,suggested=%s,action=%s}\n", context, _gdk_win32_drag_action_to_string (context->actions), _gdk_win32_drag_action_to_string (context->suggested_action), _gdk_win32_drag_action_to_string (context->action))); return TRUE; } } } GDK_NOTE (DND, g_print (" returning FALSE\n" " context=%p:{actions=%s,suggested=%s,action=%s}\n", context, _gdk_win32_drag_action_to_string (context->actions), _gdk_win32_drag_action_to_string (context->suggested_action), _gdk_win32_drag_action_to_string (context->action))); return FALSE; } static void gdk_win32_drag_context_drag_drop (GdkDragContext *context, guint32 time) { g_return_if_fail (context != NULL); GDK_NOTE (DND, g_print ("gdk_drag_drop\n")); if (!use_ole2_dnd) { if (context->dest_window && context->protocol == GDK_DRAG_PROTO_LOCAL) local_send_drop (context, time); } else { _dnd_source_state = GDK_WIN32_DND_DROPPED; } } static void gdk_win32_drag_context_drag_abort (GdkDragContext *context, guint32 time) { g_return_if_fail (context != NULL); GDK_NOTE (DND, g_print ("gdk_drag_abort\n")); if (use_ole2_dnd) _dnd_source_state = GDK_WIN32_DND_NONE; } /* Destination side */ static void gdk_win32_drag_context_drag_status (GdkDragContext *context, GdkDragAction action, guint32 time) { GdkDragContext *src_context; GdkEvent *tmp_event; g_return_if_fail (context != NULL); GDK_NOTE (DND, g_print ("gdk_drag_status: %s\n" " context=%p:{actions=%s,suggested=%s,action=%s}\n", _gdk_win32_drag_action_to_string (action), context, _gdk_win32_drag_action_to_string (context->actions), _gdk_win32_drag_action_to_string (context->suggested_action), _gdk_win32_drag_action_to_string (context->action))); context->action = action; if (!use_ole2_dnd) { src_context = gdk_drag_context_find (TRUE, context->source_window, context->dest_window); if (src_context) { GdkWin32DragContext *src_context_win32 = GDK_WIN32_DRAG_CONTEXT (src_context); if (src_context_win32->drag_status == GDK_DRAG_STATUS_MOTION_WAIT) src_context_win32->drag_status = GDK_DRAG_STATUS_DRAG; tmp_event = gdk_event_new (GDK_DRAG_STATUS); tmp_event->dnd.window = g_object_ref (context->source_window); tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (src_context); tmp_event->dnd.time = GDK_CURRENT_TIME; /* FIXME? */ gdk_event_set_device (tmp_event, gdk_drag_context_get_device (src_context)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (src_context))); if (action == GDK_ACTION_DEFAULT) action = 0; src_context->action = action; GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } } } static void gdk_win32_drag_context_drop_reply (GdkDragContext *context, gboolean ok, guint32 time) { g_return_if_fail (context != NULL); GDK_NOTE (DND, g_print ("gdk_drop_reply\n")); if (!use_ole2_dnd) if (context->dest_window) { if (context->protocol == GDK_DRAG_PROTO_WIN32_DROPFILES) _gdk_dropfiles_store (NULL); } } static void gdk_win32_drag_context_drop_finish (GdkDragContext *context, gboolean success, guint32 time) { GdkDragContext *src_context; GdkEvent *tmp_event; g_return_if_fail (context != NULL); GDK_NOTE (DND, g_print ("gdk_drop_finish\n")); if (!use_ole2_dnd) { src_context = gdk_drag_context_find (TRUE, context->source_window, context->dest_window); if (src_context) { tmp_event = gdk_event_new (GDK_DROP_FINISHED); tmp_event->dnd.window = g_object_ref (src_context->source_window); tmp_event->dnd.send_event = FALSE; tmp_event->dnd.context = g_object_ref (src_context); gdk_event_set_device (tmp_event, gdk_drag_context_get_device (src_context)); gdk_event_set_seat (tmp_event, gdk_device_get_seat (gdk_drag_context_get_device (src_context))); GDK_NOTE (EVENTS, _gdk_win32_print_event (tmp_event)); gdk_event_put (tmp_event); gdk_event_free (tmp_event); } } else { gdk_drag_do_leave (context, time); if (success) _dnd_target_state = GDK_WIN32_DND_DROPPED; else _dnd_target_state = GDK_WIN32_DND_FAILED; } } #if 0 static GdkFilterReturn gdk_destroy_filter (GdkXEvent *xev, GdkEvent *event, gpointer data) { MSG *msg = (MSG *) xev; if (msg->message == WM_DESTROY) { IDropTarget *idtp = (IDropTarget *) data; GDK_NOTE (DND, g_print ("gdk_destroy_filter: WM_DESTROY: %p\n", msg->hwnd)); #if 0 idtp->lpVtbl->Release (idtp); #endif RevokeDragDrop (msg->hwnd); CoLockObjectExternal ((IUnknown*) idtp, FALSE, TRUE); } return GDK_FILTER_CONTINUE; } #endif void _gdk_win32_window_register_dnd (GdkWindow *window) { target_drag_context *ctx; HRESULT hr; g_return_if_fail (window != NULL); if (gdk_window_get_window_type (window) == GDK_WINDOW_OFFSCREEN) return; if (g_object_get_data (G_OBJECT (window), "gdk-dnd-registered") != NULL) return; else g_object_set_data (G_OBJECT (window), "gdk-dnd-registered", GINT_TO_POINTER (TRUE)); GDK_NOTE (DND, g_print ("gdk_window_register_dnd: %p\n", GDK_WINDOW_HWND (window))); if (!use_ole2_dnd) { /* We always claim to accept dropped files, but in fact we might not, * of course. This function is called in such a way that it cannot know * whether the window (widget) in question actually accepts files * (in gtk, data of type text/uri-list) or not. */ gdk_window_add_filter (window, gdk_dropfiles_filter, NULL); DragAcceptFiles (GDK_WINDOW_HWND (window), TRUE); } else { /* Return if window is already setup for DND. */ if (g_hash_table_lookup (target_ctx_for_window, GDK_WINDOW_HWND (window)) != NULL) return; /* Register for OLE2 d&d : similarly, claim to accept all supported * data types because we cannot know from here what the window * actually accepts. */ /* FIXME: This of course won't work with user-extensible data types! */ ctx = target_context_new (window); hr = CoLockObjectExternal ((IUnknown *) &ctx->idt, TRUE, FALSE); if (!SUCCEEDED (hr)) OTHER_API_FAILED ("CoLockObjectExternal"); else { hr = RegisterDragDrop (GDK_WINDOW_HWND (window), &ctx->idt); if (hr == DRAGDROP_E_ALREADYREGISTERED) { g_print ("DRAGDROP_E_ALREADYREGISTERED\n"); CoLockObjectExternal ((IUnknown *) &ctx->idt, FALSE, FALSE); } else if (!SUCCEEDED (hr)) OTHER_API_FAILED ("RegisterDragDrop"); else { g_object_ref (window); g_hash_table_insert (target_ctx_for_window, GDK_WINDOW_HWND (window), ctx); } } } } static gboolean gdk_win32_drag_context_drop_status (GdkDragContext *context) { GdkWin32DragContext *context_win32 = GDK_WIN32_DRAG_CONTEXT (context); return ! context_win32->drop_failed; } static GdkAtom gdk_win32_drag_context_get_selection (GdkDragContext *context) { switch (context->protocol) { case GDK_DRAG_PROTO_LOCAL: return _local_dnd; case GDK_DRAG_PROTO_WIN32_DROPFILES: return _gdk_win32_dropfiles; case GDK_DRAG_PROTO_OLE2: return _gdk_ole2_dnd; default: return GDK_NONE; } } static void gdk_win32_drag_context_class_init (GdkWin32DragContextClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass); object_class->finalize = gdk_win32_drag_context_finalize; context_class->find_window = gdk_win32_drag_context_find_window; context_class->drag_status = gdk_win32_drag_context_drag_status; context_class->drag_motion = gdk_win32_drag_context_drag_motion; context_class->drag_abort = gdk_win32_drag_context_drag_abort; context_class->drag_drop = gdk_win32_drag_context_drag_drop; context_class->drop_reply = gdk_win32_drag_context_drop_reply; context_class->drop_finish = gdk_win32_drag_context_drop_finish; context_class->drop_status = gdk_win32_drag_context_drop_status; context_class->get_selection = gdk_win32_drag_context_get_selection; }