aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--include/wlr/types/wlr_data_device.h100
-rw-r--r--include/wlr/types/wlr_seat.h11
-rw-r--r--include/xwayland/selection.h72
-rw-r--r--include/xwayland/xwm.h64
-rw-r--r--types/wlr_data_device.c343
-rw-r--r--types/wlr_seat.c9
-rw-r--r--xwayland/meson.build5
-rw-r--r--xwayland/selection.c920
-rw-r--r--xwayland/selection/dnd.c340
-rw-r--r--xwayland/selection/incoming.c461
-rw-r--r--xwayland/selection/outgoing.c420
-rw-r--r--xwayland/selection/selection.c319
-rw-r--r--xwayland/xwm.c47
13 files changed, 2021 insertions, 1090 deletions
diff --git a/include/wlr/types/wlr_data_device.h b/include/wlr/types/wlr_data_device.h
index ff4a0f7e..6fb41c29 100644
--- a/include/wlr/types/wlr_data_device.h
+++ b/include/wlr/types/wlr_data_device.h
@@ -30,23 +30,29 @@ struct wlr_data_offer {
struct wl_listener source_destroy;
};
-struct wlr_data_source {
- // source metadata
- struct wl_array mime_types;
- int32_t actions;
-
- // source implementation
+/**
+ * A data source implementation. Only the `send` function is mandatory. Refer to
+ * the matching wl_data_source_* functions documentation to know what they do.
+ */
+struct wlr_data_source_impl {
void (*send)(struct wlr_data_source *source, const char *mime_type,
int32_t fd);
void (*accept)(struct wlr_data_source *source, uint32_t serial,
const char *mime_type);
void (*cancel)(struct wlr_data_source *source);
- // drag'n'drop implementation
void (*dnd_drop)(struct wlr_data_source *source);
void (*dnd_finish)(struct wlr_data_source *source);
void (*dnd_action)(struct wlr_data_source *source,
enum wl_data_device_manager_dnd_action action);
+};
+
+struct wlr_data_source {
+ const struct wlr_data_source_impl *impl;
+
+ // source metadata
+ struct wl_array mime_types;
+ int32_t actions;
// source status
bool accepted;
@@ -104,13 +110,31 @@ struct wlr_drag {
struct wl_listener source_destroy;
struct wl_listener seat_client_destroy;
struct wl_listener icon_destroy;
+
+ struct {
+ struct wl_signal focus;
+ struct wl_signal motion;
+ struct wl_signal drop;
+ struct wl_signal destroy;
+ } events;
+};
+
+struct wlr_drag_motion_event {
+ struct wlr_drag *drag;
+ uint32_t time;
+ double sx, sy;
+};
+
+struct wlr_drag_drop_event {
+ struct wlr_drag *drag;
+ uint32_t time;
};
/**
* Create a wl data device manager global for this display.
*/
struct wlr_data_device_manager *wlr_data_device_manager_create(
- struct wl_display *display);
+ struct wl_display *display);
/**
* Destroys a wlr_data_device_manager and removes its wl_data_device_manager global.
@@ -126,11 +150,67 @@ void wlr_data_device_manager_destroy(struct wlr_data_device_manager *manager);
*/
void wlr_seat_client_send_selection(struct wlr_seat_client *seat_client);
+/**
+ * Sets the current selection for the seat. This removes the previous one if
+ * there was any.
+ */
void wlr_seat_set_selection(struct wlr_seat *seat,
- struct wlr_data_source *source, uint32_t serial);
+ struct wlr_data_source *source, uint32_t serial);
-void wlr_data_source_init(struct wlr_data_source *source);
+/**
+ * Initializes the data source with the provided implementation.
+ */
+void wlr_data_source_init(struct wlr_data_source *source,
+ const struct wlr_data_source_impl *impl);
+/**
+ * Finishes the data source.
+ */
void wlr_data_source_finish(struct wlr_data_source *source);
+/**
+ * Sends the data as the specified MIME type over the passed file descriptor,
+ * then close it.
+ */
+void wlr_data_source_send(struct wlr_data_source *source, const char *mime_type,
+ int32_t fd);
+
+/**
+ * Notifies the data source that a target accepts one of the offered MIME types.
+ * If a target doesn't accept any of the offered types, `mime_type` is NULL.
+ */
+void wlr_data_source_accept(struct wlr_data_source *source, uint32_t serial,
+ const char *mime_type);
+
+/**
+ * Notifies the data source it is no longer valid and should be destroyed. That
+ * potentially destroys immediately the data source.
+ */
+void wlr_data_source_cancel(struct wlr_data_source *source);
+
+/**
+ * Notifies the data source that the drop operation was performed. This does not
+ * indicate acceptance.
+ *
+ * The data source may still be used in the future and should not be destroyed
+ * here.
+ */
+void wlr_data_source_dnd_drop(struct wlr_data_source *source);
+
+/**
+ * Notifies the data source that the drag-and-drop operation concluded. That
+ * potentially destroys immediately the data source.
+ */
+void wlr_data_source_dnd_finish(struct wlr_data_source *source);
+
+/**
+ * Notifies the data source that a target accepts the drag with the specified
+ * action.
+ *
+ * This shouldn't be called after `wlr_data_source_dnd_drop` unless the
+ * drag-and-drop operation ended in an "ask" action.
+ */
+void wlr_data_source_dnd_action(struct wlr_data_source *source,
+ enum wl_data_device_manager_dnd_action action);
+
#endif
diff --git a/include/wlr/types/wlr_seat.h b/include/wlr/types/wlr_seat.h
index 124c1cb8..34105cf0 100644
--- a/include/wlr/types/wlr_seat.h
+++ b/include/wlr/types/wlr_seat.h
@@ -181,19 +181,25 @@ struct wlr_seat {
uint32_t capabilities;
struct timespec last_event;
- struct wlr_data_source *selection_data_source;
+ struct wlr_data_source *selection_source;
uint32_t selection_serial;
struct wlr_primary_selection_source *primary_selection_source;
uint32_t primary_selection_serial;
+ // `drag` goes away before `drag_source`, when the implicit grab ends
+ struct wlr_drag *drag;
+ struct wlr_data_source *drag_source;
+ uint32_t drag_serial;
+
struct wlr_seat_pointer_state pointer_state;
struct wlr_seat_keyboard_state keyboard_state;
struct wlr_seat_touch_state touch_state;
struct wl_listener display_destroy;
- struct wl_listener selection_data_source_destroy;
+ struct wl_listener selection_source_destroy;
struct wl_listener primary_selection_source_destroy;
+ struct wl_listener drag_source_destroy;
struct {
struct wl_signal pointer_grab_begin;
@@ -210,6 +216,7 @@ struct wlr_seat {
struct wl_signal selection;
struct wl_signal primary_selection;
+ struct wl_signal start_drag;
struct wl_signal new_drag_icon;
struct wl_signal destroy;
diff --git a/include/xwayland/selection.h b/include/xwayland/selection.h
new file mode 100644
index 00000000..bb3a894d
--- /dev/null
+++ b/include/xwayland/selection.h
@@ -0,0 +1,72 @@
+#ifndef XWAYLAND_SELECTION_H
+#define XWAYLAND_SELECTION_H
+
+#include <xcb/xfixes.h>
+
+#define INCR_CHUNK_SIZE (64 * 1024)
+
+#define XDND_VERSION 5
+
+struct wlr_xwm_selection;
+
+struct wlr_xwm_selection_transfer {
+ struct wlr_xwm_selection *selection;
+
+ bool incr;
+ bool flush_property_on_delete;
+ bool property_set;
+ struct wl_array source_data;
+ int source_fd;
+ struct wl_event_source *source;
+
+ // when sending to x11
+ xcb_selection_request_event_t request;
+ struct wl_list outgoing_link;
+
+ // when receiving from x11
+ int property_start;
+ xcb_get_property_reply_t *property_reply;
+};
+
+struct wlr_xwm_selection {
+ struct wlr_xwm *xwm;
+ xcb_atom_t atom;
+ xcb_window_t window;
+ xcb_window_t owner;
+ xcb_timestamp_t timestamp;
+
+ struct wlr_xwm_selection_transfer incoming;
+ struct wl_list outgoing;
+};
+
+void xwm_selection_transfer_remove_source(
+ struct wlr_xwm_selection_transfer *transfer);
+void xwm_selection_transfer_close_source_fd(
+ struct wlr_xwm_selection_transfer *transfer);
+void xwm_selection_transfer_destroy_property_reply(
+ struct wlr_xwm_selection_transfer *transfer);
+
+xcb_atom_t xwm_mime_type_to_atom(struct wlr_xwm *xwm, char *mime_type);
+char *xwm_mime_type_from_atom(struct wlr_xwm *xwm, xcb_atom_t atom);
+struct wlr_xwm_selection *xwm_get_selection(struct wlr_xwm *xwm,
+ xcb_atom_t selection_atom);
+
+void xwm_send_incr_chunk(struct wlr_xwm_selection_transfer *transfer);
+void xwm_handle_selection_request(struct wlr_xwm *xwm,
+ xcb_selection_request_event_t *req);
+
+void xwm_get_incr_chunk(struct wlr_xwm_selection_transfer *transfer);
+void xwm_handle_selection_notify(struct wlr_xwm *xwm,
+ xcb_selection_notify_event_t *event);
+int xwm_handle_xfixes_selection_notify(struct wlr_xwm *xwm,
+ xcb_xfixes_selection_notify_event_t *event);
+bool wlr_data_source_is_xwayland_data_source(struct wlr_data_source *wlr_source);
+bool wlr_primary_selection_source_is_xwayland_primary_selection_source(
+ struct wlr_primary_selection_source *wlr_source);
+
+void xwm_seat_handle_start_drag(struct wlr_xwm *xwm, struct wlr_drag *drag);
+
+void xwm_selection_init(struct wlr_xwm *xwm);
+void xwm_selection_finish(struct wlr_xwm *xwm);
+
+#endif
diff --git a/include/xwayland/xwm.h b/include/xwayland/xwm.h
index 9e21ea3a..662d00af 100644
--- a/include/xwayland/xwm.h
+++ b/include/xwayland/xwm.h
@@ -5,13 +5,18 @@
#include <wlr/config.h>
#include <wlr/xwayland.h>
#include <xcb/render.h>
-
#ifdef WLR_HAS_XCB_ICCCM
- #include <xcb/xcb_icccm.h>
+#include <xcb/xcb_icccm.h>
#endif
#ifdef WLR_HAS_XCB_ERRORS
- #include <xcb/xcb_errors.h>
+#include <xcb/xcb_errors.h>
#endif
+#include "xwayland/selection.h"
+
+/* This is in xcb/xcb_event.h, but pulling xcb-util just for a constant
+ * others redefine anyway is meh
+ */
+#define XCB_EVENT_RESPONSE_TYPE_MASK (0x7f)
enum atom_name {
WL_SURFACE_ID,
@@ -47,12 +52,27 @@ enum atom_name {
INCR,
TEXT,
TIMESTAMP,
+ DELETE,
NET_WM_WINDOW_TYPE_UTILITY,
NET_WM_WINDOW_TYPE_TOOLTIP,
NET_WM_WINDOW_TYPE_DND,
NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
NET_WM_WINDOW_TYPE_POPUP_MENU,
NET_WM_WINDOW_TYPE_COMBO,
+ DND_SELECTION,
+ DND_AWARE,
+ DND_STATUS,
+ DND_POSITION,
+ DND_ENTER,
+ DND_LEAVE,
+ DND_DROP,
+ DND_FINISHED,
+ DND_PROXY,
+ DND_TYPE_LIST,
+ DND_ACTION_MOVE,
+ DND_ACTION_COPY,
+ DND_ACTION_ASK,
+ DND_ACTION_PRIVATE,
ATOM_LAST,
};
@@ -64,24 +84,6 @@ enum net_wm_state_action {
NET_WM_STATE_TOGGLE = 2,
};
-struct wlr_xwm_selection {
- struct wlr_xwm *xwm;
- xcb_atom_t atom;
- xcb_window_t window;
- xcb_selection_request_event_t request;
- xcb_window_t owner;
- xcb_timestamp_t timestamp;
- int incr;
- int source_fd;
- int property_start;
- xcb_get_property_reply_t *property_reply;
- struct wl_event_source *property_source;
- int flush_property_on_delete;
- struct wl_array source_data;
- xcb_atom_t target;
- bool property_set;
-};
-
struct wlr_xwm {
struct wlr_xwayland *xwayland;
struct wl_event_source *event_source;
@@ -100,11 +102,17 @@ struct wlr_xwm {
struct wlr_xwm_selection clipboard_selection;
struct wlr_xwm_selection primary_selection;
+ xcb_window_t dnd_window;
+ struct wlr_xwm_selection dnd_selection;
+
struct wlr_xwayland_surface *focus_surface;
struct wl_list surfaces; // wlr_xwayland_surface::link
struct wl_list unpaired_surfaces; // wlr_xwayland_surface::unpaired_link
+ struct wlr_drag *drag;
+ struct wlr_xwayland_surface *drag_focus;
+
const xcb_query_extension_reply_t *xfixes;
#ifdef WLR_HAS_XCB_ERRORS
xcb_errors_context_t *errors_context;
@@ -114,6 +122,12 @@ struct wlr_xwm {
struct wl_listener compositor_destroy;
struct wl_listener seat_selection;
struct wl_listener seat_primary_selection;
+ struct wl_listener seat_start_drag;
+ struct wl_listener seat_drag_focus;
+ struct wl_listener seat_drag_motion;
+ struct wl_listener seat_drag_drop;
+ struct wl_listener seat_drag_destroy;
+ struct wl_listener seat_drag_source_destroy;
};
struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland);
@@ -124,13 +138,13 @@ void xwm_set_cursor(struct wlr_xwm *xwm, const uint8_t *pixels, uint32_t stride,
uint32_t width, uint32_t height, int32_t hotspot_x, int32_t hotspot_y);
int xwm_handle_selection_event(struct wlr_xwm *xwm, xcb_generic_event_t *event);
-
-void xwm_selection_init(struct wlr_xwm *xwm);
-void xwm_selection_finish(struct wlr_xwm *xwm);
+int xwm_handle_selection_client_message(struct wlr_xwm *xwm,
+ xcb_client_message_event_t *ev);
void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat);
+char *xwm_get_atom_name(struct wlr_xwm *xwm, xcb_atom_t atom);
bool xwm_atoms_contains(struct wlr_xwm *xwm, xcb_atom_t *atoms,
- size_t num_atoms, enum atom_name needle);
+ size_t num_atoms, enum atom_name needle);
#endif
diff --git a/types/wlr_data_device.c b/types/wlr_data_device.c
index 50c94bc5..13b1d08a 100644
--- a/types/wlr_data_device.c
+++ b/types/wlr_data_device.c
@@ -84,9 +84,7 @@ static void data_offer_update_action(struct wlr_data_offer *offer) {
return;
}
- if (offer->source->dnd_action) {
- offer->source->dnd_action(offer->source, action);
- }
+ wlr_data_source_dnd_action(offer->source, action);
if (wl_resource_get_version(offer->resource) >=
WL_DATA_OFFER_ACTION_SINCE_VERSION) {
@@ -104,10 +102,7 @@ static void data_offer_accept(struct wl_client *client,
// TODO check that client is currently focused by the input device
- if (offer->source->accept) {
- offer->source->accept(offer->source, serial, mime_type);
- }
- offer->source->accepted = (mime_type != NULL);
+ wlr_data_source_accept(offer->source, serial, mime_type);
}
static void data_offer_receive(struct wl_client *client,
@@ -115,7 +110,7 @@ static void data_offer_receive(struct wl_client *client,
struct wlr_data_offer *offer = data_offer_from_resource(resource);
if (offer->source && offer == offer->source->offer) {
- offer->source->send(offer->source, mime_type, fd);
+ wlr_data_source_send(offer->source, mime_type, fd);
} else {
close(fd);
}
@@ -131,15 +126,12 @@ static void data_source_notify_finish(struct wlr_data_source *source) {
return;
}
- if (source->offer->in_ask && source->dnd_action) {
- source->dnd_action(source, source->current_dnd_action);
- }
-
- if (source->dnd_finish) {
- source->dnd_finish(source);
+ if (source->offer->in_ask) {
+ wlr_data_source_dnd_action(source, source->current_dnd_action);
}
source->offer = NULL;
+ wlr_data_source_dnd_finish(source);
}
static void data_offer_finish(struct wl_client *client,
@@ -199,10 +191,10 @@ static void data_offer_resource_destroy(struct wl_resource *resource) {
WL_DATA_OFFER_ACTION_SINCE_VERSION) {
data_source_notify_finish(offer->source);
offer->source->offer = NULL;
- } else if (offer->source->dnd_finish) {
+ } else if (offer->source->impl->dnd_finish) {
// source->cancel can free the source
offer->source->offer = NULL;
- offer->source->cancel(offer->source);
+ wlr_data_source_cancel(offer->source);
} else {
offer->source->offer = NULL;
}
@@ -275,9 +267,9 @@ void wlr_seat_client_send_selection(struct wlr_seat_client *seat_client) {
return;
}
- if (seat_client->seat->selection_data_source) {
+ if (seat_client->seat->selection_source) {
struct wlr_data_offer *offer = wlr_data_source_send_offer(
- seat_client->seat->selection_data_source, seat_client);
+ seat_client->seat->selection_source, seat_client);
if (offer == NULL) {
return;
}
@@ -294,10 +286,10 @@ void wlr_seat_client_send_selection(struct wlr_seat_client *seat_client) {
}
}
-static void seat_client_selection_data_source_destroy(
+static void seat_client_selection_source_destroy(
struct wl_listener *listener, void *data) {
struct wlr_seat *seat =
- wl_container_of(listener, seat, selection_data_source_destroy);
+ wl_container_of(listener, seat, selection_source_destroy);
struct wlr_seat_client *seat_client = seat->keyboard_state.focused_client;
if (seat_client && seat->keyboard_state.focused_surface) {
@@ -307,30 +299,25 @@ static void seat_client_selection_data_source_destroy(
}
}
- seat->selection_data_source = NULL;
+ seat->selection_source = NULL;
wlr_signal_emit_safe(&seat->events.selection, seat);
}
void wlr_seat_set_selection(struct wlr_seat *seat,
struct wlr_data_source *source, uint32_t serial) {
- if (source) {
- assert(source->send);
- assert(source->cancel);
- }
-
- if (seat->selection_data_source &&
+ if (seat->selection_source &&
seat->selection_serial - serial < UINT32_MAX / 2) {
return;
}
- if (seat->selection_data_source) {
- seat->selection_data_source->cancel(seat->selection_data_source);
- seat->selection_data_source = NULL;
- wl_list_remove(&seat->selection_data_source_destroy.link);
+ if (seat->selection_source) {
+ wl_list_remove(&seat->selection_source_destroy.link);
+ wlr_data_source_cancel(seat->selection_source);
+ seat->selection_source = NULL;
}
- seat->selection_data_source = source;
+ seat->selection_source = source;
seat->selection_serial = serial;
struct wlr_seat_client *focused_client =
@@ -343,10 +330,10 @@ void wlr_seat_set_selection(struct wlr_seat *seat,
wlr_signal_emit_safe(&seat->events.selection, seat);
if (source) {
- seat->selection_data_source_destroy.notify =
- seat_client_selection_data_source_destroy;
+ seat->selection_source_destroy.notify =
+ seat_client_selection_source_destroy;
wl_signal_add(&source->events.destroy,
- &seat->selection_data_source_destroy);
+ &seat->selection_source_destroy);
}
}
@@ -426,8 +413,7 @@ static void wlr_drag_set_focus(struct wlr_drag *drag,
struct wlr_seat_client *focus_client =
wlr_seat_client_for_wl_client(drag->seat_client->seat,
wl_resource_get_client(surface->resource));
-
- if (!focus_client || wl_list_empty(&focus_client->data_devices)) {
+ if (!focus_client) {
return;
}
@@ -436,34 +422,36 @@ static void wlr_drag_set_focus(struct wlr_drag *drag,
drag->source->accepted = false;
struct wlr_data_offer *offer = wlr_data_source_send_offer(drag->source,
focus_client);
- if (offer == NULL) {
- return;
- }
+ if (offer != NULL) {
+ data_offer_update_action(offer);
- data_offer_update_action(offer);
+ if (wl_resource_get_version(offer->resource) >=
+ WL_DATA_OFFER_SOURCE_ACTIONS_SINCE_VERSION) {
+ wl_data_offer_send_source_actions(offer->resource,
+ drag->source->actions);
+ }
- if (wl_resource_get_version(offer->resource) >=
- WL_DATA_OFFER_SOURCE_ACTIONS_SINCE_VERSION) {
- wl_data_offer_send_source_actions(offer->resource,
- drag->source->actions);
+ offer_resource = offer->resource;
}
-
- offer_resource = offer->resource;
}
- uint32_t serial =
- wl_display_next_serial(drag->seat_client->seat->display);
- struct wl_resource *resource;
- wl_resource_for_each(resource, &focus_client->data_devices) {
- wl_data_device_send_enter(resource, serial, surface->resource,
- wl_fixed_from_double(sx), wl_fixed_from_double(sy), offer_resource);
+ if (!wl_list_empty(&focus_client->data_devices)) {
+ uint32_t serial =
+ wl_display_next_serial(drag->seat_client->seat->display);
+ struct wl_resource *resource;
+ wl_resource_for_each(resource, &focus_client->data_devices) {
+ wl_data_device_send_enter(resource, serial, surface->resource,
+ wl_fixed_from_double(sx), wl_fixed_from_double(sy),
+ offer_resource);
+ }
}
drag->focus = surface;
drag->focus_client = focus_client;
drag->seat_client_destroy.notify = handle_drag_seat_client_destroy;
- wl_signal_add(&focus_client->events.destroy,
- &drag->seat_client_destroy);
+ wl_signal_add(&focus_client->events.destroy, &drag->seat_client_destroy);
+
+ wlr_signal_emit_safe(&drag->events.focus, drag);
}
static void wlr_drag_end(struct wlr_drag *drag) {
@@ -488,6 +476,7 @@ static void wlr_drag_end(struct wlr_drag *drag) {
wlr_signal_emit_safe(&drag->icon->events.map, drag->icon);
}
+ wlr_signal_emit_safe(&drag->events.destroy, drag);
free(drag);
}
}
@@ -501,12 +490,20 @@ static void pointer_drag_enter(struct wlr_seat_pointer_grab *grab,
static void pointer_drag_motion(struct wlr_seat_pointer_grab *grab,
uint32_t time, double sx, double sy) {
struct wlr_drag *drag = grab->data;
- if (drag->focus != NULL&& drag->focus_client != NULL) {
+ if (drag->focus != NULL && drag->focus_client != NULL) {
struct wl_resource *resource;
wl_resource_for_each(resource, &drag->focus_client->data_devices) {
wl_data_device_send_motion(resource, time, wl_fixed_from_double(sx),
wl_fixed_from_double(sy));
}
+
+ struct wlr_drag_motion_event event = {
+ .drag = drag,
+ .time = time,
+ .sx = sx,
+ .sy = sy,
+ };
+ wlr_signal_emit_safe(&drag->events.motion, &event);
}
}
@@ -523,15 +520,21 @@ static uint32_t pointer_drag_button(struct wlr_seat_pointer_grab *grab,
wl_resource_for_each(resource, &drag->focus_client->data_devices) {
wl_data_device_send_drop(resource);
}
- if (drag->source->dnd_drop) {
- drag->source->dnd_drop(drag->source);
+ wlr_data_source_dnd_drop(drag->source);
+
+ if (drag->source->offer != NULL) {
+ drag->source->offer->in_ask =
+ drag->source->current_dnd_action ==
+ WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
}
- drag->source->offer->in_ask =
- drag->source->current_dnd_action ==
- WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
- } else if (drag->source->dnd_finish) {
- drag->source->cancel(drag->source);
+ struct wlr_drag_drop_event event = {
+ .drag = drag,
+ .time = time,
+ };
+ wlr_signal_emit_safe(&drag->events.drop, &event);
+ } else if (drag->source->impl->dnd_finish) {
+ wlr_data_source_cancel(drag->source);
}
}
@@ -545,6 +548,7 @@ static uint32_t pointer_drag_button(struct wlr_seat_pointer_grab *grab,
static void pointer_drag_axis(struct wlr_seat_pointer_grab *grab, uint32_t time,
enum wlr_axis_orientation orientation, double value) {
+ // This space is intentionally left blank
}
static void pointer_drag_cancel(struct wlr_seat_pointer_grab *grab) {
@@ -552,8 +556,8 @@ static void pointer_drag_cancel(struct wlr_seat_pointer_grab *grab) {
wlr_drag_end(drag);
}
-const struct
-wlr_pointer_grab_interface wlr_data_device_pointer_drag_interface = {
+static const struct wlr_pointer_grab_interface
+ data_device_pointer_drag_interface = {
.enter = pointer_drag_enter,
.motion = pointer_drag_motion,
.button = pointer_drag_button,
@@ -608,7 +612,8 @@ static void touch_drag_cancel(struct wlr_seat_touch_grab *grab) {
wlr_drag_end(drag);
}
-const struct wlr_touch_grab_interface wlr_data_device_touch_drag_interface = {
+static const struct wlr_touch_grab_interface
+ data_device_touch_drag_interface = {
.down = touch_drag_down,
.up = touch_drag_up,
.motion = touch_drag_motion,
@@ -639,8 +644,8 @@ static void keyboard_drag_cancel(struct wlr_seat_keyboard_grab *grab) {
wlr_drag_end(drag);
}
-const struct
-wlr_keyboard_grab_interface wlr_data_device_keyboard_drag_interface = {
+static const struct wlr_keyboard_grab_interface
+ data_device_keyboard_drag_interface = {
.enter = keyboard_drag_enter,
.key = keyboard_drag_key,
.modifiers = keyboard_drag_modifiers,
@@ -724,6 +729,14 @@ static struct wlr_drag_icon *wlr_drag_icon_create(
return icon;
}
+static void seat_handle_drag_source_destroy(struct wl_listener *listener,
+ void *data) {
+ struct wlr_seat *seat =
+ wl_container_of(listener, seat, drag_source_destroy);
+ wl_list_remove(&seat->drag_source_destroy.link);
+ seat->drag_source = NULL;
+}
+
static bool seat_client_start_drag(struct wlr_seat_client *client,
struct wlr_data_source *source, struct wlr_surface *icon_surface,
struct wlr_surface *origin, uint32_t serial) {
@@ -732,22 +745,28 @@ static bool seat_client_start_drag(struct wlr_seat_client *client,
return false;
}
- drag->seat = client->seat;
+ wl_signal_init(&drag->events.focus);
+ wl_signal_init(&drag->events.motion);
+ wl_signal_init(&drag->events.drop);
+ wl_signal_init(&drag->events.destroy);
+
+ struct wlr_seat *seat = client->seat;
+ drag->seat = seat;
drag->is_pointer_grab = !wl_list_empty(&client->pointers) &&
- client->seat->pointer_state.button_count == 1 &&
- client->seat->pointer_state.grab_serial == serial &&
- client->seat->pointer_state.focused_surface &&
- client->seat->pointer_state.focused_surface == origin;
+ seat->pointer_state.button_count == 1 &&
+ seat->pointer_state.grab_serial == serial &&
+ seat->pointer_state.focused_surface &&
+ seat->pointer_state.focused_surface == origin;
bool is_touch_grab = !wl_list_empty(&client->touches) &&
- wlr_seat_touch_num_points(client->seat) == 1 &&
- client->seat->touch_state.grab_serial == serial;
+ wlr_seat_touch_num_points(seat) == 1 &&
+ seat->touch_state.grab_serial == serial;
// set in the iteration
struct wlr_touch_point *point = NULL;
if (is_touch_grab) {
- wl_list_for_each(point, &client->seat->touch_state.touch_points, link) {
+ wl_list_for_each(point, &seat->touch_state.touch_points, link) {
is_touch_grab = point->surface && point->surface == origin;
break;
}
@@ -773,34 +792,45 @@ static bool seat_client_start_drag(struct wlr_seat_client *client,
wl_signal_add(&icon->events.destroy, &drag->icon_destroy);
}
- if (source) {
+ drag->source = source;
+ if (source != NULL) {
drag->source_destroy.notify = drag_handle_drag_source_destroy;
wl_signal_add(&source->events.destroy, &drag->source_destroy);
- drag->source = source;
}
drag->seat_client = client;
drag->pointer_grab.data = drag;
- drag->pointer_grab.interface = &wlr_data_device_pointer_drag_interface;
+ drag->pointer_grab.interface = &data_device_pointer_drag_interface;
drag->touch_grab.data = drag;
- drag->touch_grab.interface = &wlr_data_device_touch_drag_interface;
- drag->grab_touch_id = drag->seat->touch_state.grab_id;
+ drag->touch_grab.interface = &data_device_touch_drag_interface;
+ drag->grab_touch_id = seat->touch_state.grab_id;
drag->keyboard_grab.data = drag;
- drag->keyboard_grab.interface = &wlr_data_device_keyboard_drag_interface;
+ drag->keyboard_grab.interface = &data_device_keyboard_drag_interface;
- wlr_seat_keyboard_start_grab(drag->seat, &drag->keyboard_grab);
+ wlr_seat_keyboard_start_grab(seat, &drag->keyboard_grab);
if (drag->is_pointer_grab) {
- wlr_seat_pointer_clear_focus(drag->seat);
- wlr_seat_pointer_start_grab(drag->seat, &drag->pointer_grab);
+ wlr_seat_pointer_clear_focus(seat);
+ wlr_seat_pointer_start_grab(seat, &drag->pointer_grab);
} else {
assert(point);
- wlr_seat_touch_start_grab(drag->seat, &drag->touch_grab);
+ wlr_seat_touch_start_grab(seat, &drag->touch_grab);
wlr_drag_set_focus(drag, point->surface, point->sx, point->sy);
}
+ seat->drag = drag; // TODO: unset this thing somewhere
+ seat->drag_serial = serial;
+
+ seat->drag_source = source;
+ if (source != NULL) {
+ seat->drag_source_destroy.notify = seat_handle_drag_source_destroy;
+ wl_signal_add(&source->events.destroy, &seat->drag_source_destroy);
+ }
+
+ wlr_signal_emit_safe(&seat->events.start_drag, drag);
+
return true;
}
@@ -854,36 +884,51 @@ static void data_device_destroy(struct wl_resource *resource) {
struct client_data_source {
struct wlr_data_source source;
+ struct wlr_data_source_impl impl;
struct wl_resource *resource;
};
static void client_data_source_accept(struct wlr_data_source *wlr_source,
+ uint32_t serial, const char *mime_type);
+
+static struct client_data_source *client_data_source_from_wlr_data_source(
+ struct wlr_data_source *wlr_source) {
+ assert(wlr_source->impl->accept == client_data_source_accept);
+ return (struct client_data_source *)wlr_source;
+}
+
+static void client_data_source_accept(struct wlr_data_source *wlr_source,
uint32_t serial, const char *mime_type) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
wl_data_source_send_target(source->resource, mime_type);
}
static void client_data_source_send(struct wlr_data_source *wlr_source,
const char *mime_type, int32_t fd) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
wl_data_source_send_send(source->resource, mime_type, fd);
close(fd);
}
static void client_data_source_cancel(struct wlr_data_source *wlr_source) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
wl_data_source_send_cancelled(source->resource);
}
static void client_data_source_dnd_drop(struct wlr_data_source *wlr_source) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
assert(wl_resource_get_version(source->resource) >=
WL_DATA_SOURCE_DND_DROP_PERFORMED_SINCE_VERSION);
wl_data_source_send_dnd_drop_performed(source->resource);
}
static void client_data_source_dnd_finish(struct wlr_data_source *wlr_source) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
assert(wl_resource_get_version(source->resource) >=
WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION);
wl_data_source_send_dnd_finished(source->resource);
@@ -891,7 +936,8 @@ static void client_data_source_dnd_finish(struct wlr_data_source *wlr_source) {
static void client_data_source_dnd_action(struct wlr_data_source *wlr_source,
enum wl_data_device_manager_dnd_action action) {
- struct client_data_source *source = (struct client_data_source *)wlr_source;
+ struct client_data_source *source =
+ client_data_source_from_wlr_data_source(wlr_source);
assert(wl_resource_get_version(source->resource) >=
WL_DATA_SOURCE_ACTION_SINCE_VERSION);
wl_data_source_send_action(source->resource, action);
@@ -902,6 +948,37 @@ static void data_source_destroy(struct wl_client *client,
wl_resource_destroy(resource);
}
+static struct client_data_source *client_data_source_create(
+ struct wl_resource *source_resource) {
+ struct client_data_source *source =
+ calloc(1, sizeof(struct client_data_source));
+ if (source == NULL) {
+ return NULL;
+ }
+
+ source->resource = source_resource;
+
+ source->impl.accept = client_data_source_accept;
+ source->impl.send = client_data_source_send;
+ source->impl.cancel = client_data_source_cancel;
+
+ if (wl_resource_get_version(source->resource) >=
+ WL_DATA_SOURCE_DND_DROP_PERFORMED_SINCE_VERSION) {
+ source->impl.dnd_drop = client_data_source_dnd_drop;
+ }
+ if (wl_resource_get_version(source->resource) >=
+ WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION) {
+ source->impl.dnd_finish = client_data_source_dnd_finish;
+ }
+ if (wl_resource_get_version(source->resource) >=
+ WL_DATA_SOURCE_ACTION_SINCE_VERSION) {
+ source->impl.dnd_action = client_data_source_dnd_action;
+ }
+
+ wlr_data_source_init(&source->source, &source->impl);
+ return source;
+}
+
static void data_source_set_actions(struct wl_client *client,
struct wl_resource *resource, uint32_t dnd_actions) {
struct client_data_source *source =
@@ -962,7 +1039,11 @@ static void data_source_resource_handle_destroy(struct wl_resource *resource) {
free(source);
}
-void wlr_data_source_init(struct wlr_data_source *source) {
+void wlr_data_source_init(struct wlr_data_source *source,
+ const struct wlr_data_source_impl *impl) {
+ assert(impl->send);
+
+ source->impl = impl;
wl_array_init(&source->mime_types);
wl_signal_init(&source->events.destroy);
source->actions = -1;
@@ -982,6 +1063,45 @@ void wlr_data_source_finish(struct wlr_data_source *source) {
wl_array_release(&source->mime_types);
}
+void wlr_data_source_send(struct wlr_data_source *source, const char *mime_type,
+ int32_t fd) {
+ source->impl->send(source, mime_type, fd);
+}
+
+void wlr_data_source_accept(struct wlr_data_source *source, uint32_t serial,
+ const char *mime_type) {
+ source->accepted = (mime_type != NULL);
+ if (source->impl->accept) {
+ source->impl->accept(source, serial, mime_type);
+ }
+}
+
+void wlr_data_source_cancel(struct wlr_data_source *source) {
+ if (source->impl->cancel) {
+ source->impl->cancel(source);
+ }
+}
+
+void wlr_data_source_dnd_drop(struct wlr_data_source *source) {
+ if (source->impl->dnd_drop) {
+ source->impl->dnd_drop(source);
+ }
+}
+
+void wlr_data_source_dnd_finish(struct wlr_data_source *source) {
+ if (source->impl->dnd_finish) {
+ source->impl->dnd_finish(source);
+ }
+}
+
+void wlr_data_source_dnd_action(struct wlr_data_source *source,
+ enum wl_data_device_manager_dnd_action action) {
+ source->current_dnd_action = action;
+ if (source->impl->dnd_action) {
+ source->impl->dnd_action(source, action);
+ }
+}
+
void data_device_manager_get_data_device(struct wl_client *client,
struct wl_resource *manager_resource, uint32_t id,
@@ -1003,44 +1123,27 @@ void data_device_manager_get_data_device(struct wl_client *client,
static void data_device_manager_create_data_source(struct wl_client *client,
struct wl_resource *resource, uint32_t id) {
- struct client_data_source *source =
- calloc(1, sizeof(struct client_data_source));
- if (source == NULL) {
+ struct wl_resource *source_resource = wl_resource_create(client,
+ &wl_data_source_interface, wl_resource_get_version(resource), id);
+ if (source_resource == NULL) {
wl_resource_post_no_memory(resource);
return;
}
- wlr_data_source_init(&source->source);
- source->resource = wl_resource_create(client, &wl_data_source_interface,
- wl_resource_get_version(resource), id);
- if (source->resource == NULL) {
- free(source);
+ struct client_data_source *source =
+ client_data_source_create(source_resource);
+ if (source == NULL) {
+ wl_resource_destroy(source_resource);
wl_resource_post_no_memory(resource);
return;
}
- wl_resource_set_implementation(source->resource, &data_source_impl,
- source, data_source_resource_handle_destroy);
- source->source.accept = client_data_source_accept;
- source->source.send = client_data_source_send;
- source->source.cancel = client_data_source_cancel;
-
- if (wl_resource_get_version(source->resource) >=
- WL_DATA_SOURCE_DND_DROP_PERFORMED_SINCE_VERSION) {
- source->source.dnd_drop = client_data_source_dnd_drop;
- }
- if (wl_resource_get_version(source->resource) >=
- WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION) {
- source->source.dnd_finish = client_data_source_dnd_finish;
- }
- if (wl_resource_get_version(source->resource) >=
- WL_DATA_SOURCE_ACTION_SINCE_VERSION) {
- source->source.dnd_action = client_data_source_dnd_action;
- }
+ wl_resource_set_implementation(source_resource, &data_source_impl,
+ source, data_source_resource_handle_destroy);
}
static const struct wl_data_device_manager_interface
-data_device_manager_impl = {
+ data_device_manager_impl = {
.create_data_source = data_device_manager_create_data_source,
.get_data_device = data_device_manager_get_data_device,
};
diff --git a/types/wlr_seat.c b/types/wlr_seat.c
index 9793df74..5e5de235 100644
--- a/types/wlr_seat.c
+++ b/types/wlr_seat.c
@@ -365,10 +365,10 @@ void wlr_seat_destroy(struct wlr_seat *seat) {
wl_list_remove(&seat->display_destroy.link);
- if (seat->selection_data_source) {
- seat->selection_data_source->cancel(seat->selection_data_source);
- seat->selection_data_source = NULL;
- wl_list_remove(&seat->selection_data_source_destroy.link);
+ if (seat->selection_source) {
+ wl_list_remove(&seat->selection_source_destroy.link);
+ wlr_data_source_cancel(seat->selection_source);
+ seat->selection_source = NULL;
}
if (seat->primary_selection_source) {
seat->primary_selection_source->cancel(seat->primary_selection_source);
@@ -465,6 +465,7 @@ struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) {
wl_list_init(&wlr_seat->clients);
wl_list_init(&wlr_seat->drag_icons);
+ wl_signal_init(&wlr_seat->events.start_drag);
wl_signal_init(&wlr_seat->events.new_drag_icon);
wl_signal_init(&wlr_seat->events.request_set_cursor);
diff --git a/xwayland/meson.build b/xwayland/meson.build
index 9d7f3f4a..ec486f58 100644
--- a/xwayland/meson.build
+++ b/xwayland/meson.build
@@ -1,7 +1,10 @@
lib_wlr_xwayland = static_library(
'wlr_xwayland',
files(
- 'selection.c',
+ 'selection/dnd.c',
+ 'selection/incoming.c',
+ 'selection/outgoing.c',
+ 'selection/selection.c',
'sockets.c',
'xwayland.c',
'xwm.c',
diff --git a/xwayland/selection.c b/xwayland/selection.c
deleted file mode 100644
index 72f3de3e..00000000
--- a/xwayland/selection.c
+++ /dev/null
@@ -1,920 +0,0 @@
-#define _XOPEN_SOURCE 700
-#include <assert.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <wlr/types/wlr_data_device.h>
-#include <wlr/types/wlr_primary_selection.h>
-#include <wlr/util/log.h>
-#include <xcb/xfixes.h>
-#include "xwayland/xwm.h"
-
-static const size_t incr_chunk_size = 64 * 1024;
-
-static void xwm_selection_send_notify(struct wlr_xwm_selection *selection,
- xcb_atom_t property) {
- xcb_selection_notify_event_t selection_notify = {
- .response_type = XCB_SELECTION_NOTIFY,
- .sequence = 0,
- .time = selection->request.time,
- .requestor = selection->request.requestor,
- .selection = selection->request.selection,
- .target = selection->request.target,
- .property = property,
- };
-
- xcb_send_event(selection->xwm->xcb_conn,
- 0, // propagate
- selection->request.requestor,
- XCB_EVENT_MASK_NO_EVENT,
- (char *)&selection_notify);
-}
-
-static int xwm_selection_flush_source_data(struct wlr_xwm_selection *selection) {
- xcb_change_property(selection->xwm->xcb_conn,
- XCB_PROP_MODE_REPLACE,
- selection->request.requestor,
- selection->request.property,
- selection->target,
- 8, // format
- selection->source_data.size,
- selection->source_data.data);
- selection->property_set = true;
- int length = selection->source_data.size;
- selection->source_data.size = 0;
-
- return length;
-}
-
-static void xwm_data_source_remove_property_source(
- struct wlr_xwm_selection *selection) {
- if (selection->property_source) {
- wl_event_source_remove(selection->property_source);
- }
- selection->property_source = NULL;
-}
-
-static void xwm_data_source_close_source_fd(
- struct wlr_xwm_selection *selection) {
- close(selection->source_fd);
- selection->source_fd = -1;
-}
-
-static int xwm_data_source_read(int fd, uint32_t mask, void *data) {
- struct wlr_xwm_selection *selection = data;
- struct wlr_xwm *xwm = selection->xwm;
-
- void *p;
- int current = selection->source_data.size;
- if (selection->source_data.size < incr_chunk_size) {
- p = wl_array_add(&selection->source_data, incr_chunk_size);
- if (!p){
- wlr_log(L_ERROR, "Could not allocate selection source_data");
- goto error_out;
- }
- } else {
- p = (char *) selection->source_data.data + selection->source_data.size;
- }
-
- int available = selection->source_data.alloc - current;
-
- int len = read(fd, p, available);
- if (len == -1) {
- wlr_log(L_ERROR, "read error from data source: %m");
- goto error_out;
- }
-
- wlr_log(L_DEBUG, "read %d (available %d, mask 0x%x) bytes: \"%.*s\"",
- len, available, mask, len, (char *) p);
-
- selection->source_data.size = current + len;
- if (selection->source_data.size >= incr_chunk_size) {
- if (!selection->incr) {
- wlr_log(L_DEBUG, "got %zu bytes, starting incr",
- selection->source_data.size);
- selection->incr = 1;
- xcb_change_property(xwm->xcb_conn,
- XCB_PROP_MODE_REPLACE,
- selection->request.requestor,
- selection->request.property,
- xwm->atoms[INCR],
- 32, /* format */
- 1, &incr_chunk_size);
- selection->property_set = true;
- selection->flush_property_on_delete = 1;
- xwm_data_source_remove_property_source(selection);
- xwm_selection_send_notify(selection, selection->request.property);
- } else if (selection->property_set) {
- wlr_log(L_DEBUG, "got %zu bytes, waiting for property delete",
- selection->source_data.size);
-
- selection->flush_property_on_delete = 1;
- xwm_data_source_remove_property_source(selection);
- } else {
- wlr_log(L_DEBUG, "got %zu bytes, property deleted, setting new "
- "property", selection->source_data.size);
- xwm_selection_flush_source_data(selection);
- }
- } else if (len == 0 && !selection->incr) {
- wlr_log(L_DEBUG, "non-incr transfer complete");
- /* Non-incr transfer all done. */
- xwm_selection_flush_source_data(selection);
- xwm_selection_send_notify(selection, selection->request.property);
- xcb_flush(xwm->xcb_conn);
- xwm_data_source_remove_property_source(selection);
- xwm_data_source_close_source_fd(selection);
- wl_array_release(&selection->source_data);
- selection->request.requestor = XCB_NONE;
- } else if (len == 0 && selection->incr) {
- wlr_log(L_DEBUG, "incr transfer complete");
-
- selection->flush_property_on_delete = 1;
- if (selection->property_set) {
- wlr_log(L_DEBUG, "got %zu bytes, waiting for property delete",
- selection->source_data.size);
- } else {
- wlr_log(L_DEBUG, "got %zu bytes, property deleted, setting new "
- "property", selection->source_data.size);
- xwm_selection_flush_source_data(selection);
- }
- xcb_flush(xwm->xcb_conn);
- xwm_data_source_remove_property_source(selection);
- xwm_data_source_close_source_fd(selection);
- } else {
- wlr_log(L_DEBUG, "nothing happened, buffered the bytes");
- }
-
- return 1;
-
-error_out:
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- xwm_data_source_remove_property_source(selection);
- xwm_data_source_close_source_fd(selection);
- wl_array_release(&selection->source_data);
- return 0;
-}
-
-static void xwm_selection_source_send(struct wlr_xwm_selection *selection,
- const char *mime_type, int32_t fd) {
- if (selection == &selection->xwm->clipboard_selection) {
- struct wlr_data_source *source =
- selection->xwm->seat->selection_data_source;
- if (source != NULL) {
- source->send(source, mime_type, fd);
- return;
- }
- } else if (selection == &selection->xwm->primary_selection) {
- struct wlr_primary_selection_source *source =
- selection->xwm->seat->primary_selection_source;
- if (source != NULL) {
- source->send(source, mime_type, fd);
- return;
- }
- }
-
- wlr_log(L_DEBUG, "not sending selection: no selection source available");
-}
-
-static void xwm_selection_send_data(struct wlr_xwm_selection *selection,
- xcb_atom_t target, const char *mime_type) {
- int p[2];
- if (pipe(p) == -1) {
- wlr_log(L_ERROR, "pipe failed: %m");
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- return;
- }
-
- fcntl(p[0], F_SETFD, FD_CLOEXEC);
- fcntl(p[0], F_SETFL, O_NONBLOCK);
- fcntl(p[1], F_SETFD, FD_CLOEXEC);
- fcntl(p[1], F_SETFL, O_NONBLOCK);
-
- wl_array_init(&selection->source_data);
- selection->target = target;
- selection->source_fd = p[0];
- struct wl_event_loop *loop =
- wl_display_get_event_loop(selection->xwm->xwayland->wl_display);
- selection->property_source = wl_event_loop_add_fd(loop,
- selection->source_fd, WL_EVENT_READABLE, xwm_data_source_read,
- selection);
-
- xwm_selection_source_send(selection, mime_type, p[1]);
- close(p[1]);
-}
-
-static void xwm_selection_send_timestamp(struct wlr_xwm_selection *selection) {
- xcb_change_property(selection->xwm->xcb_conn,
- XCB_PROP_MODE_REPLACE,
- selection->request.requestor,
- selection->request.property,
- XCB_ATOM_INTEGER,
- 32, // format
- 1, &selection->timestamp);
-
- xwm_selection_send_notify(selection, selection->request.property);
-}
-
-static struct wl_array *xwm_selection_source_get_mime_types(
- struct wlr_xwm_selection *selection) {
- if (selection == &selection->xwm->clipboard_selection) {
- struct wlr_data_source *source =
- selection->xwm->seat->selection_data_source;
- if (source != NULL) {
- return &source->mime_types;
- }
- } else if (selection == &selection->xwm->primary_selection) {
- struct wlr_primary_selection_source *source =
- selection->xwm->seat->primary_selection_source;
- if (source != NULL) {
- return &source->mime_types;
- }
- }
- return NULL;
-}
-
-static void xwm_selection_send_targets(struct wlr_xwm_selection *selection) {
- struct wlr_xwm *xwm = selection->xwm;
-
- struct wl_array *mime_types = xwm_selection_source_get_mime_types(selection);
- if (mime_types == NULL) {
- wlr_log(L_DEBUG, "not sending selection targets: "
- "no selection source available");
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- return;
- }
-
- size_t n = 2 + mime_types->size / sizeof(char *);
- xcb_atom_t *targets = malloc(n * sizeof(xcb_atom_t));
- if (targets == NULL) {
- return;
- }
- targets[0] = xwm->atoms[TIMESTAMP];
- targets[1] = xwm->atoms[TARGETS];
-
- size_t i = 2;
- char **mime_type_ptr;
- wl_array_for_each(mime_type_ptr, mime_types) {
- char *mime_type = *mime_type_ptr;
- xcb_atom_t atom;
- if (strcmp(mime_type, "text/plain;charset=utf-8") == 0) {
- atom = xwm->atoms[UTF8_STRING];
- } else if (strcmp(mime_type, "text/plain") == 0) {
- atom = xwm->atoms[TEXT];
- } else {
- xcb_intern_atom_cookie_t cookie =
- xcb_intern_atom(xwm->xcb_conn, 0, strlen(mime_type), mime_type);
- xcb_intern_atom_reply_t *reply =
- xcb_intern_atom_reply(xwm->xcb_conn, cookie, NULL);
- if (reply == NULL) {
- --n;
- continue;
- }
- atom = reply->atom;
- free(reply);
- }
- targets[i] = atom;
- ++i;
- }
-
- xcb_change_property(xwm->xcb_conn,
- XCB_PROP_MODE_REPLACE,
- selection->request.requestor,
- selection->request.property,
- XCB_ATOM_ATOM,
- 32, // format
- n, targets);
-
- xwm_selection_send_notify(selection, selection->request.property);
-
- free(targets);
-}
-
-static struct wlr_xwm_selection *xwm_get_selection(struct wlr_xwm *xwm,
- xcb_atom_t selection_atom) {
- if (selection_atom == xwm->atoms[CLIPBOARD]) {
- return &xwm->clipboard_selection;
- } else if (selection_atom == xwm->atoms[PRIMARY]) {
- return &xwm->primary_selection;
- } else {
- return NULL;
- }
-}
-
-static void xwm_handle_selection_request(struct wlr_xwm *xwm,
- xcb_generic_event_t *event) {
- xcb_selection_request_event_t *selection_request =
- (xcb_selection_request_event_t *) event;
-
- wlr_log(L_DEBUG, "XCB_SELECTION_REQUEST (selection=%u, target=%u)",
- selection_request->selection, selection_request->target);
-
- if (selection_request->selection == xwm->atoms[CLIPBOARD_MANAGER]) {
- // The wlroots clipboard should already have grabbed the first target,
- // so just send selection notify now. This isn't synchronized with the
- // clipboard finishing getting the data, so there's a race here.
- struct wlr_xwm_selection *selection = &xwm->clipboard_selection;
- selection->request = *selection_request;
- selection->incr = 0;
- selection->flush_property_on_delete = 0;
- xwm_selection_send_notify(selection, selection->request.property);
- return;
- }
-
- struct wlr_xwm_selection *selection =
- xwm_get_selection(xwm, selection_request->selection);
- if (selection == NULL) {
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- return;
- }
-
- selection->request = *selection_request;
- selection->incr = 0;
- selection->flush_property_on_delete = 0;
-
- // No xwayland surface focused, deny access to clipboard
- if (xwm->focus_surface == NULL) {
- wlr_log(L_DEBUG, "denying read access to clipboard: "
- "no xwayland surface focused");
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- return;
- }
-
- if (selection_request->target == xwm->atoms[TARGETS]) {
- xwm_selection_send_targets(selection);
- } else if (selection_request->target == xwm->atoms[TIMESTAMP]) {
- xwm_selection_send_timestamp(selection);
- } else if (selection_request->target == xwm->atoms[UTF8_STRING]) {
- xwm_selection_send_data(selection, selection_request->target,
- "text/plain;charset=utf-8");
- } else if (selection_request->target == xwm->atoms[TEXT]) {
- xwm_selection_send_data(selection, selection_request->target,
- "text/plain");
- } else {
- xcb_get_atom_name_cookie_t name_cookie =
- xcb_get_atom_name(xwm->xcb_conn, selection_request->target);
- xcb_get_atom_name_reply_t *name_reply =
- xcb_get_atom_name_reply(xwm->xcb_conn, name_cookie, NULL);
- if (name_reply == NULL) {
- wlr_log(L_DEBUG, "not handling selection request: unknown atom");
- xwm_selection_send_notify(selection, XCB_ATOM_NONE);
- return;
- }
- size_t len = xcb_get_atom_name_name_length(name_reply);
- char *mime_type = malloc((len + 1) * sizeof(char));
- if (mime_type == NULL) {
- free(name_reply);
- return;
- }
- memcpy(mime_type, xcb_get_atom_name_name(name_reply), len);
- mime_type[len] = '\0';
- xwm_selection_send_data(selection, selection_request->target, mime_type);
- free(mime_type);
- free(name_reply);
- }
-}
-
-static void xwm_data_source_destroy_property_reply(
- struct wlr_xwm_selection *selection) {
- free(selection->property_reply);
- selection->property_reply = NULL;
-}
-
-static int xwm_data_source_write(int fd, uint32_t mask, void *data) {
- struct wlr_xwm_selection *selection = data;
- struct wlr_xwm *xwm = selection->xwm;
-
- unsigned char *property = xcb_get_property_value(selection->property_reply);
- int remainder = xcb_get_property_value_length(selection->property_reply) -
- selection->property_start;
-
- int len = write(fd, property + selection->property_start, remainder);
- if (len == -1) {
- xwm_data_source_destroy_property_reply(selection);
- xwm_data_source_remove_property_source(selection);
- xwm_data_source_close_source_fd(selection);
- wlr_log(L_ERROR, "write error to target fd: %m");
- return 1;
- }
-
- wlr_log(L_DEBUG, "wrote %d (chunk size %d) of %d bytes",
- selection->property_start + len,
- len, xcb_get_property_value_length(selection->property_reply));
-
- selection->property_start += len;
- if (len == remainder) {
- xwm_data_source_destroy_property_reply(selection);
- xwm_data_source_remove_property_source(selection);
-
- if (selection->incr) {
- xcb_delete_property(xwm->xcb_conn,
- selection->window,
- xwm->atoms[WL_SELECTION]);
- } else {
- wlr_log(L_DEBUG, "transfer complete");
- xwm_data_source_close_source_fd(selection);
- }
- }
-
- return 1;
-}
-
-static void xwm_write_property(struct wlr_xwm_selection *selection,
- xcb_get_property_reply_t *reply) {
- selection->property_start = 0;
- selection->property_reply = reply;
- xwm_data_source_write(selection->source_fd, WL_EVENT_WRITABLE, selection);
-
- if (selection->property_reply) {
- struct wl_event_loop *loop =
- wl_display_get_event_loop(selection->xwm->xwayland->wl_display);
- selection->property_source = wl_event_loop_add_fd(loop,
- selection->source_fd, WL_EVENT_WRITABLE, xwm_data_source_write,
- selection);
- }
-}
-
-static void xwm_selection_get_data(struct wlr_xwm_selection *selection) {
- struct wlr_xwm *xwm = selection->xwm;
-
- xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
- 1, // delete
- selection->window,
- xwm->atoms[WL_SELECTION],
- XCB_GET_PROPERTY_TYPE_ANY,
- 0, // offset
- 0x1fffffff // length
- );
-
- xcb_get_property_reply_t *reply =
- xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
- if (reply == NULL) {
- return;
- }
-
- if (reply->type == xwm->atoms[INCR]) {
- selection->incr = 1;
- free(reply);
- } else {
- selection->incr = 0;
- // reply's ownership is transferred to wm, which is responsible
- // for freeing it
- xwm_write_property(selection, reply);
- }
-}
-
-static void source_send(struct wlr_xwm_selection *selection,
- struct wl_array *mime_types, struct wl_array *mime_types_atoms,
- const char *requested_mime_type, int32_t fd) {
- struct wlr_xwm *xwm = selection->xwm;
-
- xcb_atom_t *atoms = mime_types_atoms->data;
- bool found = false;
- xcb_atom_t mime_type_atom;
- char **mime_type_ptr;
- size_t i = 0;
- wl_array_for_each(mime_type_ptr, mime_types) {
- char *mime_type = *mime_type_ptr;
- if (strcmp(mime_type, requested_mime_type) == 0) {
- found = true;
- mime_type_atom = atoms[i];
- break;
- }
- ++i;
- }
- if (!found) {
- wlr_log(L_DEBUG, "cannot send X11 selection: unsupported MIME type");
- return;
- }
-
- xcb_convert_selection(xwm->xcb_conn,
- selection->window,
- selection->atom,
- mime_type_atom,
- xwm->atoms[WL_SELECTION],
- XCB_TIME_CURRENT_TIME);
-
- xcb_flush(xwm->xcb_conn);
-
- fcntl(fd, F_SETFL, O_WRONLY | O_NONBLOCK);
- selection->source_fd = fd;
-}
-
-struct x11_data_source {
- struct wlr_data_source base;
- struct wlr_xwm_selection *selection;
- struct wl_array mime_types_atoms;
-};
-
-static void data_source_accept(struct wlr_data_source *base, uint32_t time,
- const char *mime_type) {
- // No-op
-}
-
-static void data_source_send(struct wlr_data_source *base,
- const char *mime_type, int32_t fd) {
- struct x11_data_source *source = (struct x11_data_source *)base;
- struct wlr_xwm_selection *selection = source->selection;
-
- source_send(selection, &base->mime_types, &source->mime_types_atoms,
- mime_type, fd);
-}
-
-static void data_source_cancel(struct wlr_data_source *base) {
- struct x11_data_source *source = (struct x11_data_source *)base;
- wlr_data_source_finish(&source->base);
- wl_array_release(&source->mime_types_atoms);
- free(source);
-}
-
-struct x11_primary_selection_source {
- struct wlr_primary_selection_source base;
- struct wlr_xwm_selection *selection;
- struct wl_array mime_types_atoms;
-};
-
-static void primary_selection_source_send(
- struct wlr_primary_selection_source *base, const char *mime_type,
- int32_t fd) {
- struct x11_primary_selection_source *source =
- (struct x11_primary_selection_source *)base;
- struct wlr_xwm_selection *selection = source->selection;
-
- source_send(selection, &base->mime_types, &source->mime_types_atoms,
- mime_type, fd);
-}
-
-static void primary_selection_source_cancel(
- struct wlr_primary_selection_source *base) {
- struct x11_primary_selection_source *source =
- (struct x11_primary_selection_source *)base;
- wlr_primary_selection_source_finish(&source->base);
- wl_array_release(&source->mime_types_atoms);
- free(source);
-}
-
-static bool source_get_targets(struct wlr_xwm_selection *selection,
- struct wl_array *mime_types, struct wl_array *mime_types_atoms) {
- struct wlr_xwm *xwm = selection->xwm;
-
- xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
- 1, // delete
- selection->window,
- xwm->atoms[WL_SELECTION],
- XCB_GET_PROPERTY_TYPE_ANY,
- 0, // offset
- 4096 // length
- );
-
- xcb_get_property_reply_t *reply =
- xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
- if (reply == NULL) {
- return false;
- }
-
- if (reply->type != XCB_ATOM_ATOM) {
- free(reply);
- return false;
- }
-
- xcb_atom_t *value = xcb_get_property_value(reply);
- for (uint32_t i = 0; i < reply->value_len; i++) {
- char *mime_type = NULL;
-
- if (value[i] == xwm->atoms[UTF8_STRING]) {
- mime_type = strdup("text/plain;charset=utf-8");
- } else if (value[i] == xwm->atoms[TEXT]) {
- mime_type = strdup("text/plain");
- } else if (value[i] != xwm->atoms[TARGETS] &&
- value[i] != xwm->atoms[TIMESTAMP]) {
- xcb_get_atom_name_cookie_t name_cookie =
- xcb_get_atom_name(xwm->xcb_conn, value[i]);
- xcb_get_atom_name_reply_t *name_reply =
- xcb_get_atom_name_reply(xwm->xcb_conn, name_cookie, NULL);
- if (name_reply == NULL) {
- continue;
- }
- size_t len = xcb_get_atom_name_name_length(name_reply);
- char *name = xcb_get_atom_name_name(name_reply); // not a C string
- if (memchr(name, '/', len) != NULL) {
- mime_type = malloc((len + 1) * sizeof(char));
- if (mime_type == NULL) {
- free(name_reply);
- continue;
- }
- memcpy(mime_type, name, len);
- mime_type[len] = '\0';
- }
- free(name_reply);
- }
-
- if (mime_type != NULL) {
- char **mime_type_ptr =
- wl_array_add(mime_types, sizeof(*mime_type_ptr));
- if (mime_type_ptr == NULL) {
- break;
- }
- *mime_type_ptr = mime_type;
-
- xcb_atom_t *atom_ptr =
- wl_array_add(mime_types_atoms, sizeof(*atom_ptr));
- if (atom_ptr == NULL) {
- break;
- }
- *atom_ptr = value[i];
- }
- }
-
- free(reply);
- return true;
-}
-
-static void xwm_selection_get_targets(struct wlr_xwm_selection *selection) {
- // set the wayland selection to the X11 selection
- struct wlr_xwm *xwm = selection->xwm;
-
- if (selection == &xwm->clipboard_selection) {
- struct x11_data_source *source =
- calloc(1, sizeof(struct x11_data_source));
- if (source == NULL) {
- return;
- }
- wlr_data_source_init(&source->base);
- source->base.accept = data_source_accept;
- source->base.send = data_source_send;
- source->base.cancel = data_source_cancel;
-
- source->selection = selection;
- wl_array_init(&source->mime_types_atoms);
-
- bool ok = source_get_targets(selection, &source->base.mime_types,
- &source->mime_types_atoms);
- if (ok) {
- wlr_seat_set_selection(xwm->seat, &source->base,
- wl_display_next_serial(xwm->xwayland->wl_display));
- } else {
- source->base.cancel(&source->base);
- }
- } else if (selection == &xwm->primary_selection) {
- struct x11_primary_selection_source *source =
- calloc(1, sizeof(struct x11_primary_selection_source));
- if (source == NULL) {
- return;
- }
- wlr_primary_selection_source_init(&source->base);
- source->base.send = primary_selection_source_send;
- source->base.cancel = primary_selection_source_cancel;
-
- source->selection = selection;
- wl_array_init(&source->mime_types_atoms);
-
- bool ok = source_get_targets(selection, &source->base.mime_types,
- &source->mime_types_atoms);
- if (ok) {
- wlr_seat_set_primary_selection(xwm->seat, &source->base,
- wl_display_next_serial(xwm->xwayland->wl_display));
- } else {
- source->base.cancel(&source->base);
- }
- }
-}
-
-static void xwm_handle_selection_notify(struct wlr_xwm *xwm,
- xcb_generic_event_t *event) {
- xcb_selection_notify_event_t *selection_notify =
- (xcb_selection_notify_event_t *) event;
-
- wlr_log(L_DEBUG, "XCB_SELECTION_NOTIFY (selection=%u, property=%u, target=%u)",
- selection_notify->selection, selection_notify->property,
- selection_notify->target);
-
- struct wlr_xwm_selection *selection =
- xwm_get_selection(xwm, selection_notify->selection);
- if (selection == NULL) {
- return;
- }
-
- if (selection_notify->property == XCB_ATOM_NONE) {
- wlr_log(L_ERROR, "convert selection failed");
- } else if (selection_notify->target == xwm->atoms[TARGETS]) {
- // No xwayland surface focused, deny access to clipboard
- if (xwm->focus_surface == NULL) {
- wlr_log(L_DEBUG, "denying write access to clipboard: "
- "no xwayland surface focused");
- return;
- }
-
- // This sets the Wayland clipboard (by calling wlr_seat_set_selection)
- xwm_selection_get_targets(selection);
- } else {
- xwm_selection_get_data(selection);
- }
-}
-
-static int xwm_handle_xfixes_selection_notify(struct wlr_xwm *xwm,
- xcb_generic_event_t *event) {
- xcb_xfixes_selection_notify_event_t *xfixes_selection_notify =
- (xcb_xfixes_selection_notify_event_t *)event;
-
- wlr_log(L_DEBUG, "XCB_XFIXES_SELECTION_NOTIFY (selection=%u, owner=%u)",
- xfixes_selection_notify->selection, xfixes_selection_notify->owner);
-
- struct wlr_xwm_selection *selection =
- xwm_get_selection(xwm, xfixes_selection_notify->selection);
- if (selection == NULL) {
- return 0;
- }
-
- if (xfixes_selection_notify->owner == XCB_WINDOW_NONE) {
- if (selection->owner != selection->window) {
- // A real X client selection went away, not our
- // proxy selection
- if (selection == &xwm->clipboard_selection) {
- wlr_seat_set_selection(xwm->seat, NULL,
- wl_display_next_serial(xwm->xwayland->wl_display));
- } else if (selection == &xwm->primary_selection) {
- wlr_seat_set_primary_selection(xwm->seat, NULL,
- wl_display_next_serial(xwm->xwayland->wl_display));
- }
- }
-
- selection->owner = XCB_WINDOW_NONE;
- return 1;
- }
-
- selection->owner = xfixes_selection_notify->owner;
-
- // We have to use XCB_TIME_CURRENT_TIME when we claim the
- // selection, so grab the actual timestamp here so we can
- // answer TIMESTAMP conversion requests correctly.
- if (xfixes_selection_notify->owner == selection->window) {
- selection->timestamp = xfixes_selection_notify->timestamp;
- return 1;
- }
-
- selection->incr = 0;
- // doing this will give a selection notify where we actually handle the sync
- xcb_convert_selection(xwm->xcb_conn, selection->window,
- selection->atom,
- xwm->atoms[TARGETS],
- xwm->atoms[WL_SELECTION],
- xfixes_selection_notify->timestamp);
-
- xcb_flush(xwm->xcb_conn);
-
- return 1;
-}
-
-int xwm_handle_selection_event(struct wlr_xwm *xwm,
- xcb_generic_event_t *event) {
- if (xwm->seat == NULL) {
- wlr_log(L_DEBUG, "not handling selection events:"
- "no seat assigned to xwayland");
- return 0;
- }
-
- switch (event->response_type & ~0x80) {
- case XCB_SELECTION_NOTIFY:
- xwm_handle_selection_notify(xwm, event);
- return 1;
- case XCB_SELECTION_REQUEST:
- xwm_handle_selection_request(xwm, event);
- return 1;
- }
-
- switch (event->response_type - xwm->xfixes->first_event) {
- case XCB_XFIXES_SELECTION_NOTIFY:
- // an X11 window has copied something to the clipboard
- return xwm_handle_xfixes_selection_notify(xwm, event);
- }
-
- return 0;
-}
-
-static void selection_init(struct wlr_xwm *xwm,
- struct wlr_xwm_selection *selection, xcb_atom_t atom) {
- selection->xwm = xwm;
- selection->atom = atom;
- selection->window = xwm->selection_window;
- selection->request.requestor = XCB_NONE;
-
- uint32_t mask =
- XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
- XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
- XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
- xcb_xfixes_select_selection_input(xwm->xcb_conn, selection->window,
- selection->atom, mask);
-}
-
-void xwm_selection_init(struct wlr_xwm *xwm) {
- uint32_t values[] = { XCB_EVENT_MASK_PROPERTY_CHANGE };
- xwm->selection_window = xcb_generate_id(xwm->xcb_conn);
- xcb_create_window(xwm->xcb_conn,
- XCB_COPY_FROM_PARENT,
- xwm->selection_window,
- xwm->screen->root,
- 0, 0,
- 10, 10,
- 0,
- XCB_WINDOW_CLASS_INPUT_OUTPUT,
- xwm->screen->root_visual,
- XCB_CW_EVENT_MASK, values);
-
- xcb_set_selection_owner(xwm->xcb_conn,
- xwm->selection_window,
- xwm->atoms[CLIPBOARD_MANAGER],
- XCB_TIME_CURRENT_TIME);
-
- selection_init(xwm, &xwm->clipboard_selection, xwm->atoms[CLIPBOARD]);
- selection_init(xwm, &xwm->primary_selection, xwm->atoms[PRIMARY]);
-}
-
-void xwm_selection_finish(struct wlr_xwm *xwm) {
- if (!xwm) {
- return;
- }
- if (xwm->selection_window) {
- xcb_destroy_window(xwm->xcb_conn, xwm->selection_window);
- }
- if (xwm->seat) {
- if (xwm->seat->selection_data_source &&
- xwm->seat->selection_data_source->cancel == data_source_cancel) {
- wlr_seat_set_selection(xwm->seat, NULL,
- wl_display_next_serial(xwm->xwayland->wl_display));
- }
- if (xwm->seat->primary_selection_source &&
- xwm->seat->primary_selection_source->cancel == primary_selection_source_cancel) {
- wlr_seat_set_primary_selection(xwm->seat, NULL,
- wl_display_next_serial(xwm->xwayland->wl_display));
- }
- wlr_xwayland_set_seat(xwm->xwayland, NULL);
- }
-
-}
-
-static void xwm_selection_set_owner(struct wlr_xwm_selection *selection,
- bool set) {
- if (set) {
- xcb_set_selection_owner(selection->xwm->xcb_conn,
- selection->window,
- selection->atom,
- XCB_TIME_CURRENT_TIME);
- } else {
- if (selection->owner == selection->window) {
- xcb_set_selection_owner(selection->xwm->xcb_conn,
- XCB_WINDOW_NONE,
- selection->atom,
- selection->timestamp);
- }
- }
-}
-
-static void seat_handle_selection(struct wl_listener *listener,
- void *data) {
- struct wlr_seat *seat = data;
- struct wlr_xwm *xwm =
- wl_container_of(listener, xwm, seat_selection);
- struct wlr_data_source *source = seat->selection_data_source;
-
- if (source != NULL && source->send == data_source_send) {
- return;
- }
-
- xwm_selection_set_owner(&xwm->clipboard_selection, source != NULL);
-}
-
-static void seat_handle_primary_selection(struct wl_listener *listener,
- void *data) {
- struct wlr_seat *seat = data;
- struct wlr_xwm *xwm =
- wl_container_of(listener, xwm, seat_primary_selection);
- struct wlr_primary_selection_source *source = seat->primary_selection_source;
-
- if (source != NULL && source->send == primary_selection_source_send) {
- return;
- }
-
- xwm_selection_set_owner(&xwm->primary_selection, source != NULL);
-}
-
-void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat) {
- if (xwm->seat != NULL) {
- wl_list_remove(&xwm->seat_selection.link);
- wl_list_remove(&xwm->seat_primary_selection.link);
- xwm->seat = NULL;
- }
-
- if (seat == NULL) {
- return;
- }
-
- xwm->seat = seat;
-
- wl_signal_add(&seat->events.selection, &xwm->seat_selection);
- xwm->seat_selection.notify = seat_handle_selection;
- wl_signal_add(&seat->events.primary_selection, &xwm->seat_primary_selection);
- xwm->seat_primary_selection.notify = seat_handle_primary_selection;
-
- seat_handle_selection(&xwm->seat_selection, seat);
- seat_handle_primary_selection(&xwm->seat_primary_selection, seat);
-}
diff --git a/xwayland/selection/dnd.c b/xwayland/selection/dnd.c
new file mode 100644
index 00000000..ed265c28
--- /dev/null
+++ b/xwayland/selection/dnd.c
@@ -0,0 +1,340 @@
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_primary_selection.h>
+#include <wlr/util/log.h>
+#include <xcb/xfixes.h>
+#include "xwayland/xwm.h"
+#include "xwayland/selection.h"
+
+static xcb_atom_t data_device_manager_dnd_action_to_atom(
+ struct wlr_xwm *xwm, enum wl_data_device_manager_dnd_action action) {
+ if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY) {
+ return xwm->atoms[DND_ACTION_COPY];
+ } else if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE) {
+ return xwm->atoms[DND_ACTION_MOVE];
+ } else if (action & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK) {
+ return xwm->atoms[DND_ACTION_ASK];
+ }
+ return XCB_ATOM_NONE;
+}
+
+static enum wl_data_device_manager_dnd_action
+ data_device_manager_dnd_action_from_atom(struct wlr_xwm *xwm,
+ enum atom_name atom) {
+ if (atom == xwm->atoms[DND_ACTION_COPY] ||
+ atom == xwm->atoms[DND_ACTION_PRIVATE]) {
+ return WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
+ } else if (atom == xwm->atoms[DND_ACTION_MOVE]) {
+ return WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
+ } else if (atom == xwm->atoms[DND_ACTION_ASK]) {
+ return WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
+ }
+ return WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
+}
+
+static void xwm_dnd_send_event(struct wlr_xwm *xwm, xcb_atom_t type,
+ xcb_client_message_data_t *data) {
+ struct wlr_xwayland_surface *dest = xwm->drag_focus;
+ assert(dest != NULL);
+
+ xcb_client_message_event_t event = {
+ .response_type = XCB_CLIENT_MESSAGE,
+ .format = 32,
+ .sequence = 0,
+ .window = dest->window_id,
+ .type = type,
+ .data = *data,
+ };
+
+ xcb_send_event(xwm->xcb_conn,
+ 0, // propagate
+ dest->window_id,
+ XCB_EVENT_MASK_NO_EVENT,
+ (const char *)&event);
+ xcb_flush(xwm->xcb_conn);
+}
+
+static void xwm_dnd_send_enter(struct wlr_xwm *xwm) {
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+ struct wl_array *mime_types = &drag->source->mime_types;
+
+ xcb_client_message_data_t data = { 0 };
+ data.data32[0] = xwm->dnd_window;
+ data.data32[1] = XDND_VERSION << 24;
+
+ // If we have 3 MIME types or less, we can send them directly in the
+ // DND_ENTER message
+ size_t n = mime_types->size / sizeof(char *);
+ if (n <= 3) {
+ size_t i = 0;
+ char **mime_type_ptr;
+ wl_array_for_each(mime_type_ptr, mime_types) {
+ char *mime_type = *mime_type_ptr;
+ data.data32[2+i] = xwm_mime_type_to_atom(xwm, mime_type);
+ ++i;
+ }
+ } else {
+ // Let the client know that targets are not contained in the message
+ // data and must be retrieved with the DND_TYPE_LIST property
+ data.data32[1] |= 1;
+
+ xcb_atom_t targets[n];
+ size_t i = 0;
+ char **mime_type_ptr;
+ wl_array_for_each(mime_type_ptr, mime_types) {
+ char *mime_type = *mime_type_ptr;
+ targets[i] = xwm_mime_type_to_atom(xwm, mime_type);
+ ++i;
+ }
+
+ xcb_change_property(xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ xwm->dnd_window,
+ xwm->atoms[DND_TYPE_LIST],
+ XCB_ATOM_ATOM,
+ 32, // format
+ n, targets);
+ }
+
+ xwm_dnd_send_event(xwm, xwm->atoms[DND_ENTER], &data);
+}
+
+static void xwm_dnd_send_position(struct wlr_xwm *xwm, uint32_t time, int16_t x,
+ int16_t y) {
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+
+ xcb_client_message_data_t data = { 0 };
+ data.data32[0] = xwm->dnd_window;
+ data.data32[2] = (x << 16) | y;
+ data.data32[3] = time;
+ data.data32[4] =
+ data_device_manager_dnd_action_to_atom(xwm, drag->source->actions);
+
+ xwm_dnd_send_event(xwm, xwm->atoms[DND_POSITION], &data);
+}
+
+static void xwm_dnd_send_drop(struct wlr_xwm *xwm, uint32_t time) {
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+ struct wlr_xwayland_surface *dest = xwm->drag_focus;
+ assert(dest != NULL);
+
+ xcb_client_message_data_t data = { 0 };
+ data.data32[0] = xwm->dnd_window;
+ data.data32[2] = time;
+
+ xwm_dnd_send_event(xwm, xwm->atoms[DND_DROP], &data);
+}
+
+static void xwm_dnd_send_leave(struct wlr_xwm *xwm) {
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+ struct wlr_xwayland_surface *dest = xwm->drag_focus;
+ assert(dest != NULL);
+
+ xcb_client_message_data_t data = { 0 };
+ data.data32[0] = xwm->dnd_window;
+
+ xwm_dnd_send_event(xwm, xwm->atoms[DND_LEAVE], &data);
+}
+
+/*static void xwm_dnd_send_finished(struct wlr_xwm *xwm) {
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+ struct wlr_xwayland_surface *dest = xwm->drag_focus;
+ assert(dest != NULL);
+
+ xcb_client_message_data_t data = { 0 };
+ data.data32[0] = xwm->dnd_window;
+ data.data32[1] = drag->source->accepted;
+
+ if (drag->source->accepted) {
+ data.data32[2] = data_device_manager_dnd_action_to_atom(xwm,
+ drag->source->current_dnd_action);
+ }
+
+ xwm_dnd_send_event(xwm, xwm->atoms[DND_FINISHED], &data);
+}*/
+
+int xwm_handle_selection_client_message(struct wlr_xwm *xwm,
+ xcb_client_message_event_t *ev) {
+ if (ev->type == xwm->atoms[DND_STATUS]) {
+ if (xwm->drag == NULL) {
+ wlr_log(L_DEBUG, "ignoring XdndStatus client message because "
+ "there's no drag");
+ return 1;
+ }
+
+ xcb_client_message_data_t *data = &ev->data;
+ xcb_window_t target_window = data->data32[0];
+ bool accepted = data->data32[1] & 1;
+ xcb_atom_t action_atom = data->data32[4];
+
+ if (xwm->drag_focus == NULL ||
+ target_window != xwm->drag_focus->window_id) {
+ wlr_log(L_DEBUG, "ignoring XdndStatus client message because "
+ "it doesn't match the current drag focus window ID");
+ return 1;
+ }
+
+ enum wl_data_device_manager_dnd_action action =
+ data_device_manager_dnd_action_from_atom(xwm, action_atom);
+
+ struct wlr_drag *drag = xwm->drag;
+ assert(drag != NULL);
+
+ drag->source->accepted = accepted;
+ wlr_data_source_dnd_action(drag->source, action);
+
+ wlr_log(L_DEBUG, "DND_STATUS window=%d accepted=%d action=%d",
+ target_window, accepted, action);
+ return 1;
+ } else if (ev->type == xwm->atoms[DND_FINISHED]) {
+ // This should only happen after the drag has ended, but before the drag
+ // source is destroyed
+ if (xwm->seat == NULL || xwm->seat->drag_source == NULL ||
+ xwm->drag != NULL) {
+ wlr_log(L_DEBUG, "ignoring XdndFinished client message because "
+ "there's no finished drag");
+ return 1;
+ }
+
+ struct wlr_data_source *source = xwm->seat->drag_source;
+
+ xcb_client_message_data_t *data = &ev->data;
+ xcb_window_t target_window = data->data32[0];
+ bool performed = data->data32[1] & 1;
+ xcb_atom_t action_atom = data->data32[2];
+
+ if (xwm->drag_focus == NULL ||
+ target_window != xwm->drag_focus->window_id) {
+ wlr_log(L_DEBUG, "ignoring XdndFinished client message because "
+ "it doesn't match the finished drag focus window ID");
+ return 1;
+ }
+
+ enum wl_data_device_manager_dnd_action action =
+ data_device_manager_dnd_action_from_atom(xwm, action_atom);
+
+ if (performed) {
+ wlr_data_source_dnd_finish(source);
+ }
+
+ wlr_log(L_DEBUG, "DND_FINISH window=%d performed=%d action=%d",
+ target_window, performed, action);
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+static void seat_handle_drag_focus(struct wl_listener *listener, void *data) {
+ struct wlr_drag *drag = data;
+ struct wlr_xwm *xwm = wl_container_of(listener, xwm, seat_drag_focus);
+
+ struct wlr_xwayland_surface *focus = NULL;
+ if (drag->focus != NULL) {
+ // TODO: check for subsurfaces?
+ struct wlr_xwayland_surface *surface;
+ wl_list_for_each(surface, &xwm->surfaces, link) {
+ if (surface->surface == drag->focus) {
+ focus = surface;
+ break;
+ }
+ }
+ }
+
+ if (focus == xwm->drag_focus) {
+ return;
+ }
+
+ if (xwm->drag_focus != NULL) {
+ wlr_data_source_dnd_action(drag->source,
+ WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE);
+ xwm_dnd_send_leave(xwm);
+ }
+
+ xwm->drag_focus = focus;
+
+ if (xwm->drag_focus != NULL) {
+ xwm_dnd_send_enter(xwm);
+ }
+}
+
+static void seat_handle_drag_motion(struct wl_listener *listener, void *data) {
+ struct wlr_xwm *xwm = wl_container_of(listener, xwm, seat_drag_motion);
+ struct wlr_drag_motion_event *event = data;
+ struct wlr_xwayland_surface *surface = xwm->drag_focus;
+
+ if (surface == NULL) {
+ return; // No xwayland surface focused
+ }
+
+ xwm_dnd_send_position(xwm, event->time, surface->x + (int16_t)event->sx,
+ surface->y + (int16_t)event->sy);
+}
+
+static void seat_handle_drag_drop(struct wl_listener *listener, void *data) {
+ struct wlr_xwm *xwm = wl_container_of(listener, xwm, seat_drag_drop);
+ struct wlr_drag_drop_event *event = data;
+
+ if (xwm->drag_focus == NULL) {
+ return; // No xwayland surface focused
+ }
+
+ wlr_log(L_DEBUG, "Wayland drag dropped over an Xwayland window");
+ xwm_dnd_send_drop(xwm, event->time);
+}
+
+static void seat_handle_drag_destroy(struct wl_listener *listener, void *data) {
+ struct wlr_xwm *xwm = wl_container_of(listener, xwm, seat_drag_destroy);
+
+ // Don't reset drag focus yet because the target will read the drag source
+ // right after
+ if (xwm->drag_focus != NULL && !xwm->drag->source->accepted) {
+ wlr_log(L_DEBUG, "Wayland drag cancelled over an Xwayland window");
+ xwm_dnd_send_leave(xwm);
+ }
+
+ wl_list_remove(&xwm->seat_drag_focus.link);
+ wl_list_remove(&xwm->seat_drag_motion.link);
+ wl_list_remove(&xwm->seat_drag_drop.link);
+ wl_list_remove(&xwm->seat_drag_destroy.link);
+ xwm->drag = NULL;
+}
+
+static void seat_handle_drag_source_destroy(struct wl_listener *listener,
+ void *data) {
+ struct wlr_xwm *xwm =
+ wl_container_of(listener, xwm, seat_drag_source_destroy);
+
+ wl_list_remove(&xwm->seat_drag_source_destroy.link);
+ xwm->drag_focus = NULL;
+}
+
+void xwm_seat_handle_start_drag(struct wlr_xwm *xwm, struct wlr_drag *drag) {
+ xwm->drag = drag;
+ xwm->drag_focus = NULL;
+
+ if (drag != NULL) {
+ wl_signal_add(&drag->events.focus, &xwm->seat_drag_focus);
+ xwm->seat_drag_focus.notify = seat_handle_drag_focus;
+ wl_signal_add(&drag->events.motion, &xwm->seat_drag_motion);
+ xwm->seat_drag_motion.notify = seat_handle_drag_motion;
+ wl_signal_add(&drag->events.drop, &xwm->seat_drag_drop);
+ xwm->seat_drag_drop.notify = seat_handle_drag_drop;
+ wl_signal_add(&drag->events.destroy, &xwm->seat_drag_destroy);
+ xwm->seat_drag_destroy.notify = seat_handle_drag_destroy;
+
+ wl_signal_add(&drag->source->events.destroy,
+ &xwm->seat_drag_source_destroy);
+ xwm->seat_drag_source_destroy.notify = seat_handle_drag_source_destroy;
+ }
+}
diff --git a/xwayland/selection/incoming.c b/xwayland/selection/incoming.c
new file mode 100644
index 00000000..ab06f40d
--- /dev/null
+++ b/xwayland/selection/incoming.c
@@ -0,0 +1,461 @@
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_primary_selection.h>
+#include <wlr/util/log.h>
+#include <xcb/xfixes.h>
+#include "xwayland/xwm.h"
+#include "xwayland/selection.h"
+
+/**
+ * Write the X11 selection to a Wayland client.
+ */
+static int xwm_data_source_write(int fd, uint32_t mask, void *data) {
+ struct wlr_xwm_selection_transfer *transfer = data;
+ struct wlr_xwm *xwm = transfer->selection->xwm;
+
+ char *property = xcb_get_property_value(transfer->property_reply);
+ int remainder = xcb_get_property_value_length(transfer->property_reply) -
+ transfer->property_start;
+
+ ssize_t len = write(fd, property + transfer->property_start, remainder);
+ if (len == -1) {
+ xwm_selection_transfer_destroy_property_reply(transfer);
+ xwm_selection_transfer_remove_source(transfer);
+ xwm_selection_transfer_close_source_fd(transfer);
+ wlr_log(L_ERROR, "write error to target fd: %m");
+ return 1;
+ }
+
+ wlr_log(L_DEBUG, "wrote %ld (chunk size %ld) of %d bytes",
+ transfer->property_start + len,
+ len, xcb_get_property_value_length(transfer->property_reply));
+
+ transfer->property_start += len;
+ if (len == remainder) {
+ xwm_selection_transfer_destroy_property_reply(transfer);
+ xwm_selection_transfer_remove_source(transfer);
+
+ if (transfer->incr) {
+ wlr_log(L_DEBUG, "deleting property");
+ xcb_delete_property(xwm->xcb_conn, transfer->selection->window,
+ xwm->atoms[WL_SELECTION]);
+ xcb_flush(xwm->xcb_conn);
+ } else {
+ wlr_log(L_DEBUG, "transfer complete");
+ xwm_selection_transfer_close_source_fd(transfer);
+ }
+ }
+
+ return 1;
+}
+
+static void xwm_write_property(struct wlr_xwm_selection_transfer *transfer,
+ xcb_get_property_reply_t *reply) {
+ struct wlr_xwm *xwm = transfer->selection->xwm;
+
+ transfer->property_start = 0;
+ transfer->property_reply = reply;
+
+ xwm_data_source_write(transfer->source_fd, WL_EVENT_WRITABLE, transfer);
+
+ if (transfer->property_reply != NULL) {
+ struct wl_event_loop *loop =
+ wl_display_get_event_loop(xwm->xwayland->wl_display);
+ transfer->source = wl_event_loop_add_fd(loop,
+ transfer->source_fd, WL_EVENT_WRITABLE, xwm_data_source_write,
+ transfer);
+ }
+}
+
+void xwm_get_incr_chunk(struct wlr_xwm_selection_transfer *transfer) {
+ struct wlr_xwm *xwm = transfer->selection->xwm;
+ wlr_log(L_DEBUG, "xwm_get_incr_chunk");
+
+ xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
+ 0, // delete
+ transfer->selection->window,
+ xwm->atoms[WL_SELECTION],
+ XCB_GET_PROPERTY_TYPE_ANY,
+ 0, // offset
+ 0x1fffffff // length
+ );
+
+ xcb_get_property_reply_t *reply =
+ xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
+ if (reply == NULL) {
+ wlr_log(L_ERROR, "cannot get selection property");
+ return;
+ }
+ //dump_property(xwm, xwm->atoms[WL_SELECTION], reply);
+
+ if (xcb_get_property_value_length(reply) > 0) {
+ /* Reply's ownership is transferred to xwm, which is responsible
+ * for freeing it */
+ xwm_write_property(transfer, reply);
+ } else {
+ wlr_log(L_DEBUG, "transfer complete");
+ xwm_selection_transfer_close_source_fd(transfer);
+ free(reply);
+ }
+}
+
+static void xwm_selection_get_data(struct wlr_xwm_selection *selection) {
+ struct wlr_xwm *xwm = selection->xwm;
+
+ xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
+ 1, // delete
+ selection->window,
+ xwm->atoms[WL_SELECTION],
+ XCB_GET_PROPERTY_TYPE_ANY,
+ 0, // offset
+ 0x1fffffff // length
+ );
+
+ xcb_get_property_reply_t *reply =
+ xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
+ if (reply == NULL) {
+ wlr_log(L_ERROR, "Cannot get selection property");
+ return;
+ }
+
+ struct wlr_xwm_selection_transfer *transfer = &selection->incoming;
+ if (reply->type == xwm->atoms[INCR]) {
+ transfer->incr = true;
+ free(reply);
+ } else {
+ transfer->incr = false;
+ // reply's ownership is transferred to wm, which is responsible
+ // for freeing it
+ xwm_write_property(transfer, reply);
+ }
+}
+
+static void source_send(struct wlr_xwm_selection *selection,
+ struct wl_array *mime_types, struct wl_array *mime_types_atoms,
+ const char *requested_mime_type, int32_t fd) {
+ struct wlr_xwm *xwm = selection->xwm;
+ struct wlr_xwm_selection_transfer *transfer = &selection->incoming;
+
+ xcb_atom_t *atoms = mime_types_atoms->data;
+ bool found = false;
+ xcb_atom_t mime_type_atom;
+ char **mime_type_ptr;
+ size_t i = 0;
+ wl_array_for_each(mime_type_ptr, mime_types) {
+ char *mime_type = *mime_type_ptr;
+ if (strcmp(mime_type, requested_mime_type) == 0) {
+ found = true;
+ mime_type_atom = atoms[i];
+ break;
+ }
+ ++i;
+ }
+ if (!found) {
+ wlr_log(L_DEBUG, "Cannot send X11 selection to Wayland: "
+ "unsupported MIME type");
+ return;
+ }
+
+ xcb_convert_selection(xwm->xcb_conn,
+ selection->window,
+ selection->atom,
+ mime_type_atom,
+ xwm->atoms[WL_SELECTION],
+ XCB_TIME_CURRENT_TIME);
+
+ xcb_flush(xwm->xcb_conn);
+
+ fcntl(fd, F_SETFL, O_WRONLY | O_NONBLOCK);
+ transfer->source_fd = fd;
+}
+
+struct x11_data_source {
+ struct wlr_data_source base;
+ struct wlr_xwm_selection *selection;
+ struct wl_array mime_types_atoms;
+};
+
+static const struct wlr_data_source_impl data_source_impl;
+
+bool wlr_data_source_is_xwayland_data_source(
+ struct wlr_data_source *wlr_source) {
+ return wlr_source->impl == &data_source_impl;
+}
+
+static struct x11_data_source *data_source_from_wlr_data_source(
+ struct wlr_data_source *wlr_source) {
+ assert(wlr_data_source_is_xwayland_data_source(wlr_source));
+ return (struct x11_data_source *)wlr_source;
+}
+
+static void data_source_send(struct wlr_data_source *wlr_source,
+ const char *mime_type, int32_t fd) {
+ struct x11_data_source *source =
+ data_source_from_wlr_data_source(wlr_source);
+ struct wlr_xwm_selection *selection = source->selection;
+
+ source_send(selection, &wlr_source->mime_types, &source->mime_types_atoms,
+ mime_type, fd);
+}
+
+static void data_source_cancel(struct wlr_data_source *wlr_source) {
+ struct x11_data_source *source =
+ data_source_from_wlr_data_source(wlr_source);
+ wlr_data_source_finish(&source->base);
+ wl_array_release(&source->mime_types_atoms);
+ free(source);
+}
+
+static const struct wlr_data_source_impl data_source_impl = {
+ .send = data_source_send,
+ .cancel = data_source_cancel,
+};
+
+struct x11_primary_selection_source {
+ struct wlr_primary_selection_source base;
+ struct wlr_xwm_selection *selection;
+ struct wl_array mime_types_atoms;
+};
+
+static void primary_selection_source_cancel(
+ struct wlr_primary_selection_source *wlr_source);
+
+bool wlr_primary_selection_source_is_xwayland_primary_selection_source(
+ struct wlr_primary_selection_source *wlr_source) {
+ return wlr_source->cancel == primary_selection_source_cancel;
+}
+
+static void primary_selection_source_send(
+ struct wlr_primary_selection_source *wlr_source, const char *mime_type,
+ int32_t fd) {
+ struct x11_primary_selection_source *source =
+ (struct x11_primary_selection_source *)wlr_source;
+ struct wlr_xwm_selection *selection = source->selection;
+
+ source_send(selection, &wlr_source->mime_types, &source->mime_types_atoms,
+ mime_type, fd);
+}
+
+static void primary_selection_source_cancel(
+ struct wlr_primary_selection_source *wlr_source) {
+ struct x11_primary_selection_source *source =
+ (struct x11_primary_selection_source *)wlr_source;
+ wlr_primary_selection_source_finish(&source->base);
+ wl_array_release(&source->mime_types_atoms);
+ free(source);
+}
+
+static bool source_get_targets(struct wlr_xwm_selection *selection,
+ struct wl_array *mime_types, struct wl_array *mime_types_atoms) {
+ struct wlr_xwm *xwm = selection->xwm;
+
+ xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
+ 1, // delete
+ selection->window,
+ xwm->atoms[WL_SELECTION],
+ XCB_GET_PROPERTY_TYPE_ANY,
+ 0, // offset
+ 4096 // length
+ );
+
+ xcb_get_property_reply_t *reply =
+ xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
+ if (reply == NULL) {
+ return false;
+ }
+
+ if (reply->type != XCB_ATOM_ATOM) {
+ free(reply);
+ return false;
+ }
+
+ xcb_atom_t *value = xcb_get_property_value(reply);
+ for (uint32_t i = 0; i < reply->value_len; i++) {
+ char *mime_type = NULL;
+
+ if (value[i] == xwm->atoms[UTF8_STRING]) {
+ mime_type = strdup("text/plain;charset=utf-8");
+ } else if (value[i] == xwm->atoms[TEXT]) {
+ mime_type = strdup("text/plain");
+ } else if (value[i] != xwm->atoms[TARGETS] &&
+ value[i] != xwm->atoms[TIMESTAMP]) {
+ xcb_get_atom_name_cookie_t name_cookie =
+ xcb_get_atom_name(xwm->xcb_conn, value[i]);
+ xcb_get_atom_name_reply_t *name_reply =
+ xcb_get_atom_name_reply(xwm->xcb_conn, name_cookie, NULL);
+ if (name_reply == NULL) {
+ continue;
+ }
+ size_t len = xcb_get_atom_name_name_length(name_reply);
+ char *name = xcb_get_atom_name_name(name_reply); // not a C string
+ if (memchr(name, '/', len) != NULL) {
+ mime_type = malloc((len + 1) * sizeof(char));
+ if (mime_type == NULL) {
+ free(name_reply);
+ continue;
+ }
+ memcpy(mime_type, name, len);
+ mime_type[len] = '\0';
+ }
+ free(name_reply);
+ }
+
+ if (mime_type != NULL) {
+ char **mime_type_ptr =
+ wl_array_add(mime_types, sizeof(*mime_type_ptr));
+ if (mime_type_ptr == NULL) {
+ break;
+ }
+ *mime_type_ptr = mime_type;
+
+ xcb_atom_t *atom_ptr =
+ wl_array_add(mime_types_atoms, sizeof(*atom_ptr));
+ if (atom_ptr == NULL) {
+ break;
+ }
+ *atom_ptr = value[i];
+ }
+ }
+
+ free(reply);
+ return true;
+}
+
+static void xwm_selection_get_targets(struct wlr_xwm_selection *selection) {
+ // set the wayland selection to the X11 selection
+ struct wlr_xwm *xwm = selection->xwm;
+
+ if (selection == &xwm->clipboard_selection) {
+ struct x11_data_source *source =
+ calloc(1, sizeof(struct x11_data_source));
+ if (source == NULL) {
+ return;
+ }
+ wlr_data_source_init(&source->base, &data_source_impl);
+
+ source->selection = selection;
+ wl_array_init(&source->mime_types_atoms);
+
+ bool ok = source_get_targets(selection, &source->base.mime_types,
+ &source->mime_types_atoms);
+ if (ok) {
+ wlr_seat_set_selection(xwm->seat, &source->base,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ } else {
+ wlr_data_source_cancel(&source->base);
+ }
+ } else if (selection == &xwm->primary_selection) {
+ struct x11_primary_selection_source *source =
+ calloc(1, sizeof(struct x11_primary_selection_source));
+ if (source == NULL) {
+ return;
+ }
+ wlr_primary_selection_source_init(&source->base);
+ source->base.send = primary_selection_source_send;
+ source->base.cancel = primary_selection_source_cancel;
+
+ source->selection = selection;
+ wl_array_init(&source->mime_types_atoms);
+
+ bool ok = source_get_targets(selection, &source->base.mime_types,
+ &source->mime_types_atoms);
+ if (ok) {
+ wlr_seat_set_primary_selection(xwm->seat, &source->base,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ } else {
+ source->base.cancel(&source->base);
+ }
+ } else if (selection == &xwm->dnd_selection) {
+ // TODO
+ }
+}
+
+void xwm_handle_selection_notify(struct wlr_xwm *xwm,
+ xcb_selection_notify_event_t *event) {
+ wlr_log(L_DEBUG, "XCB_SELECTION_NOTIFY (selection=%u, property=%u, target=%u)",
+ event->selection, event->property,
+ event->target);
+
+ struct wlr_xwm_selection *selection =
+ xwm_get_selection(xwm, event->selection);
+ if (selection == NULL) {
+ return;
+ }
+
+ if (event->property == XCB_ATOM_NONE) {
+ wlr_log(L_ERROR, "convert selection failed");
+ } else if (event->target == xwm->atoms[TARGETS]) {
+ // No xwayland surface focused, deny access to clipboard
+ if (xwm->focus_surface == NULL) {
+ wlr_log(L_DEBUG, "denying write access to clipboard: "
+ "no xwayland surface focused");
+ return;
+ }
+
+ // This sets the Wayland clipboard (by calling wlr_seat_set_selection)
+ xwm_selection_get_targets(selection);
+ } else {
+ xwm_selection_get_data(selection);
+ }
+}
+
+int xwm_handle_xfixes_selection_notify(struct wlr_xwm *xwm,
+ xcb_xfixes_selection_notify_event_t *event) {
+ wlr_log(L_DEBUG, "XCB_XFIXES_SELECTION_NOTIFY (selection=%u, owner=%u)",
+ event->selection, event->owner);
+
+ struct wlr_xwm_selection *selection =
+ xwm_get_selection(xwm, event->selection);
+ if (selection == NULL) {
+ return 0;
+ }
+
+ if (event->owner == XCB_WINDOW_NONE) {
+ if (selection->owner != selection->window) {
+ // A real X client selection went away, not our
+ // proxy selection
+ if (selection == &xwm->clipboard_selection) {
+ wlr_seat_set_selection(xwm->seat, NULL,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ } else if (selection == &xwm->primary_selection) {
+ wlr_seat_set_primary_selection(xwm->seat, NULL,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ } else if (selection == &xwm->dnd_selection) {
+ // TODO: DND
+ } else {
+ wlr_log(L_DEBUG, "X11 selection has been cleared, but cannot "
+ "clear Wayland selection");
+ }
+ }
+
+ selection->owner = XCB_WINDOW_NONE;
+ return 1;
+ }
+
+ selection->owner = event->owner;
+
+ // We have to use XCB_TIME_CURRENT_TIME when we claim the
+ // selection, so grab the actual timestamp here so we can
+ // answer TIMESTAMP conversion requests correctly.
+ if (event->owner == selection->window) {
+ selection->timestamp = event->timestamp;
+ return 1;
+ }
+
+ struct wlr_xwm_selection_transfer *transfer = &selection->incoming;
+ transfer->incr = false;
+ // doing this will give a selection notify where we actually handle the sync
+ xcb_convert_selection(xwm->xcb_conn, selection->window,
+ selection->atom,
+ xwm->atoms[TARGETS],
+ xwm->atoms[WL_SELECTION],
+ event->timestamp);
+ xcb_flush(xwm->xcb_conn);
+
+ return 1;
+}
diff --git a/xwayland/selection/outgoing.c b/xwayland/selection/outgoing.c
new file mode 100644
index 00000000..b612b2fb
--- /dev/null
+++ b/xwayland/selection/outgoing.c
@@ -0,0 +1,420 @@
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_primary_selection.h>
+#include <wlr/util/log.h>
+#include <xcb/xfixes.h>
+#include "xwayland/xwm.h"
+#include "xwayland/selection.h"
+
+static void xwm_selection_send_notify(struct wlr_xwm *xwm,
+ xcb_selection_request_event_t *req, bool success) {
+ xcb_selection_notify_event_t selection_notify = {
+ .response_type = XCB_SELECTION_NOTIFY,
+ .sequence = 0,
+ .time = req->time,
+ .requestor = req->requestor,
+ .selection = req->selection,
+ .target = req->target,
+ .property = success ? req->property : XCB_ATOM_NONE,
+ };
+
+ wlr_log(L_DEBUG, "SendEvent destination=%d SelectionNotify(31) time=%d "
+ "requestor=%d selection=%d target=%d property=%d", req->requestor,
+ req->time, req->requestor, req->selection, req->target,
+ selection_notify.property);
+ xcb_send_event(xwm->xcb_conn,
+ 0, // propagate
+ req->requestor,
+ XCB_EVENT_MASK_NO_EVENT,
+ (const char *)&selection_notify);
+ xcb_flush(xwm->xcb_conn);
+}
+
+static int xwm_selection_flush_source_data(
+ struct wlr_xwm_selection_transfer *transfer) {
+ xcb_change_property(transfer->selection->xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ transfer->request.requestor,
+ transfer->request.property,
+ transfer->request.target,
+ 8, // format
+ transfer->source_data.size,
+ transfer->source_data.data);
+ xcb_flush(transfer->selection->xwm->xcb_conn);
+ transfer->property_set = true;
+ size_t length = transfer->source_data.size;
+ transfer->source_data.size = 0;
+ return length;
+}
+
+static void xwm_selection_transfer_start_outgoing(
+ struct wlr_xwm_selection_transfer *transfer);
+
+static void xwm_selection_transfer_destroy_outgoing(
+ struct wlr_xwm_selection_transfer *transfer) {
+ wl_list_remove(&transfer->outgoing_link);
+
+ // Start next queued transfer
+ struct wlr_xwm_selection_transfer *first = NULL;
+ if (!wl_list_empty(&transfer->selection->outgoing)) {
+ first = wl_container_of(transfer->selection->outgoing.prev, first,
+ outgoing_link);
+ xwm_selection_transfer_start_outgoing(first);
+ }
+
+ xwm_selection_transfer_remove_source(transfer);
+ xwm_selection_transfer_close_source_fd(transfer);
+ wl_array_release(&transfer->source_data);
+ free(transfer);
+}
+
+static int xwm_data_source_read(int fd, uint32_t mask, void *data) {
+ struct wlr_xwm_selection_transfer *transfer = data;
+ struct wlr_xwm *xwm = transfer->selection->xwm;
+
+ void *p;
+ size_t current = transfer->source_data.size;
+ if (transfer->source_data.size < INCR_CHUNK_SIZE) {
+ p = wl_array_add(&transfer->source_data, INCR_CHUNK_SIZE);
+ if (p == NULL) {
+ wlr_log(L_ERROR, "Could not allocate selection source_data");
+ goto error_out;
+ }
+ } else {
+ p = (char *)transfer->source_data.data + transfer->source_data.size;
+ }
+
+ size_t available = transfer->source_data.alloc - current;
+ ssize_t len = read(fd, p, available);
+ if (len == -1) {
+ wlr_log(L_ERROR, "read error from data source: %m");
+ goto error_out;
+ }
+
+ wlr_log(L_DEBUG, "read %ld bytes (available %zu, mask 0x%x)", len,
+ available, mask);
+
+ transfer->source_data.size = current + len;
+ if (transfer->source_data.size >= INCR_CHUNK_SIZE) {
+ if (!transfer->incr) {
+ wlr_log(L_DEBUG, "got %zu bytes, starting incr",
+ transfer->source_data.size);
+
+ size_t incr_chunk_size = INCR_CHUNK_SIZE;
+ xcb_change_property(xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ transfer->request.requestor,
+ transfer->request.property,
+ xwm->atoms[INCR],
+ 32, /* format */
+ 1, &incr_chunk_size);
+ transfer->incr = true;
+ transfer->property_set = true;
+ transfer->flush_property_on_delete = true;
+ xwm_selection_transfer_remove_source(transfer);
+ xwm_selection_send_notify(xwm, &transfer->request, true);
+ } else if (transfer->property_set) {
+ wlr_log(L_DEBUG, "got %zu bytes, waiting for property delete",
+ transfer->source_data.size);
+
+ transfer->flush_property_on_delete = true;
+ xwm_selection_transfer_remove_source(transfer);
+ } else {
+ wlr_log(L_DEBUG, "got %zu bytes, property deleted, setting new "
+ "property", transfer->source_data.size);
+ xwm_selection_flush_source_data(transfer);
+ }
+ } else if (len == 0 && !transfer->incr) {
+ wlr_log(L_DEBUG, "non-incr transfer complete");
+ xwm_selection_flush_source_data(transfer);
+ xwm_selection_send_notify(xwm, &transfer->request, true);
+ xwm_selection_transfer_destroy_outgoing(transfer);
+ } else if (len == 0 && transfer->incr) {
+ wlr_log(L_DEBUG, "incr transfer complete");
+
+ transfer->flush_property_on_delete = true;
+ if (transfer->property_set) {
+ wlr_log(L_DEBUG, "got %zu bytes, waiting for property delete",
+ transfer->source_data.size);
+ } else {
+ wlr_log(L_DEBUG, "got %zu bytes, property deleted, setting new "
+ "property", transfer->source_data.size);
+ xwm_selection_flush_source_data(transfer);
+ }
+ xwm_selection_transfer_remove_source(transfer);
+ xwm_selection_transfer_close_source_fd(transfer);
+ } else {
+ wlr_log(L_DEBUG, "nothing happened, buffered the bytes");
+ }
+
+ return 1;
+
+error_out:
+ xwm_selection_send_notify(xwm, &transfer->request, false);
+ xwm_selection_transfer_destroy_outgoing(transfer);
+ return 0;
+}
+
+void xwm_send_incr_chunk(struct wlr_xwm_selection_transfer *transfer) {
+ wlr_log(L_DEBUG, "property deleted");
+
+ transfer->property_set = false;
+ if (transfer->flush_property_on_delete) {
+ wlr_log(L_DEBUG, "setting new property, %zu bytes",
+ transfer->source_data.size);
+ transfer->flush_property_on_delete = false;
+ int length = xwm_selection_flush_source_data(transfer);
+
+ if (transfer->source_fd >= 0) {
+ xwm_selection_transfer_start_outgoing(transfer);
+ } else if (length > 0) {
+ /* Transfer is all done, but queue a flush for
+ * the delete of the last chunk so we can set
+ * the 0 sized property to signal the end of
+ * the transfer. */
+ transfer->flush_property_on_delete = true;
+ wl_array_release(&transfer->source_data);
+ wl_array_init(&transfer->source_data);
+ } else {
+ xwm_selection_transfer_destroy_outgoing(transfer);
+ }
+ }
+}
+
+static void xwm_selection_source_send(struct wlr_xwm_selection *selection,
+ const char *mime_type, int32_t fd) {
+ if (selection == &selection->xwm->clipboard_selection) {
+ struct wlr_data_source *source =
+ selection->xwm->seat->selection_source;
+ if (source != NULL) {
+ wlr_data_source_send(source, mime_type, fd);
+ return;
+ }
+ } else if (selection == &selection->xwm->primary_selection) {
+ struct wlr_primary_selection_source *source =
+ selection->xwm->seat->primary_selection_source;
+ if (source != NULL) {
+ source->send(source, mime_type, fd);
+ return;
+ }
+ } else if (selection == &selection->xwm->dnd_selection) {
+ struct wlr_data_source *source =
+ selection->xwm->seat->drag_source;
+ if (source != NULL) {
+ wlr_data_source_send(source, mime_type, fd);
+ return;
+ }
+ }
+
+ wlr_log(L_DEBUG, "not sending selection: no selection source available");
+}
+
+static void xwm_selection_transfer_start_outgoing(
+ struct wlr_xwm_selection_transfer *transfer) {
+ struct wlr_xwm *xwm = transfer->selection->xwm;
+ struct wl_event_loop *loop =
+ wl_display_get_event_loop(xwm->xwayland->wl_display);
+ transfer->source = wl_event_loop_add_fd(loop, transfer->source_fd,
+ WL_EVENT_READABLE, xwm_data_source_read, transfer);
+}
+
+static struct wl_array *xwm_selection_source_get_mime_types(
+ struct wlr_xwm_selection *selection) {
+ if (selection == &selection->xwm->clipboard_selection) {
+ struct wlr_data_source *source =
+ selection->xwm->seat->selection_source;
+ if (source != NULL) {
+ return &source->mime_types;
+ }
+ } else if (selection == &selection->xwm->primary_selection) {
+ struct wlr_primary_selection_source *source =
+ selection->xwm->seat->primary_selection_source;
+ if (source != NULL) {
+ return &source->mime_types;
+ }
+ } else if (selection == &selection->xwm->dnd_selection) {
+ struct wlr_data_source *source =
+ selection->xwm->seat->drag_source;
+ if (source != NULL) {
+ return &source->mime_types;
+ }
+ }
+ return NULL;
+}
+
+/**
+ * Read the Wayland selection and send it to an Xwayland client.
+ */
+static void xwm_selection_send_data(struct wlr_xwm_selection *selection,
+ xcb_selection_request_event_t *req, const char *mime_type) {
+ // Check MIME type
+ struct wl_array *mime_types =
+ xwm_selection_source_get_mime_types(selection);
+ if (mime_types == NULL) {
+ wlr_log(L_ERROR, "not sending selection: no MIME type list available");
+ xwm_selection_send_notify(selection->xwm, req, false);
+ return;
+ }
+
+ bool found = false;
+ char **mime_type_ptr;
+ wl_array_for_each(mime_type_ptr, mime_types) {
+ char *t = *mime_type_ptr;
+ if (strcmp(t, mime_type) == 0) {
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ wlr_log(L_ERROR, "not sending selection: "
+ "requested an unsupported MIME type %s", mime_type);
+ xwm_selection_send_notify(selection->xwm, req, false);
+ return;
+ }
+
+ struct wlr_xwm_selection_transfer *transfer =
+ calloc(1, sizeof(struct wlr_xwm_selection_transfer));
+ if (transfer == NULL) {
+ wlr_log(L_ERROR, "Allocation failed");
+ return;
+ }
+ transfer->selection = selection;
+ transfer->request = *req;
+ wl_array_init(&transfer->source_data);
+
+ int p[2];
+ if (pipe(p) == -1) {
+ wlr_log(L_ERROR, "pipe() failed: %m");
+ xwm_selection_send_notify(selection->xwm, req, false);
+ return;
+ }
+ fcntl(p[0], F_SETFD, FD_CLOEXEC);
+ fcntl(p[0], F_SETFL, O_NONBLOCK);
+ fcntl(p[1], F_SETFD, FD_CLOEXEC);
+ fcntl(p[1], F_SETFL, O_NONBLOCK);
+
+ transfer->source_fd = p[0];
+
+ wlr_log(L_DEBUG, "Sending Wayland selection %u to Xwayland window with "
+ "MIME type %s, target %u", req->target, mime_type, req->target);
+ xwm_selection_source_send(selection, mime_type, p[1]);
+
+ wl_list_insert(&selection->outgoing, &transfer->outgoing_link);
+
+ // We can only handle one transfer at a time
+ if (wl_list_length(&selection->outgoing) == 1) {
+ xwm_selection_transfer_start_outgoing(transfer);
+ }
+}
+
+static void xwm_selection_send_targets(struct wlr_xwm_selection *selection,
+ xcb_selection_request_event_t *req) {
+ struct wlr_xwm *xwm = selection->xwm;
+
+ struct wl_array *mime_types =
+ xwm_selection_source_get_mime_types(selection);
+ if (mime_types == NULL) {
+ wlr_log(L_ERROR, "not sending selection targets: "
+ "no selection source available");
+ xwm_selection_send_notify(selection->xwm, req, false);
+ return;
+ }
+
+ size_t n = 2 + mime_types->size / sizeof(char *);
+ xcb_atom_t targets[n];
+ targets[0] = xwm->atoms[TIMESTAMP];
+ targets[1] = xwm->atoms[TARGETS];
+
+ size_t i = 0;
+ char **mime_type_ptr;
+ wl_array_for_each(mime_type_ptr, mime_types) {
+ char *mime_type = *mime_type_ptr;
+ targets[2+i] = xwm_mime_type_to_atom(xwm, mime_type);
+ ++i;
+ }
+
+ xcb_change_property(xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ req->requestor,
+ req->property,
+ XCB_ATOM_ATOM,
+ 32, // format
+ n, targets);
+
+ xwm_selection_send_notify(selection->xwm, req, true);
+}
+
+static void xwm_selection_send_timestamp(struct wlr_xwm_selection *selection,
+ xcb_selection_request_event_t *req) {
+ xcb_change_property(selection->xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ req->requestor,
+ req->property,
+ XCB_ATOM_INTEGER,
+ 32, // format
+ 1, &selection->timestamp);
+
+ xwm_selection_send_notify(selection->xwm, req, true);
+}
+
+void xwm_handle_selection_request(struct wlr_xwm *xwm,
+ xcb_selection_request_event_t *req) {
+ wlr_log(L_DEBUG, "XCB_SELECTION_REQUEST (time=%u owner=%u, requestor=%u "
+ "selection=%u, target=%u, property=%u)",
+ req->time, req->owner, req->requestor, req->selection, req->target,
+ req->property);
+
+ if (req->selection == xwm->atoms[CLIPBOARD_MANAGER]) {
+ // The wlroots clipboard should already have grabbed the first target,
+ // so just send selection notify now. This isn't synchronized with the
+ // clipboard finishing getting the data, so there's a race here.
+ xwm_selection_send_notify(xwm, req, true);
+ return;
+ }
+
+ struct wlr_xwm_selection *selection =
+ xwm_get_selection(xwm, req->selection);
+ if (selection == NULL) {
+ wlr_log(L_DEBUG, "received selection request for unknown selection");
+ return;
+ }
+
+ if (selection->window != req->owner) {
+ wlr_log(L_DEBUG, "received selection request with invalid owner");
+ return;
+ }
+
+ // No xwayland surface focused, deny access to clipboard
+ if (xwm->focus_surface == NULL && xwm->drag_focus == NULL) {
+ char *selection_name = xwm_get_atom_name(xwm, selection->atom);
+ wlr_log(L_DEBUG, "denying read access to selection %u (%s): "
+ "no xwayland surface focused", selection->atom, selection_name);
+ free(selection_name);
+ xwm_selection_send_notify(xwm, req, false);
+ return;
+ }
+
+ if (req->target == xwm->atoms[TARGETS]) {
+ xwm_selection_send_targets(selection, req);
+ } else if (req->target == xwm->atoms[TIMESTAMP]) {
+ xwm_selection_send_timestamp(selection, req);
+ } else if (req->target == xwm->atoms[DELETE]) {
+ xwm_selection_send_notify(selection->xwm, req, true);
+ } else {
+ // Send data
+ char *mime_type = xwm_mime_type_from_atom(xwm, req->target);
+ if (mime_type == NULL) {
+ wlr_log(L_ERROR, "ignoring selection request: unknown atom %u",
+ req->target);
+ xwm_selection_send_notify(xwm, req, false);
+ return;
+ }
+ xwm_selection_send_data(selection, req, mime_type);
+ free(mime_type);
+ }
+}
diff --git a/xwayland/selection/selection.c b/xwayland/selection/selection.c
new file mode 100644
index 00000000..39c47c45
--- /dev/null
+++ b/xwayland/selection/selection.c
@@ -0,0 +1,319 @@
+#define _XOPEN_SOURCE 700
+#include <assert.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wlr/types/wlr_data_device.h>
+#include <wlr/types/wlr_primary_selection.h>
+#include <wlr/util/log.h>
+#include <xcb/xfixes.h>
+#include "xwayland/xwm.h"
+#include "xwayland/selection.h"
+
+void xwm_selection_transfer_remove_source(
+ struct wlr_xwm_selection_transfer *transfer) {
+ if (transfer->source != NULL) {
+ wl_event_source_remove(transfer->source);
+ transfer->source = NULL;
+ }
+}
+
+void xwm_selection_transfer_close_source_fd(
+ struct wlr_xwm_selection_transfer *transfer) {
+ if (transfer->source_fd >= 0) {
+ close(transfer->source_fd);
+ transfer->source_fd = -1;
+ }
+}
+
+void xwm_selection_transfer_destroy_property_reply(
+ struct wlr_xwm_selection_transfer *transfer) {
+ free(transfer->property_reply);
+ transfer->property_reply = NULL;
+}
+
+xcb_atom_t xwm_mime_type_to_atom(struct wlr_xwm *xwm, char *mime_type) {
+ if (strcmp(mime_type, "text/plain;charset=utf-8") == 0) {
+ return xwm->atoms[UTF8_STRING];
+ } else if (strcmp(mime_type, "text/plain") == 0) {
+ return xwm->atoms[TEXT];
+ }
+
+ xcb_intern_atom_cookie_t cookie =
+ xcb_intern_atom(xwm->xcb_conn, 0, strlen(mime_type), mime_type);
+ xcb_intern_atom_reply_t *reply =
+ xcb_intern_atom_reply(xwm->xcb_conn, cookie, NULL);
+ if (reply == NULL) {
+ return XCB_ATOM_NONE;
+ }
+ xcb_atom_t atom = reply->atom;
+ free(reply);
+ return atom;
+}
+
+char *xwm_mime_type_from_atom(struct wlr_xwm *xwm, xcb_atom_t atom) {
+ if (atom == xwm->atoms[UTF8_STRING]) {
+ return strdup("text/plain;charset=utf-8");
+ } else if (atom == xwm->atoms[TEXT]) {
+ return strdup("text/plain");
+ } else {
+ return xwm_get_atom_name(xwm, atom);
+ }
+}
+
+struct wlr_xwm_selection *xwm_get_selection(struct wlr_xwm *xwm,
+ xcb_atom_t selection_atom) {
+ if (selection_atom == xwm->atoms[CLIPBOARD]) {
+ return &xwm->clipboard_selection;
+ } else if (selection_atom == xwm->atoms[PRIMARY]) {
+ return &xwm->primary_selection;
+ } else if (selection_atom == xwm->atoms[DND_SELECTION]) {
+ return &xwm->dnd_selection;
+ } else {
+ return NULL;
+ }
+}
+
+static int xwm_handle_selection_property_notify(struct wlr_xwm *xwm,
+ xcb_property_notify_event_t *event) {
+ struct wlr_xwm_selection *selections[] = {
+ &xwm->clipboard_selection,
+ &xwm->primary_selection,
+ &xwm->dnd_selection,
+ };
+
+ for (size_t i = 0; i < sizeof(selections)/sizeof(selections[0]); ++i) {
+ struct wlr_xwm_selection *selection = selections[i];
+
+ if (event->window == selection->window) {
+ if (event->state == XCB_PROPERTY_NEW_VALUE &&
+ event->atom == xwm->atoms[WL_SELECTION] &&
+ selection->incoming.incr) {
+ xwm_get_incr_chunk(&selection->incoming);
+ }
+ return 1;
+ }
+
+ struct wlr_xwm_selection_transfer *outgoing;
+ wl_list_for_each(outgoing, &selection->outgoing, outgoing_link) {
+ if (event->window == outgoing->request.requestor) {
+ if (event->state == XCB_PROPERTY_DELETE &&
+ event->atom == outgoing->request.property &&
+ outgoing->incr) {
+ xwm_send_incr_chunk(outgoing);
+ }
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int xwm_handle_selection_event(struct wlr_xwm *xwm,
+ xcb_generic_event_t *event) {
+ if (xwm->seat == NULL) {
+ wlr_log(L_DEBUG, "not handling selection events: "
+ "no seat assigned to xwayland");
+ return 0;
+ }
+
+ switch (event->response_type & XCB_EVENT_RESPONSE_TYPE_MASK) {
+ case XCB_SELECTION_NOTIFY:
+ xwm_handle_selection_notify(xwm, (xcb_selection_notify_event_t *)event);
+ return 1;
+ case XCB_PROPERTY_NOTIFY:
+ return xwm_handle_selection_property_notify(xwm,
+ (xcb_property_notify_event_t *)event);
+ case XCB_SELECTION_REQUEST:
+ xwm_handle_selection_request(xwm,
+ (xcb_selection_request_event_t *)event);
+ return 1;
+ }
+
+ switch (event->response_type - xwm->xfixes->first_event) {
+ case XCB_XFIXES_SELECTION_NOTIFY:
+ // an X11 window has copied something to the clipboard
+ return xwm_handle_xfixes_selection_notify(xwm,
+ (xcb_xfixes_selection_notify_event_t *)event);
+ }
+
+ return 0;
+}
+
+static void selection_init(struct wlr_xwm *xwm,
+ struct wlr_xwm_selection *selection, xcb_atom_t atom) {
+ selection->xwm = xwm;
+ selection->atom = atom;
+ selection->window = xwm->selection_window;
+ selection->incoming.selection = selection;
+ wl_list_init(&selection->outgoing);
+
+ uint32_t mask =
+ XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
+ XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
+ XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
+ xcb_xfixes_select_selection_input(xwm->xcb_conn, selection->window,
+ selection->atom, mask);
+}
+
+void xwm_selection_init(struct wlr_xwm *xwm) {
+ // Clipboard and primary selection
+ uint32_t selection_values[] = {
+ XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE
+ };
+ xwm->selection_window = xcb_generate_id(xwm->xcb_conn);
+ xcb_create_window(xwm->xcb_conn,
+ XCB_COPY_FROM_PARENT,
+ xwm->selection_window,
+ xwm->screen->root,
+ 0, 0,
+ 10, 10,
+ 0,
+ XCB_WINDOW_CLASS_INPUT_OUTPUT,
+ xwm->screen->root_visual,
+ XCB_CW_EVENT_MASK, selection_values);
+
+ xcb_set_selection_owner(xwm->xcb_conn,
+ xwm->selection_window,
+ xwm->atoms[CLIPBOARD_MANAGER],
+ XCB_TIME_CURRENT_TIME);
+
+ selection_init(xwm, &xwm->clipboard_selection, xwm->atoms[CLIPBOARD]);
+ selection_init(xwm, &xwm->primary_selection, xwm->atoms[PRIMARY]);
+
+ // Drag'n'drop
+ uint32_t dnd_values[] = {
+ XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE
+ };
+ xwm->dnd_window = xcb_generate_id(xwm->xcb_conn);
+ xcb_create_window(xwm->xcb_conn,
+ XCB_COPY_FROM_PARENT,
+ xwm->dnd_window,
+ xwm->screen->root,
+ 0, 0,
+ 8192, 8192,
+ 0,
+ XCB_WINDOW_CLASS_INPUT_ONLY,
+ xwm->screen->root_visual,
+ XCB_CW_EVENT_MASK, dnd_values);
+
+ uint32_t version = XDND_VERSION;
+ xcb_change_property(xwm->xcb_conn,
+ XCB_PROP_MODE_REPLACE,
+ xwm->dnd_window,
+ xwm->atoms[DND_AWARE],
+ XCB_ATOM_ATOM,
+ 32, // format
+ 1, &version);
+
+ selection_init(xwm, &xwm->dnd_selection, xwm->atoms[DND_SELECTION]);
+}
+
+void xwm_selection_finish(struct wlr_xwm *xwm) {
+ if (!xwm) {
+ return;
+ }
+ if (xwm->selection_window) {
+ xcb_destroy_window(xwm->xcb_conn, xwm->selection_window);
+ }
+ if (xwm->dnd_window) {
+ xcb_destroy_window(xwm->xcb_conn, xwm->dnd_window);
+ }
+ if (xwm->seat) {
+ if (xwm->seat->selection_source &&
+ wlr_data_source_is_xwayland_data_source(
+ xwm->seat->selection_source)) {
+ wlr_seat_set_selection(xwm->seat, NULL,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ }
+ if (xwm->seat->primary_selection_source &&
+ wlr_primary_selection_source_is_xwayland_primary_selection_source(
+ xwm->seat->primary_selection_source)) {
+ wlr_seat_set_primary_selection(xwm->seat, NULL,
+ wl_display_next_serial(xwm->xwayland->wl_display));
+ }
+ wlr_xwayland_set_seat(xwm->xwayland, NULL);
+ }
+}
+
+static void xwm_selection_set_owner(struct wlr_xwm_selection *selection,
+ bool set) {
+ if (set) {
+ xcb_set_selection_owner(selection->xwm->xcb_conn,
+ selection->window,
+ selection->atom,
+ XCB_TIME_CURRENT_TIME);
+ } else {
+ if (selection->owner == selection->window) {
+ xcb_set_selection_owner(selection->xwm->xcb_conn,
+ XCB_WINDOW_NONE,
+ selection->atom,
+ selection->timestamp);
+ }
+ }
+}
+
+static void seat_handle_selection(struct wl_listener *listener,
+ void *data) {
+ struct wlr_seat *seat = data;
+ struct wlr_xwm *xwm =
+ wl_container_of(listener, xwm, seat_selection);
+ struct wlr_data_source *source = seat->selection_source;
+
+ if (source != NULL && wlr_data_source_is_xwayland_data_source(source)) {
+ return;
+ }
+
+ xwm_selection_set_owner(&xwm->clipboard_selection, source != NULL);
+}
+
+static void seat_handle_primary_selection(struct wl_listener *listener,
+ void *data) {
+ struct wlr_seat *seat = data;
+ struct wlr_xwm *xwm =
+ wl_container_of(listener, xwm, seat_primary_selection);
+ struct wlr_primary_selection_source *source = seat->primary_selection_source;
+
+ if (source != NULL &&
+ wlr_primary_selection_source_is_xwayland_primary_selection_source(
+ source)) {
+ return;
+ }
+
+ xwm_selection_set_owner(&xwm->primary_selection, source != NULL);
+}
+
+static void seat_handle_start_drag(struct wl_listener *listener, void *data) {
+ struct wlr_xwm *xwm = wl_container_of(listener, xwm, seat_start_drag);
+ struct wlr_drag *drag = data;
+
+ xwm_selection_set_owner(&xwm->dnd_selection, drag != NULL);
+ xwm_seat_handle_start_drag(xwm, drag);
+}
+
+void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat) {
+ if (xwm->seat != NULL) {
+ wl_list_remove(&xwm->seat_selection.link);
+ wl_list_remove(&xwm->seat_primary_selection.link);
+ wl_list_remove(&xwm->seat_start_drag.link);
+ xwm->seat = NULL;
+ }
+
+ if (seat == NULL) {
+ return;
+ }
+
+ xwm->seat = seat;
+
+ wl_signal_add(&seat->events.selection, &xwm->seat_selection);
+ xwm->seat_selection.notify = seat_handle_selection;
+ wl_signal_add(&seat->events.primary_selection, &xwm->seat_primary_selection);
+ xwm->seat_primary_selection.notify = seat_handle_primary_selection;
+ wl_signal_add(&seat->events.start_drag, &xwm->seat_start_drag);
+ xwm->seat_start_drag.notify = seat_handle_start_drag;
+
+ seat_handle_selection(&xwm->seat_selection, seat);
+ seat_handle_primary_selection(&xwm->seat_primary_selection, seat);
+}
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 4fa7d311..c2b9bd11 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -51,12 +51,27 @@ const char *atom_map[ATOM_LAST] = {
"INCR",
"TEXT",
"TIMESTAMP",
+ "DELETE",
"_NET_WM_WINDOW_TYPE_UTILITY",
"_NET_WM_WINDOW_TYPE_TOOLTIP",
"_NET_WM_WINDOW_TYPE_DND",
"_NET_WM_WINDOW_TYPE_DROPDOWN_MENU",
"_NET_WM_WINDOW_TYPE_POPUP_MENU",
"_NET_WM_WINDOW_TYPE_COMBO",
+ "XdndSelection",
+ "XdndAware",
+ "XdndStatus",
+ "XdndPosition",
+ "XdndEnter",
+ "XdndLeave",
+ "XdndDrop",
+ "XdndFinished",
+ "XdndProxy",
+ "XdndTypeList",
+ "XdndActionMove",
+ "XdndActionCopy",
+ "XdndActionAsk",
+ "XdndActionPrivate",
};
const char *wlr_xwayland_surface_role = "wlr_xwayland_surface";
@@ -71,7 +86,6 @@ struct wlr_xwayland_surface *wlr_xwayland_surface_from_wlr_surface(
return (struct wlr_xwayland_surface *)surface->role_data;
}
-/* General helpers */
// TODO: replace this with hash table?
static struct wlr_xwayland_surface *lookup_surface(struct wlr_xwm *xwm,
xcb_window_t window_id) {
@@ -506,6 +520,21 @@ static void read_surface_net_wm_state(struct wlr_xwm *xwm,
}
}
+char *xwm_get_atom_name(struct wlr_xwm *xwm, xcb_atom_t atom) {
+ xcb_get_atom_name_cookie_t name_cookie =
+ xcb_get_atom_name(xwm->xcb_conn, atom);
+ xcb_get_atom_name_reply_t *name_reply =
+ xcb_get_atom_name_reply(xwm->xcb_conn, name_cookie, NULL);
+ if (name_reply == NULL) {
+ return NULL;
+ }
+ size_t len = xcb_get_atom_name_name_length(name_reply);
+ char *buf = xcb_get_atom_name_name(name_reply); // not a C string
+ char *name = strndup(buf, len);
+ free(name_reply);
+ return name;
+}
+
static void read_surface_property(struct wlr_xwm *xwm,
struct wlr_xwayland_surface *xsurface, xcb_atom_t property) {
xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn, 0,
@@ -538,7 +567,10 @@ static void read_surface_property(struct wlr_xwm *xwm,
} else if (property == xwm->atoms[MOTIF_WM_HINTS]) {
read_surface_motif_hints(xwm, xsurface, reply);
} else {
- wlr_log(L_DEBUG, "unhandled x11 property %u", property);
+ char *prop_name = xwm_get_atom_name(xwm, property);
+ wlr_log(L_DEBUG, "unhandled X11 property %u (%s) for window %u",
+ property, prop_name, xsurface->window_id);
+ free(prop_name);
}
free(reply);
@@ -944,8 +976,11 @@ static void xwm_handle_client_message(struct wlr_xwm *xwm,
xwm_handle_net_wm_state_message(xwm, ev);
} else if (ev->type == xwm->atoms[_NET_WM_MOVERESIZE]) {
xwm_handle_net_wm_moveresize_message(xwm, ev);
- } else {
- wlr_log(L_DEBUG, "unhandled x11 client message %u", ev->type);
+ } else if (!xwm_handle_selection_client_message(xwm, ev)) {
+ char *type_name = xwm_get_atom_name(xwm, ev->type);
+ wlr_log(L_DEBUG, "unhandled x11 client message %u (%s)", ev->type,
+ type_name);
+ free(type_name);
}
}
@@ -1020,10 +1055,6 @@ static void xwm_handle_unhandled_event(struct wlr_xwm *xwm, xcb_generic_event_t
#endif
}
-/* This is in xcb/xcb_event.h, but pulling xcb-util just for a constant
- * others redefine anyway is meh
- */
-#define XCB_EVENT_RESPONSE_TYPE_MASK (0x7f)
static int x11_event_handler(int fd, uint32_t mask, void *data) {
int count = 0;
xcb_generic_event_t *event;