fe41e69eea
When a drag and drop occurs from an X11 client to a Wayland native client, mutter uses an internal X11 window as a peer for the DnD drop site. That internal X11 window is moved and resized to match the Wayland native windows as the drag destination moves. When moving from one Wayland native window to another Wayland native window, the same X11 window is used, and as a result no DND enter/leave events is emitted. In that case, the drop may occur on the wrong Wayland native window, because no new XdndEnter/XdndLeave event were emitted. To avoid that issue, use a pair of X11 windows instead of just one and alternate between the two when repicking a new drop surface, so that moving from a Wayland surface to another will always generate the expected enter/leave events that we rely on. Closes: https://gitlab.gnome.org/GNOME/mutter/-/issues/2136 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2305>
1071 lines
34 KiB
C
1071 lines
34 KiB
C
/*
|
|
* Copyright © 2012 Intel Corporation
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and
|
|
* its documentation for any purpose is hereby granted without fee, provided
|
|
* that the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of the copyright holders not be used in
|
|
* advertising or publicity pertaining to distribution of the software
|
|
* without specific, written prior permission. The copyright holders make
|
|
* no representations about the suitability of this software for any
|
|
* purpose. It is provided "as is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
|
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
/* The file is loosely based on xwayland/selection.c from Weston */
|
|
|
|
#include "config.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <glib-unix.h>
|
|
#include <gio/gunixoutputstream.h>
|
|
#include <gio/gunixinputstream.h>
|
|
#include <gdk/gdkx.h>
|
|
#include <X11/Xatom.h>
|
|
#include <X11/extensions/Xfixes.h>
|
|
|
|
#include "core/meta-workspace-manager-private.h"
|
|
#include "meta/meta-x11-errors.h"
|
|
#include "wayland/meta-wayland-data-device.h"
|
|
#include "wayland/meta-xwayland-private.h"
|
|
#include "wayland/meta-xwayland-dnd-private.h"
|
|
#include "wayland/meta-xwayland.h"
|
|
#include "x11/meta-x11-display-private.h"
|
|
|
|
#define INCR_CHUNK_SIZE (128 * 1024)
|
|
#define XDND_VERSION 5
|
|
|
|
struct _MetaWaylandDataSourceXWayland
|
|
{
|
|
MetaWaylandDataSource parent;
|
|
MetaXWaylandDnd *dnd;
|
|
gboolean has_utf8_string_atom;
|
|
};
|
|
|
|
struct _MetaXWaylandDnd
|
|
{
|
|
Window owner;
|
|
Time client_message_timestamp;
|
|
MetaWaylandDataSource *source; /* owned by MetaWaylandDataDevice */
|
|
MetaWaylandSurface *focus_surface;
|
|
Window dnd_window[2]; /* Mutter-internal windows, act as peer on wayland drop sites */
|
|
Window dnd_dest; /* X11 drag dest window */
|
|
guint32 last_motion_time;
|
|
int current_dnd_window;
|
|
};
|
|
|
|
enum
|
|
{
|
|
ATOM_DND_SELECTION,
|
|
ATOM_DND_AWARE,
|
|
ATOM_DND_STATUS,
|
|
ATOM_DND_POSITION,
|
|
ATOM_DND_ENTER,
|
|
ATOM_DND_LEAVE,
|
|
ATOM_DND_DROP,
|
|
ATOM_DND_FINISHED,
|
|
ATOM_DND_PROXY,
|
|
ATOM_DND_TYPE_LIST,
|
|
ATOM_DND_ACTION_MOVE,
|
|
ATOM_DND_ACTION_COPY,
|
|
ATOM_DND_ACTION_ASK,
|
|
ATOM_DND_ACTION_PRIVATE,
|
|
N_DND_ATOMS
|
|
};
|
|
|
|
/* Matches order in enum above */
|
|
const gchar *atom_names[] = {
|
|
"XdndSelection",
|
|
"XdndAware",
|
|
"XdndStatus",
|
|
"XdndPosition",
|
|
"XdndEnter",
|
|
"XdndLeave",
|
|
"XdndDrop",
|
|
"XdndFinished",
|
|
"XdndProxy",
|
|
"XdndTypeList",
|
|
"XdndActionMove",
|
|
"XdndActionCopy",
|
|
"XdndActionAsk",
|
|
"XdndActionPrivate",
|
|
NULL
|
|
};
|
|
|
|
Atom xdnd_atoms[N_DND_ATOMS];
|
|
|
|
G_DEFINE_TYPE (MetaWaylandDataSourceXWayland, meta_wayland_data_source_xwayland,
|
|
META_TYPE_WAYLAND_DATA_SOURCE);
|
|
|
|
/* XDND helpers */
|
|
static Atom
|
|
action_to_atom (uint32_t action)
|
|
{
|
|
if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
|
|
return xdnd_atoms[ATOM_DND_ACTION_COPY];
|
|
else if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
|
|
return xdnd_atoms[ATOM_DND_ACTION_MOVE];
|
|
else if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
|
|
return xdnd_atoms[ATOM_DND_ACTION_ASK];
|
|
else
|
|
return None;
|
|
}
|
|
|
|
static enum wl_data_device_manager_dnd_action
|
|
atom_to_action (Atom atom)
|
|
{
|
|
if (atom == xdnd_atoms[ATOM_DND_ACTION_COPY] ||
|
|
atom == xdnd_atoms[ATOM_DND_ACTION_PRIVATE])
|
|
return WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
|
|
else if (atom == xdnd_atoms[ATOM_DND_ACTION_MOVE])
|
|
return WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
|
|
else if (atom == xdnd_atoms[ATOM_DND_ACTION_ASK])
|
|
return WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
|
|
else
|
|
return WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
|
|
}
|
|
|
|
static Window
|
|
current_dnd_window (MetaXWaylandDnd *dnd)
|
|
{
|
|
return dnd->dnd_window[dnd->current_dnd_window];
|
|
}
|
|
|
|
static Window
|
|
next_dnd_window (MetaXWaylandDnd *dnd)
|
|
{
|
|
dnd->current_dnd_window =
|
|
(dnd->current_dnd_window + 1) % G_N_ELEMENTS (dnd->dnd_window);
|
|
|
|
return current_dnd_window (dnd);
|
|
}
|
|
|
|
static void
|
|
create_dnd_windows (MetaXWaylandDnd *dnd,
|
|
MetaX11Display *x11_display)
|
|
{
|
|
Display *xdisplay = meta_x11_display_get_xdisplay (x11_display);
|
|
XSetWindowAttributes attributes;
|
|
guint32 version = XDND_VERSION;
|
|
int i;
|
|
|
|
attributes.event_mask = PropertyChangeMask | SubstructureNotifyMask;
|
|
attributes.override_redirect = True;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (dnd->dnd_window); i++)
|
|
{
|
|
dnd->dnd_window[i] =
|
|
XCreateWindow (xdisplay,
|
|
meta_x11_display_get_xroot (x11_display),
|
|
-1, -1, 1, 1,
|
|
0, /* border width */
|
|
0, /* depth */
|
|
InputOnly, /* class */
|
|
CopyFromParent, /* visual */
|
|
CWEventMask | CWOverrideRedirect,
|
|
&attributes);
|
|
|
|
XChangeProperty (xdisplay, dnd->dnd_window[i],
|
|
xdnd_atoms[ATOM_DND_AWARE],
|
|
XA_ATOM, 32, PropModeReplace,
|
|
(guchar*) &version, 1);
|
|
}
|
|
}
|
|
|
|
static void
|
|
destroy_dnd_windows (MetaXWaylandDnd *dnd,
|
|
MetaX11Display *x11_display)
|
|
{
|
|
Display *xdisplay = meta_x11_display_get_xdisplay (x11_display);
|
|
int i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (dnd->dnd_window); i++)
|
|
{
|
|
XDestroyWindow (xdisplay, dnd->dnd_window[i]);
|
|
dnd->dnd_window[i] = None;
|
|
}
|
|
}
|
|
|
|
static void
|
|
hide_dnd_window (MetaXWaylandDnd *dnd,
|
|
MetaX11Display *x11_display,
|
|
int index)
|
|
{
|
|
Display *xdisplay = meta_x11_display_get_xdisplay (x11_display);
|
|
|
|
g_assert (index < G_N_ELEMENTS (dnd->dnd_window));
|
|
|
|
XMoveResizeWindow (xdisplay, dnd->dnd_window[index], -1, -1, 1, 1);
|
|
XUnmapWindow (xdisplay, dnd->dnd_window[index]);
|
|
}
|
|
|
|
static void
|
|
hide_all_dnd_windows (MetaXWaylandDnd *dnd,
|
|
MetaX11Display *x11_display)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (dnd->dnd_window); i++)
|
|
hide_dnd_window (dnd, x11_display, i);
|
|
}
|
|
|
|
static void
|
|
xdnd_send_enter (MetaXWaylandDnd *dnd,
|
|
Window dest)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = x11_display->xdisplay;
|
|
MetaWaylandDataSource *data_source;
|
|
XEvent xev = { 0 };
|
|
gchar **p;
|
|
struct wl_array *source_mime_types;
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
|
|
data_source = compositor->seat->data_device.dnd_data_source;
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_ENTER];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
|
|
xev.xclient.data.l[0] = x11_display->selection.xwindow;
|
|
xev.xclient.data.l[1] = XDND_VERSION << 24; /* version */
|
|
xev.xclient.data.l[2] = xev.xclient.data.l[3] = xev.xclient.data.l[4] = 0;
|
|
|
|
source_mime_types = meta_wayland_data_source_get_mime_types (data_source);
|
|
if (source_mime_types->size <= 3)
|
|
{
|
|
/* The mimetype atoms fit in this same message */
|
|
gint i = 2;
|
|
|
|
wl_array_for_each (p, source_mime_types)
|
|
{
|
|
xev.xclient.data.l[i++] = gdk_x11_get_xatom_by_name (*p);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* We have more than 3 mimetypes, we must set up
|
|
* the mimetype list as a XdndTypeList property.
|
|
*/
|
|
g_autofree Atom *atomlist = NULL;
|
|
gint i = 0;
|
|
|
|
xev.xclient.data.l[1] |= 1;
|
|
atomlist = g_new0 (Atom, source_mime_types->size);
|
|
|
|
wl_array_for_each (p, source_mime_types)
|
|
{
|
|
atomlist[i++] = gdk_x11_get_xatom_by_name (*p);
|
|
}
|
|
|
|
XChangeProperty (xdisplay, x11_display->selection.xwindow,
|
|
xdnd_atoms[ATOM_DND_TYPE_LIST],
|
|
XA_ATOM, 32, PropModeReplace,
|
|
(guchar *) atomlist, i);
|
|
}
|
|
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
|
|
if (meta_x11_error_trap_pop_with_return (x11_display) != Success)
|
|
g_critical ("Error sending XdndEnter");
|
|
}
|
|
|
|
static void
|
|
xdnd_send_leave (MetaXWaylandDnd *dnd,
|
|
Window dest)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = x11_display->xdisplay;
|
|
XEvent xev = { 0 };
|
|
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_LEAVE];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
xev.xclient.data.l[0] = x11_display->selection.xwindow;
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
meta_x11_error_trap_pop (x11_display);
|
|
}
|
|
|
|
static void
|
|
xdnd_send_position (MetaXWaylandDnd *dnd,
|
|
Window dest,
|
|
uint32_t time,
|
|
int x,
|
|
int y)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaWaylandDataSource *source = compositor->seat->data_device.dnd_data_source;
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = x11_display->xdisplay;
|
|
uint32_t action = 0, user_action, actions;
|
|
XEvent xev = { 0 };
|
|
|
|
user_action = meta_wayland_data_source_get_user_action (source);
|
|
meta_wayland_data_source_get_actions (source, &actions);
|
|
|
|
if (user_action & actions)
|
|
action = user_action;
|
|
if (!action)
|
|
action = actions;
|
|
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_POSITION];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
|
|
xev.xclient.data.l[0] = x11_display->selection.xwindow;
|
|
xev.xclient.data.l[1] = 0;
|
|
xev.xclient.data.l[2] = (x << 16) | y;
|
|
xev.xclient.data.l[3] = time;
|
|
xev.xclient.data.l[4] = action_to_atom (action);
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
|
|
if (meta_x11_error_trap_pop_with_return (x11_display) != Success)
|
|
g_critical ("Error sending XdndPosition");
|
|
}
|
|
|
|
static void
|
|
xdnd_send_drop (MetaXWaylandDnd *dnd,
|
|
Window dest,
|
|
uint32_t time)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = x11_display->xdisplay;
|
|
XEvent xev = { 0 };
|
|
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_DROP];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
|
|
xev.xclient.data.l[0] = x11_display->selection.xwindow;
|
|
xev.xclient.data.l[2] = time;
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
|
|
if (meta_x11_error_trap_pop_with_return (x11_display) != Success)
|
|
g_critical ("Error sending XdndDrop");
|
|
}
|
|
|
|
static void
|
|
xdnd_send_finished (MetaXWaylandDnd *dnd,
|
|
Window dest,
|
|
gboolean accepted)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = x11_display->xdisplay;
|
|
MetaWaylandDataSource *source = dnd->source;
|
|
uint32_t action = 0;
|
|
XEvent xev = { 0 };
|
|
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_FINISHED];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
|
|
xev.xclient.data.l[0] = current_dnd_window (dnd);
|
|
|
|
if (accepted)
|
|
{
|
|
action = meta_wayland_data_source_get_current_action (source);
|
|
xev.xclient.data.l[1] = 1; /* Drop successful */
|
|
xev.xclient.data.l[2] = action_to_atom (action);
|
|
}
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
|
|
if (meta_x11_error_trap_pop_with_return (x11_display) != Success)
|
|
g_critical ("Error sending XdndFinished");
|
|
}
|
|
|
|
static void
|
|
xdnd_send_status (MetaXWaylandDnd *dnd,
|
|
Window dest,
|
|
uint32_t action)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
|
|
XEvent xev = { 0 };
|
|
|
|
xev.xclient.type = ClientMessage;
|
|
xev.xclient.message_type = xdnd_atoms[ATOM_DND_STATUS];
|
|
xev.xclient.format = 32;
|
|
xev.xclient.window = dest;
|
|
|
|
xev.xclient.data.l[0] = current_dnd_window (dnd);
|
|
xev.xclient.data.l[1] = 1 << 1; /* Bit 2: dest wants XdndPosition messages */
|
|
xev.xclient.data.l[4] = action_to_atom (action);
|
|
|
|
if (xev.xclient.data.l[4])
|
|
xev.xclient.data.l[1] |= 1 << 0; /* Bit 1: dest accepts the drop */
|
|
|
|
meta_x11_error_trap_push (x11_display);
|
|
XSendEvent (xdisplay, dest, False, NoEventMask, &xev);
|
|
|
|
if (meta_x11_error_trap_pop_with_return (x11_display) != Success)
|
|
g_critical ("Error sending Xdndstatus");
|
|
}
|
|
|
|
static void
|
|
meta_xwayland_end_dnd_grab (MetaWaylandDataDevice *data_device,
|
|
gboolean success)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandManager *manager = &compositor->xwayland_manager;
|
|
MetaWaylandDragGrab *drag_grab = compositor->seat->data_device.current_grab;
|
|
MetaXWaylandDnd *dnd = manager->dnd;
|
|
|
|
if (drag_grab)
|
|
{
|
|
if (!success && dnd->source)
|
|
meta_wayland_data_source_set_current_offer (dnd->source, NULL);
|
|
|
|
meta_wayland_data_device_end_drag (data_device);
|
|
}
|
|
|
|
hide_all_dnd_windows (dnd, x11_display);
|
|
}
|
|
|
|
static void
|
|
transfer_cb (MetaSelection *selection,
|
|
GAsyncResult *res,
|
|
GOutputStream *stream)
|
|
{
|
|
GError *error = NULL;
|
|
|
|
if (!meta_selection_transfer_finish (selection, res, &error))
|
|
{
|
|
g_warning ("Could not transfer DnD selection: %s", error->message);
|
|
g_error_free (error);
|
|
}
|
|
|
|
g_output_stream_close (stream, NULL, NULL);
|
|
g_object_unref (stream);
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_send (MetaWaylandDataSource *source,
|
|
const gchar *mime_type,
|
|
gint fd)
|
|
{
|
|
MetaDisplay *display = meta_get_display ();
|
|
GOutputStream *stream;
|
|
|
|
stream = g_unix_output_stream_new (fd, TRUE);
|
|
meta_selection_transfer_async (meta_display_get_selection (display),
|
|
META_SELECTION_DND,
|
|
mime_type,
|
|
-1,
|
|
stream,
|
|
NULL,
|
|
(GAsyncReadyCallback) transfer_cb,
|
|
stream);
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_target (MetaWaylandDataSource *source,
|
|
const gchar *mime_type)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland =
|
|
META_WAYLAND_DATA_SOURCE_XWAYLAND (source);
|
|
MetaXWaylandDnd *dnd = source_xwayland->dnd;
|
|
uint32_t action = 0;
|
|
|
|
if (mime_type)
|
|
action = meta_wayland_data_source_get_current_action (source);
|
|
|
|
xdnd_send_status (dnd, dnd->owner, action);
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_cancel (MetaWaylandDataSource *source)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland =
|
|
META_WAYLAND_DATA_SOURCE_XWAYLAND (source);
|
|
MetaXWaylandDnd *dnd = source_xwayland->dnd;
|
|
|
|
xdnd_send_finished (dnd, dnd->owner, FALSE);
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_action (MetaWaylandDataSource *source,
|
|
uint32_t action)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland =
|
|
META_WAYLAND_DATA_SOURCE_XWAYLAND (source);
|
|
MetaXWaylandDnd *dnd = source_xwayland->dnd;
|
|
|
|
if (!meta_wayland_data_source_has_target (source))
|
|
action = 0;
|
|
|
|
xdnd_send_status (dnd, dnd->owner, action);
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_drop_performed (MetaWaylandDataSource *source)
|
|
{
|
|
}
|
|
|
|
static void
|
|
meta_x11_source_drag_finished (MetaWaylandDataSource *source)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland =
|
|
META_WAYLAND_DATA_SOURCE_XWAYLAND (source);
|
|
MetaXWaylandDnd *dnd = source_xwayland->dnd;
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
uint32_t action = meta_wayland_data_source_get_current_action (source);
|
|
|
|
if (action == WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
|
|
{
|
|
Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
|
|
|
|
/* Request data deletion on the drag source */
|
|
XConvertSelection (xdisplay,
|
|
xdnd_atoms[ATOM_DND_SELECTION],
|
|
gdk_x11_get_xatom_by_name ("DELETE"),
|
|
gdk_x11_get_xatom_by_name ("_META_SELECTION"),
|
|
x11_display->selection.xwindow,
|
|
META_CURRENT_TIME);
|
|
}
|
|
|
|
xdnd_send_finished (dnd, dnd->owner, TRUE);
|
|
}
|
|
|
|
static void
|
|
meta_wayland_data_source_xwayland_init (MetaWaylandDataSourceXWayland *source_xwayland)
|
|
{
|
|
}
|
|
|
|
static void
|
|
meta_wayland_data_source_xwayland_class_init (MetaWaylandDataSourceXWaylandClass *klass)
|
|
{
|
|
MetaWaylandDataSourceClass *data_source_class =
|
|
META_WAYLAND_DATA_SOURCE_CLASS (klass);
|
|
|
|
data_source_class->send = meta_x11_source_send;
|
|
data_source_class->target = meta_x11_source_target;
|
|
data_source_class->cancel = meta_x11_source_cancel;
|
|
data_source_class->action = meta_x11_source_action;
|
|
data_source_class->drop_performed = meta_x11_source_drop_performed;
|
|
data_source_class->drag_finished = meta_x11_source_drag_finished;
|
|
}
|
|
|
|
static MetaWaylandDataSource *
|
|
meta_wayland_data_source_xwayland_new (MetaXWaylandDnd *dnd)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland;
|
|
|
|
source_xwayland = g_object_new (META_TYPE_WAYLAND_DATA_SOURCE_XWAYLAND, NULL);
|
|
source_xwayland->dnd = dnd;
|
|
|
|
return META_WAYLAND_DATA_SOURCE (source_xwayland);
|
|
}
|
|
|
|
static void
|
|
meta_x11_drag_dest_focus_in (MetaWaylandDataDevice *data_device,
|
|
MetaWaylandSurface *surface,
|
|
MetaWaylandDataOffer *offer)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
|
|
dnd->dnd_dest = meta_wayland_surface_get_window (surface)->xwindow;
|
|
xdnd_send_enter (dnd, dnd->dnd_dest);
|
|
}
|
|
|
|
static void
|
|
meta_x11_drag_dest_focus_out (MetaWaylandDataDevice *data_device,
|
|
MetaWaylandSurface *surface)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
|
|
xdnd_send_leave (dnd, dnd->dnd_dest);
|
|
dnd->dnd_dest = None;
|
|
}
|
|
|
|
static void
|
|
meta_x11_drag_dest_motion (MetaWaylandDataDevice *data_device,
|
|
MetaWaylandSurface *surface,
|
|
const ClutterEvent *event)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
guint32 time;
|
|
gfloat x, y;
|
|
|
|
time = clutter_event_get_time (event);
|
|
clutter_event_get_coords (event, &x, &y);
|
|
xdnd_send_position (dnd, dnd->dnd_dest, time, x, y);
|
|
}
|
|
|
|
static void
|
|
meta_x11_drag_dest_drop (MetaWaylandDataDevice *data_device,
|
|
MetaWaylandSurface *surface)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
|
|
xdnd_send_drop (dnd, dnd->dnd_dest,
|
|
meta_display_get_current_time_roundtrip (meta_get_display ()));
|
|
}
|
|
|
|
static void
|
|
meta_x11_drag_dest_update (MetaWaylandDataDevice *data_device,
|
|
MetaWaylandSurface *surface)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
MetaWaylandSeat *seat = compositor->seat;
|
|
graphene_point_t pos;
|
|
|
|
clutter_seat_query_state (clutter_input_device_get_seat (seat->pointer->device),
|
|
seat->pointer->device, NULL, &pos, NULL);
|
|
xdnd_send_position (dnd, dnd->dnd_dest,
|
|
clutter_get_current_event_time (),
|
|
pos.x, pos.y);
|
|
}
|
|
|
|
static const MetaWaylandDragDestFuncs meta_x11_drag_dest_funcs = {
|
|
meta_x11_drag_dest_focus_in,
|
|
meta_x11_drag_dest_focus_out,
|
|
meta_x11_drag_dest_motion,
|
|
meta_x11_drag_dest_drop,
|
|
meta_x11_drag_dest_update
|
|
};
|
|
|
|
const MetaWaylandDragDestFuncs *
|
|
meta_xwayland_selection_get_drag_dest_funcs (void)
|
|
{
|
|
return &meta_x11_drag_dest_funcs;
|
|
}
|
|
|
|
static gboolean
|
|
meta_xwayland_data_source_fetch_mimetype_list (MetaWaylandDataSource *source,
|
|
Window window,
|
|
Atom prop)
|
|
{
|
|
MetaWaylandDataSourceXWayland *source_xwayland =
|
|
META_WAYLAND_DATA_SOURCE_XWAYLAND (source);
|
|
Display *xdisplay = GDK_DISPLAY_XDISPLAY (gdk_display_get_default ());
|
|
gulong nitems_ret, bytes_after_ret, i;
|
|
Atom *atoms, type_ret, utf8_string;
|
|
int format_ret;
|
|
struct wl_array *source_mime_types;
|
|
|
|
source_mime_types = meta_wayland_data_source_get_mime_types (source);
|
|
if (source_mime_types->size != 0)
|
|
return TRUE;
|
|
|
|
utf8_string = gdk_x11_get_xatom_by_name ("UTF8_STRING");
|
|
XGetWindowProperty (xdisplay, window, prop,
|
|
0, /* offset */
|
|
0x1fffffff, /* length */
|
|
False, /* delete */
|
|
AnyPropertyType,
|
|
&type_ret,
|
|
&format_ret,
|
|
&nitems_ret,
|
|
&bytes_after_ret,
|
|
(guchar **) &atoms);
|
|
|
|
if (nitems_ret == 0 || type_ret != XA_ATOM)
|
|
{
|
|
XFree (atoms);
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < nitems_ret; i++)
|
|
{
|
|
const gchar *mime_type;
|
|
|
|
if (atoms[i] == utf8_string)
|
|
{
|
|
meta_wayland_data_source_add_mime_type (source,
|
|
"text/plain;charset=utf-8");
|
|
source_xwayland->has_utf8_string_atom = TRUE;
|
|
}
|
|
|
|
mime_type = gdk_x11_get_xatom_name (atoms[i]);
|
|
meta_wayland_data_source_add_mime_type (source, mime_type);
|
|
}
|
|
|
|
XFree (atoms);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static MetaWaylandSurface *
|
|
pick_drop_surface (MetaWaylandCompositor *compositor,
|
|
const ClutterEvent *event)
|
|
{
|
|
MetaDisplay *display = meta_get_display ();
|
|
MetaWorkspaceManager *workspace_manager = display->workspace_manager;
|
|
MetaWorkspace *workspace = workspace_manager->active_workspace;
|
|
MetaWindow *focus_window = NULL;
|
|
graphene_point_t pos;
|
|
|
|
clutter_event_get_coords (event, &pos.x, &pos.y);
|
|
focus_window = meta_stack_get_default_focus_window_at_point (display->stack,
|
|
workspace,
|
|
NULL,
|
|
pos.x, pos.y);
|
|
return focus_window ? focus_window->surface : NULL;
|
|
}
|
|
|
|
static void
|
|
repick_drop_surface (MetaWaylandCompositor *compositor,
|
|
MetaWaylandDragGrab *drag_grab,
|
|
const ClutterEvent *event)
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
Display *xdisplay = meta_x11_display_get_xdisplay (x11_display);
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
MetaWaylandSurface *focus = NULL;
|
|
MetaWindow *focus_window;
|
|
|
|
focus = pick_drop_surface (compositor, event);
|
|
if (dnd->focus_surface == focus)
|
|
return;
|
|
|
|
dnd->focus_surface = focus;
|
|
|
|
if (focus)
|
|
focus_window = meta_wayland_surface_get_window (focus);
|
|
else
|
|
focus_window = NULL;
|
|
|
|
if (focus_window &&
|
|
focus_window->client_type == META_WINDOW_CLIENT_TYPE_WAYLAND)
|
|
{
|
|
Window dnd_window;
|
|
|
|
hide_dnd_window (dnd, x11_display, dnd->current_dnd_window);
|
|
dnd_window = next_dnd_window (dnd);
|
|
|
|
XMapRaised (xdisplay, dnd_window);
|
|
XMoveResizeWindow (xdisplay, dnd_window,
|
|
focus_window->rect.x,
|
|
focus_window->rect.y,
|
|
focus_window->rect.width,
|
|
focus_window->rect.height);
|
|
}
|
|
else
|
|
{
|
|
hide_all_dnd_windows (dnd, x11_display);
|
|
}
|
|
}
|
|
|
|
static void
|
|
drag_xgrab_focus (MetaWaylandPointerGrab *grab,
|
|
MetaWaylandSurface *surface)
|
|
{
|
|
/* Do not update the focus here. First, the surface may perfectly
|
|
* be the X11 source DnD icon window's, so we can only be fooled
|
|
* here. Second, delaying focus handling to XdndEnter/Leave
|
|
* makes us do the negotiation orderly on the X11 side.
|
|
*/
|
|
}
|
|
|
|
static void
|
|
drag_xgrab_motion (MetaWaylandPointerGrab *grab,
|
|
const ClutterEvent *event)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
MetaWaylandSeat *seat = compositor->seat;
|
|
|
|
repick_drop_surface (compositor,
|
|
(MetaWaylandDragGrab *) grab,
|
|
event);
|
|
|
|
dnd->last_motion_time = clutter_event_get_time (event);
|
|
meta_wayland_pointer_send_motion (seat->pointer, event);
|
|
}
|
|
|
|
static void
|
|
drag_xgrab_button (MetaWaylandPointerGrab *grab,
|
|
const ClutterEvent *event)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaWaylandSeat *seat = compositor->seat;
|
|
MetaWaylandDataSource *data_source;
|
|
|
|
meta_wayland_pointer_send_button (seat->pointer, event);
|
|
data_source = compositor->seat->data_device.dnd_data_source;
|
|
|
|
if (seat->pointer->button_count == 0 &&
|
|
(!meta_wayland_drag_grab_get_focus ((MetaWaylandDragGrab *) grab) ||
|
|
meta_wayland_data_source_get_current_action (data_source) ==
|
|
WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE))
|
|
meta_xwayland_end_dnd_grab (&seat->data_device, FALSE);
|
|
}
|
|
|
|
static const MetaWaylandPointerGrabInterface drag_xgrab_interface = {
|
|
drag_xgrab_focus,
|
|
drag_xgrab_motion,
|
|
drag_xgrab_button,
|
|
};
|
|
|
|
static gboolean
|
|
meta_xwayland_dnd_handle_client_message (MetaWaylandCompositor *compositor,
|
|
XEvent *xevent)
|
|
{
|
|
XClientMessageEvent *event = (XClientMessageEvent *) xevent;
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
MetaWaylandSeat *seat = compositor->seat;
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
|
|
/* Source side messages */
|
|
if (event->window == x11_display->selection.xwindow)
|
|
{
|
|
MetaWaylandDataSource *data_source;
|
|
uint32_t action = 0;
|
|
|
|
data_source = compositor->seat->data_device.dnd_data_source;
|
|
|
|
if (!data_source)
|
|
return FALSE;
|
|
|
|
if (event->message_type == xdnd_atoms[ATOM_DND_STATUS])
|
|
{
|
|
/* The first bit in data.l[1] is set if the drag was accepted */
|
|
meta_wayland_data_source_set_has_target (data_source,
|
|
(event->data.l[1] & 1) != 0);
|
|
|
|
/* data.l[4] contains the action atom */
|
|
if (event->data.l[4])
|
|
action = atom_to_action ((Atom) event->data.l[4]);
|
|
|
|
meta_wayland_data_source_set_current_action (data_source, action);
|
|
return TRUE;
|
|
}
|
|
else if (event->message_type == xdnd_atoms[ATOM_DND_FINISHED])
|
|
{
|
|
/* Reject messages mid-grab */
|
|
if (compositor->seat->data_device.current_grab)
|
|
return FALSE;
|
|
|
|
meta_wayland_data_source_notify_finish (data_source);
|
|
return TRUE;
|
|
}
|
|
}
|
|
/* Dest side messages */
|
|
else if (dnd->source &&
|
|
compositor->seat->data_device.current_grab &&
|
|
(Window) event->data.l[0] == dnd->owner)
|
|
{
|
|
MetaWaylandDragGrab *drag_grab = compositor->seat->data_device.current_grab;
|
|
MetaWaylandSurface *drag_focus = meta_wayland_drag_grab_get_focus (drag_grab);
|
|
|
|
if (!drag_focus &&
|
|
event->message_type != xdnd_atoms[ATOM_DND_ENTER])
|
|
return FALSE;
|
|
|
|
if (event->message_type == xdnd_atoms[ATOM_DND_ENTER])
|
|
{
|
|
/* Bit 1 in data.l[1] determines whether there's 3 or less mimetype
|
|
* atoms (and are thus contained in this same message), or whether
|
|
* there's more than 3 and we need to check the XdndTypeList property
|
|
* for the full list.
|
|
*/
|
|
if (!(event->data.l[1] & 1))
|
|
{
|
|
/* Mimetypes are contained in this message */
|
|
const gchar *mimetype;
|
|
gint i;
|
|
struct wl_array *source_mime_types;
|
|
|
|
/* We only need to fetch once */
|
|
source_mime_types =
|
|
meta_wayland_data_source_get_mime_types (dnd->source);
|
|
if (source_mime_types->size == 0)
|
|
{
|
|
for (i = 2; i <= 4; i++)
|
|
{
|
|
if (event->data.l[i] == None)
|
|
break;
|
|
|
|
mimetype = gdk_x11_get_xatom_name (event->data.l[i]);
|
|
meta_wayland_data_source_add_mime_type (dnd->source,
|
|
mimetype);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Fetch mimetypes from type list */
|
|
meta_xwayland_data_source_fetch_mimetype_list (dnd->source,
|
|
event->data.l[0],
|
|
xdnd_atoms[ATOM_DND_TYPE_LIST]);
|
|
}
|
|
|
|
meta_wayland_data_source_set_actions (dnd->source,
|
|
WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY |
|
|
WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE |
|
|
WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK);
|
|
meta_wayland_drag_grab_set_focus (drag_grab, dnd->focus_surface);
|
|
return TRUE;
|
|
}
|
|
else if (event->message_type == xdnd_atoms[ATOM_DND_POSITION])
|
|
{
|
|
ClutterEvent *motion;
|
|
graphene_point_t pos;
|
|
uint32_t action = 0;
|
|
|
|
dnd->client_message_timestamp = event->data.l[3];
|
|
|
|
motion = clutter_event_new (CLUTTER_MOTION);
|
|
clutter_seat_query_state (clutter_input_device_get_seat (seat->pointer->device),
|
|
seat->pointer->device, NULL, &pos, NULL);
|
|
clutter_event_set_coords (motion, pos.x, pos.y);
|
|
clutter_event_set_device (motion, seat->pointer->device);
|
|
clutter_event_set_source_device (motion, seat->pointer->device);
|
|
clutter_event_set_time (motion, dnd->last_motion_time);
|
|
|
|
action = atom_to_action ((Atom) event->data.l[4]);
|
|
meta_wayland_data_source_set_user_action (dnd->source, action);
|
|
|
|
meta_wayland_surface_drag_dest_motion (drag_focus, motion);
|
|
xdnd_send_status (dnd, (Window) event->data.l[0],
|
|
meta_wayland_data_source_get_current_action (dnd->source));
|
|
|
|
clutter_event_free (motion);
|
|
return TRUE;
|
|
}
|
|
else if (event->message_type == xdnd_atoms[ATOM_DND_LEAVE])
|
|
{
|
|
meta_wayland_drag_grab_set_focus (drag_grab, NULL);
|
|
return TRUE;
|
|
}
|
|
else if (event->message_type == xdnd_atoms[ATOM_DND_DROP])
|
|
{
|
|
dnd->client_message_timestamp = event->data.l[2];
|
|
meta_wayland_surface_drag_dest_drop (drag_focus);
|
|
meta_xwayland_end_dnd_grab (&seat->data_device, TRUE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_xwayland_dnd_handle_xfixes_selection_notify (MetaWaylandCompositor *compositor,
|
|
XEvent *xevent)
|
|
{
|
|
XFixesSelectionNotifyEvent *event = (XFixesSelectionNotifyEvent *) xevent;
|
|
MetaXWaylandDnd *dnd = compositor->xwayland_manager.dnd;
|
|
MetaWaylandDataDevice *data_device = &compositor->seat->data_device;
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
MetaWaylandSurface *focus;
|
|
|
|
if (event->selection != xdnd_atoms[ATOM_DND_SELECTION])
|
|
return FALSE;
|
|
|
|
dnd->owner = event->owner;
|
|
focus = compositor->seat->pointer->focus_surface;
|
|
|
|
if (event->owner != None && event->owner != x11_display->selection.xwindow &&
|
|
focus && meta_xwayland_is_xwayland_surface (focus))
|
|
{
|
|
dnd->source = meta_wayland_data_source_xwayland_new (dnd);
|
|
meta_wayland_data_device_set_dnd_source (&compositor->seat->data_device,
|
|
dnd->source);
|
|
|
|
meta_wayland_data_device_start_drag (data_device,
|
|
wl_resource_get_client (focus->resource),
|
|
&drag_xgrab_interface,
|
|
focus, dnd->source,
|
|
NULL);
|
|
}
|
|
else if (event->owner == None)
|
|
{
|
|
meta_xwayland_end_dnd_grab (data_device, FALSE);
|
|
g_clear_object (&dnd->source);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
meta_xwayland_dnd_handle_event (XEvent *xevent)
|
|
{
|
|
MetaWaylandCompositor *compositor;
|
|
|
|
compositor = meta_wayland_compositor_get_default ();
|
|
|
|
if (!compositor->xwayland_manager.dnd)
|
|
return FALSE;
|
|
|
|
switch (xevent->type)
|
|
{
|
|
case ClientMessage:
|
|
return meta_xwayland_dnd_handle_client_message (compositor, xevent);
|
|
default:
|
|
{
|
|
MetaX11Display *x11_display = meta_get_display ()->x11_display;
|
|
|
|
if (xevent->type - x11_display->xfixes_event_base == XFixesSelectionNotify)
|
|
return meta_xwayland_dnd_handle_xfixes_selection_notify (compositor, xevent);
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
meta_xwayland_init_dnd (MetaX11Display *x11_display)
|
|
{
|
|
MetaWaylandCompositor *compositor = meta_wayland_compositor_get_default ();
|
|
MetaXWaylandManager *manager = &compositor->xwayland_manager;
|
|
|
|
MetaXWaylandDnd *dnd = manager->dnd;
|
|
|
|
guint32 i;
|
|
|
|
g_assert (manager->dnd == NULL);
|
|
|
|
manager->dnd = dnd = g_new0 (MetaXWaylandDnd, 1);
|
|
|
|
for (i = 0; i < N_DND_ATOMS; i++)
|
|
xdnd_atoms[i] = gdk_x11_get_xatom_by_name (atom_names[i]);
|
|
|
|
create_dnd_windows (dnd, x11_display);
|
|
dnd->current_dnd_window = 0;
|
|
}
|
|
|
|
void
|
|
meta_xwayland_shutdown_dnd (MetaXWaylandManager *manager,
|
|
MetaX11Display *x11_display)
|
|
{
|
|
MetaXWaylandDnd *dnd = manager->dnd;
|
|
|
|
g_assert (dnd != NULL);
|
|
|
|
destroy_dnd_windows (dnd, x11_display);
|
|
|
|
g_free (dnd);
|
|
manager->dnd = NULL;
|
|
}
|