Implement xwayland primary selection sync

include/wlr/types/wlr_data_device.h

@@ -34,6 +34,7 @@ struct wlr_data_source {
 	struct wl_resource *resource;
 	struct wlr_data_offer *offer;
 	struct wlr_seat_client *seat_client;
+
 	struct wl_array mime_types;
 
 	bool accepted;
@@ -123,4 +124,6 @@ void wlr_seat_client_send_selection(struct wlr_seat_client *seat_client);
 void wlr_seat_set_selection(struct wlr_seat *seat,
 		struct wlr_data_source *source, uint32_t serial);
 
+void wlr_data_source_init(struct wlr_data_source *source);
+
 #endif

include/wlr/types/wlr_primary_selection.h

@@ -48,6 +48,9 @@ void wlr_primary_selection_device_manager_destroy(
 
 void wlr_seat_client_send_primary_selection(struct wlr_seat_client *seat_client);
 void wlr_seat_set_primary_selection(struct wlr_seat *seat,
-		struct wlr_primary_selection_source *source, uint32_t serial);
+	struct wlr_primary_selection_source *source, uint32_t serial);
+
+void wlr_primary_selection_source_init(
+	struct wlr_primary_selection_source *source);
 
 #endif

include/wlr/xwm.h

@@ -32,6 +32,7 @@ enum atom_name {
 	_NET_WM_STATE_MAXIMIZED_HORZ,
 	WM_STATE,
 	CLIPBOARD,
+	PRIMARY,
 	WL_SELECTION,
 	TARGETS,
 	CLIPBOARD_MANAGER,
@@ -49,6 +50,24 @@ 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;
@@ -63,20 +82,9 @@ struct wlr_xwm {
 	xcb_render_pictformat_t render_format_id;
 	xcb_cursor_t cursor;
 
-	// selection properties
 	xcb_window_t selection_window;
-	xcb_selection_request_event_t selection_request;
+	struct wlr_xwm_selection clipboard_selection;
-	xcb_window_t selection_owner;
+	struct wlr_xwm_selection primary_selection;
-	xcb_timestamp_t selection_timestamp;
-	int incr;
-	int data_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 selection_target;
-	bool selection_property_set;
 
 	struct wlr_xwayland_surface *focus_surface;
 
@@ -86,7 +94,8 @@ struct wlr_xwm {
 	const xcb_query_extension_reply_t *xfixes;
 
 	struct wl_listener compositor_surface_create;
-	struct wl_listener seat_selection_change;
+	struct wl_listener seat_selection;
+	struct wl_listener seat_primary_selection;
 };
 
 struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland);

types/wlr_data_device.c

@@ -927,6 +927,11 @@ static struct wl_data_source_interface data_source_impl = {
 	.set_actions = data_source_set_actions,
 };
 
+void wlr_data_source_init(struct wlr_data_source *source) {
+	wl_array_init(&source->mime_types);
+	wl_signal_init(&source->events.destroy);
+}
+
 static void data_device_manager_create_data_source(struct wl_client *client,
 		struct wl_resource *resource, uint32_t id) {
 	struct wlr_data_source *source = calloc(1, sizeof(struct wlr_data_source));
@@ -934,25 +939,21 @@ static void data_device_manager_create_data_source(struct wl_client *client,
 		wl_resource_post_no_memory(resource);
 		return;
 	}
+	wlr_data_source_init(source);
 
-	source->resource =
+	source->resource = wl_resource_create(client, &wl_data_source_interface,
-		wl_resource_create(client, &wl_data_source_interface,
+		wl_resource_get_version(resource), id);
-			wl_resource_get_version(resource), id);
 	if (source->resource == NULL) {
 		free(source);
 		wl_resource_post_no_memory(resource);
 		return;
 	}
+	wl_resource_set_implementation(source->resource, &data_source_impl,
+		source, data_source_resource_destroy);
 
 	source->accept = client_data_source_accept;
 	source->send = client_data_source_send;
 	source->cancel = client_data_source_cancel;
-
-	wl_array_init(&source->mime_types);
-	wl_signal_init(&source->events.destroy);
-
-	wl_resource_set_implementation(source->resource, &data_source_impl,
-		source, data_source_resource_destroy);
 }
 
 static const struct wl_data_device_manager_interface

types/wlr_primary_selection.c

@@ -262,6 +262,12 @@ static void device_resource_handle_destroy(struct wl_resource *resource) {
 }
 
 
+void wlr_primary_selection_source_init(
+		struct wlr_primary_selection_source *source) {
+	wl_array_init(&source->mime_types);
+	wl_signal_init(&source->events.destroy);
+}
+
 static void device_manager_handle_create_source(struct wl_client *client,
 		struct wl_resource *manager_resource, uint32_t id) {
 	struct wlr_primary_selection_source *source =
@@ -270,6 +276,7 @@ static void device_manager_handle_create_source(struct wl_client *client,
 		wl_client_post_no_memory(client);
 		return;
 	}
+	wlr_primary_selection_source_init(source);
 
 	int version = wl_resource_get_version(manager_resource);
 	source->resource = wl_resource_create(client,
@@ -284,9 +291,6 @@ static void device_manager_handle_create_source(struct wl_client *client,
 
 	source->send = client_source_send;
 	source->cancel = client_source_cancel;
-
-	wl_array_init(&source->mime_types);
-	wl_signal_init(&source->events.destroy);
 }
 
 void device_manager_handle_get_device(struct wl_client *client,

xwayland/selection.c

@@ -7,131 +7,133 @@
 #include <fcntl.h>
 #include "wlr/util/log.h"
 #include "wlr/types/wlr_data_device.h"
+#include "wlr/types/wlr_primary_selection.h"
 #include "wlr/xwm.h"
 
 static const size_t incr_chunk_size = 64 * 1024;
 
-static void xwm_send_selection_notify(struct wlr_xwm *xwm,
+static void xwm_selection_send_notify(struct wlr_xwm_selection *selection,
 		xcb_atom_t property) {
-	xcb_selection_notify_event_t selection_notify;
+	xcb_selection_notify_event_t selection_notify = {
-
+		.response_type = XCB_SELECTION_NOTIFY,
-	memset(&selection_notify, 0, sizeof selection_notify);
+		.sequence = 0,
-	selection_notify.response_type = XCB_SELECTION_NOTIFY;
+		.time = selection->request.time,
-	selection_notify.sequence = 0;
+		.requestor = selection->request.requestor,
-	selection_notify.time = xwm->selection_request.time;
+		.selection = selection->request.selection,
-	selection_notify.requestor = xwm->selection_request.requestor;
+		.target = selection->request.target,
-	selection_notify.selection = xwm->selection_request.selection;
+		.property = property,
-	selection_notify.target = xwm->selection_request.target;
+	};
-	selection_notify.property = property;
+
-
+	xcb_send_event(selection->xwm->xcb_conn,
-	xcb_send_event(xwm->xcb_conn, 0, // propagate
+		0, // propagate
-		xwm->selection_request.requestor,
+		selection->request.requestor,
-		XCB_EVENT_MASK_NO_EVENT, (char *)&selection_notify);
+		XCB_EVENT_MASK_NO_EVENT,
+		(char *)&selection_notify);
 }
 
-static int xwm_flush_source_data(struct wlr_xwm *xwm)
+static int xwm_selection_flush_source_data(struct wlr_xwm_selection *selection) {
-{
+	xcb_change_property(selection->xwm->xcb_conn,
-	xcb_change_property(xwm->xcb_conn,
 		XCB_PROP_MODE_REPLACE,
-		xwm->selection_request.requestor,
+		selection->request.requestor,
-		xwm->selection_request.property,
+		selection->request.property,
-		xwm->selection_target,
+		selection->target,
 		8, // format
-		xwm->source_data.size,
+		selection->source_data.size,
-		xwm->source_data.data);
+		selection->source_data.data);
-	xwm->selection_property_set = 1;
+	selection->property_set = true;
-	int length = xwm->source_data.size;
+	int length = selection->source_data.size;
-	xwm->source_data.size = 0;
+	selection->source_data.size = 0;
 
 	return length;
 }
 
 static int xwm_read_data_source(int fd, uint32_t mask, void *data) {
-	struct wlr_xwm *xwm = data;
+	struct wlr_xwm_selection *selection = data;
-	void *p;
+	struct wlr_xwm *xwm = selection->xwm;
 
-	int current = xwm->source_data.size;
+	void *p;
-	if (xwm->source_data.size < incr_chunk_size) {
+	int current = selection->source_data.size;
-		p = wl_array_add(&xwm->source_data, incr_chunk_size);
+	if (selection->source_data.size < incr_chunk_size) {
+		p = wl_array_add(&selection->source_data, incr_chunk_size);
 	} else {
-		p = (char *) xwm->source_data.data + xwm->source_data.size;
+		p = (char *) selection->source_data.data + selection->source_data.size;
 	}
 
-	int available = xwm->source_data.alloc - current;
+	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");
-		xwm_send_selection_notify(xwm, XCB_ATOM_NONE);
+		xwm_selection_send_notify(selection, XCB_ATOM_NONE);
-		wl_event_source_remove(xwm->property_source);
+		wl_event_source_remove(selection->property_source);
-		xwm->property_source = NULL;
+		selection->property_source = NULL;
 		close(fd);
-		wl_array_release(&xwm->source_data);
+		wl_array_release(&selection->source_data);
 	}
 
 	wlr_log(L_DEBUG, "read %d (available %d, mask 0x%x) bytes: \"%.*s\"",
 			len, available, mask, len, (char *) p);
 
-	xwm->source_data.size = current + len;
+	selection->source_data.size = current + len;
-	if (xwm->source_data.size >= incr_chunk_size) {
+	if (selection->source_data.size >= incr_chunk_size) {
-		if (!xwm->incr) {
+		if (!selection->incr) {
 			wlr_log(L_DEBUG, "got %zu bytes, starting incr",
-					xwm->source_data.size);
+					selection->source_data.size);
-			xwm->incr = 1;
+			selection->incr = 1;
 			xcb_change_property(xwm->xcb_conn,
 					XCB_PROP_MODE_REPLACE,
-					xwm->selection_request.requestor,
+					selection->request.requestor,
-					xwm->selection_request.property,
+					selection->request.property,
 					xwm->atoms[INCR],
 					32, /* format */
 					1, &incr_chunk_size);
-			xwm->selection_property_set = 1;
+			selection->property_set = true;
-			xwm->flush_property_on_delete = 1;
+			selection->flush_property_on_delete = 1;
-			wl_event_source_remove(xwm->property_source);
+			wl_event_source_remove(selection->property_source);
-			xwm->property_source = NULL;
+			selection->property_source = NULL;
-			xwm_send_selection_notify(xwm, xwm->selection_request.property);
+			xwm_selection_send_notify(selection, selection->request.property);
-		} else if (xwm->selection_property_set) {
+		} else if (selection->property_set) {
 			wlr_log(L_DEBUG, "got %zu bytes, waiting for "
-				"property delete", xwm->source_data.size);
+				"property delete", selection->source_data.size);
 
-			xwm->flush_property_on_delete = 1;
+			selection->flush_property_on_delete = 1;
-			wl_event_source_remove(xwm->property_source);
+			wl_event_source_remove(selection->property_source);
-			xwm->property_source = NULL;
+			selection->property_source = NULL;
 		} else {
 			wlr_log(L_DEBUG, "got %zu bytes, "
 				"property deleted, setting new property",
-				xwm->source_data.size);
+				selection->source_data.size);
-			xwm_flush_source_data(xwm);
+			xwm_selection_flush_source_data(selection);
 		}
-	} else if (len == 0 && !xwm->incr) {
+	} else if (len == 0 && !selection->incr) {
 		wlr_log(L_DEBUG, "non-incr transfer complete");
 		/* Non-incr transfer all done. */
-		xwm_flush_source_data(xwm);
+		xwm_selection_flush_source_data(selection);
-		xwm_send_selection_notify(xwm, xwm->selection_request.property);
+		xwm_selection_send_notify(selection, selection->request.property);
 		xcb_flush(xwm->xcb_conn);
-		wl_event_source_remove(xwm->property_source);
+		wl_event_source_remove(selection->property_source);
-		xwm->property_source = NULL;
+		selection->property_source = NULL;
 		close(fd);
-		wl_array_release(&xwm->source_data);
+		wl_array_release(&selection->source_data);
-		xwm->selection_request.requestor = XCB_NONE;
+		selection->request.requestor = XCB_NONE;
-	} else if (len == 0 && xwm->incr) {
+	} else if (len == 0 && selection->incr) {
 		wlr_log(L_DEBUG, "incr transfer complete");
 
-		xwm->flush_property_on_delete = 1;
+		selection->flush_property_on_delete = 1;
-		if (xwm->selection_property_set) {
+		if (selection->property_set) {
 			wlr_log(L_DEBUG, "got %zu bytes, waiting for "
-					"property delete", xwm->source_data.size);
+					"property delete", selection->source_data.size);
 		} else {
 			wlr_log(L_DEBUG, "got %zu bytes, "
 					"property deleted, setting new property",
-					xwm->source_data.size);
+					selection->source_data.size);
-			xwm_flush_source_data(xwm);
+			xwm_selection_flush_source_data(selection);
 		}
 		xcb_flush(xwm->xcb_conn);
-		wl_event_source_remove(xwm->property_source);
+		wl_event_source_remove(selection->property_source);
-		xwm->property_source = NULL;
+		selection->property_source = NULL;
-		close(xwm->data_source_fd);
+		close(selection->source_fd);
-		xwm->data_source_fd = -1;
+		selection->source_fd = -1;
 		close(fd);
 	} else {
 		wlr_log(L_DEBUG, "nothing happened, buffered the bytes");
@@ -140,14 +142,28 @@ static int xwm_read_data_source(int fd, uint32_t mask, void *data) {
 	return 1;
 }
 
-static void xwm_send_data(struct wlr_xwm *xwm, xcb_atom_t target,
+static void xwm_selection_source_send(struct wlr_xwm_selection *selection,
-		const char *mime_type) {
+		const char *mime_type, int32_t fd) {
-	struct wlr_data_source *source;
+	if (selection == &selection->xwm->clipboard_selection) {
-	int p[2];
+		struct wlr_data_source *source = selection->xwm->seat->selection_source;
+		if (source != NULL) {
+			source->send(source, mime_type, fd);
+		}
+	} 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);
+		}
+	}
+}
 
+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_send_selection_notify(xwm, XCB_ATOM_NONE);
+		xwm_selection_send_notify(selection, XCB_ATOM_NONE);
 		return;
 	}
 
@@ -156,37 +172,59 @@ static void xwm_send_data(struct wlr_xwm *xwm, xcb_atom_t target,
 	fcntl(p[1], F_SETFD, FD_CLOEXEC);
 	fcntl(p[1], F_SETFL, O_NONBLOCK);
 
-	wl_array_init(&xwm->source_data);
+	wl_array_init(&selection->source_data);
-	xwm->selection_target = target;
+	selection->target = target;
-	xwm->data_source_fd = p[0];
+	selection->source_fd = p[0];
 	struct wl_event_loop *loop =
-		wl_display_get_event_loop(xwm->xwayland->wl_display);
+		wl_display_get_event_loop(selection->xwm->xwayland->wl_display);
-	xwm->property_source = wl_event_loop_add_fd(loop,
+	selection->property_source = wl_event_loop_add_fd(loop,
-		xwm->data_source_fd,
+		selection->source_fd,
 		WL_EVENT_READABLE,
 		xwm_read_data_source,
-		xwm);
+		selection);
 
-	source = xwm->seat->selection_source;
+	xwm_selection_source_send(selection, mime_type, p[1]);
-	source->send(source, mime_type, p[1]);
 	close(p[1]);
 }
 
-static void xwm_send_timestamp(struct wlr_xwm *xwm) {
+static void xwm_selection_send_timestamp(struct wlr_xwm_selection *selection) {
-	xcb_change_property(xwm->xcb_conn,
+	xcb_change_property(selection->xwm->xcb_conn,
 		XCB_PROP_MODE_REPLACE,
-		xwm->selection_request.requestor,
+		selection->request.requestor,
-		xwm->selection_request.property,
+		selection->request.property,
 		XCB_ATOM_INTEGER,
 		32, // format
-		1, &xwm->selection_timestamp);
+		1, &selection->timestamp);
 
-	xwm_send_selection_notify(xwm, xwm->selection_request.property);
+	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_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_send_targets(struct wlr_xwm *xwm) {
+static void xwm_selection_send_targets(struct wlr_xwm_selection *selection) {
-	struct wlr_data_source *source = xwm->seat->selection_source;
+	struct wlr_xwm *xwm = selection->xwm;
-	size_t n = 2 + source->mime_types.size / sizeof(char *);
+
+	struct wl_array *mime_types = xwm_selection_source_get_mime_types(selection);
+	if (mime_types == NULL) {
+		return;
+	}
+
+	size_t n = 2 + mime_types->size / sizeof(char *);
 	xcb_atom_t *targets = malloc(n * sizeof(xcb_atom_t));
 	if (targets == NULL) {
 		return;
@@ -196,7 +234,7 @@ static void xwm_send_targets(struct wlr_xwm *xwm) {
 
 	size_t i = 2;
 	char **mime_type_ptr;
-	wl_array_for_each(mime_type_ptr, &source->mime_types) {
+	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) {
@@ -221,44 +259,60 @@ static void xwm_send_targets(struct wlr_xwm *xwm) {
 
 	xcb_change_property(xwm->xcb_conn,
 		XCB_PROP_MODE_REPLACE,
-		xwm->selection_request.requestor,
+		selection->request.requestor,
-		xwm->selection_request.property,
+		selection->request.property,
 		XCB_ATOM_ATOM,
 		32, // format
 		n, targets);
 
-	xwm_send_selection_notify(xwm, xwm->selection_request.property);
+	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;
 
-	if (selection_request->selection != xwm->atoms[CLIPBOARD]) {
+	if (selection_request->selection == xwm->atoms[CLIPBOARD_MANAGER]) {
-		xwm_send_selection_notify(xwm, XCB_ATOM_NONE);
+		// 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;
 	}
 
-	xwm->selection_request = *selection_request;
+	struct wlr_xwm_selection *selection =
-	xwm->incr = 0;
+		xwm_get_selection(xwm, selection_request->selection);
-	xwm->flush_property_on_delete = 0;
+	if (selection == NULL) {
-
+		xwm_selection_send_notify(selection, XCB_ATOM_NONE);
-	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.
-		xwm_send_selection_notify(xwm, xwm->selection_request.property);
 		return;
 	}
 
+	selection->request = *selection_request;
+	selection->incr = 0;
+	selection->flush_property_on_delete = 0;
+
 	if (xwm->seat->selection_source == NULL) {
 		wlr_log(L_DEBUG, "not handling selection request: "
 			"no selection source assigned to xwayland seat");
-		xwm_send_selection_notify(xwm, XCB_ATOM_NONE);
+		xwm_selection_send_notify(selection, XCB_ATOM_NONE);
 		return;
 	}
 
@@ -266,18 +320,20 @@ static void xwm_handle_selection_request(struct wlr_xwm *xwm,
 	if (xwm->focus_surface == NULL) {
 		wlr_log(L_DEBUG, "denying read access to clipboard: "
 			"no xwayland surface focused");
-		xwm_send_selection_notify(xwm, XCB_ATOM_NONE);
+		xwm_selection_send_notify(selection, XCB_ATOM_NONE);
 		return;
 	}
 
 	if (selection_request->target == xwm->atoms[TARGETS]) {
-		xwm_send_targets(xwm);
+		xwm_selection_send_targets(selection);
 	} else if (selection_request->target == xwm->atoms[TIMESTAMP]) {
-		xwm_send_timestamp(xwm);
+		xwm_selection_send_timestamp(selection);
 	} else if (selection_request->target == xwm->atoms[UTF8_STRING]) {
-		xwm_send_data(xwm, selection_request->target, "text/plain;charset=utf-8");
+		xwm_selection_send_data(selection, selection_request->target,
+			"text/plain;charset=utf-8");
 	} else if (selection_request->target == xwm->atoms[TEXT]) {
-		xwm_send_data(xwm, selection_request->target, "text/plain");
+		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);
@@ -285,7 +341,7 @@ static void xwm_handle_selection_request(struct wlr_xwm *xwm,
 			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_send_selection_notify(xwm, XCB_ATOM_NONE);
+			xwm_selection_send_notify(selection, XCB_ATOM_NONE);
 			return;
 		}
 		size_t len = xcb_get_atom_name_name_length(name_reply);
@@ -296,48 +352,49 @@ static void xwm_handle_selection_request(struct wlr_xwm *xwm,
 		}
 		memcpy(mime_type, xcb_get_atom_name_name(name_reply), len);
 		mime_type[len] = '\0';
-		xwm_send_data(xwm, selection_request->target, mime_type);
+		xwm_selection_send_data(selection, selection_request->target, mime_type);
 		free(mime_type);
 		free(name_reply);
 	}
 }
 
 static int writable_callback(int fd, uint32_t mask, void *data) {
-	struct wlr_xwm *xwm = data;
+	struct wlr_xwm_selection *selection = data;
+	struct wlr_xwm *xwm = selection->xwm;
 
-	unsigned char *property = xcb_get_property_value(xwm->property_reply);
+	unsigned char *property = xcb_get_property_value(selection->property_reply);
-	int remainder = xcb_get_property_value_length(xwm->property_reply) -
+	int remainder = xcb_get_property_value_length(selection->property_reply) -
-		xwm->property_start;
+		selection->property_start;
 
-	int len = write(fd, property + xwm->property_start, remainder);
+	int len = write(fd, property + selection->property_start, remainder);
 	if (len == -1) {
-		free(xwm->property_reply);
+		free(selection->property_reply);
-		xwm->property_reply = NULL;
+		selection->property_reply = NULL;
-		if (xwm->property_source) {
+		if (selection->property_source) {
-			wl_event_source_remove(xwm->property_source);
+			wl_event_source_remove(selection->property_source);
 		}
-		xwm->property_source = NULL;
+		selection->property_source = NULL;
 		close(fd);
 		wlr_log(L_ERROR, "write error to target fd: %m");
 		return 1;
 	}
 
 	wlr_log(L_DEBUG, "wrote %d (chunk size %d) of %d bytes",
-		xwm->property_start + len,
+		selection->property_start + len,
-		len, xcb_get_property_value_length(xwm->property_reply));
+		len, xcb_get_property_value_length(selection->property_reply));
 
-	xwm->property_start += len;
+	selection->property_start += len;
 	if (len == remainder) {
-		free(xwm->property_reply);
+		free(selection->property_reply);
-		xwm->property_reply = NULL;
+		selection->property_reply = NULL;
-		if (xwm->property_source) {
+		if (selection->property_source) {
-			wl_event_source_remove(xwm->property_source);
+			wl_event_source_remove(selection->property_source);
 		}
-		xwm->property_source = NULL;
+		selection->property_source = NULL;
 
-		if (xwm->incr) {
+		if (selection->incr) {
 			xcb_delete_property(xwm->xcb_conn,
-				xwm->selection_window,
+				selection->window,
 				xwm->atoms[WL_SELECTION]);
 		} else {
 			wlr_log(L_DEBUG, "transfer complete");
@@ -348,86 +405,77 @@ static int writable_callback(int fd, uint32_t mask, void *data) {
 	return 1;
 }
 
-static void xwm_write_property(struct wlr_xwm *xwm,
+static void xwm_write_property(struct wlr_xwm_selection *selection,
 		xcb_get_property_reply_t *reply) {
-	xwm->property_start = 0;
+	selection->property_start = 0;
-	xwm->property_reply = reply;
+	selection->property_reply = reply;
-	writable_callback(xwm->data_source_fd, WL_EVENT_WRITABLE, xwm);
+	writable_callback(selection->source_fd, WL_EVENT_WRITABLE, selection);
 
-	if (xwm->property_reply) {
+	if (selection->property_reply) {
 		struct wl_event_loop *loop =
-			wl_display_get_event_loop(xwm->xwayland->wl_display);
+			wl_display_get_event_loop(selection->xwm->xwayland->wl_display);
-		xwm->property_source =
+		selection->property_source = wl_event_loop_add_fd(loop,
-			wl_event_loop_add_fd(loop,
+			selection->source_fd, WL_EVENT_WRITABLE, writable_callback,
-				xwm->data_source_fd,
+			selection);
-				WL_EVENT_WRITABLE,
-				writable_callback, xwm);
 	}
 }
 
-static void xwm_get_selection_data(struct wlr_xwm *xwm) {
+static void xwm_selection_get_data(struct wlr_xwm_selection *selection) {
-	xcb_get_property_cookie_t cookie =
+	struct wlr_xwm *xwm = selection->xwm;
-		xcb_get_property(xwm->xcb_conn,
+
-			1, // delete
+	xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
-			xwm->selection_window,
+		1, // delete
-			xwm->atoms[WL_SELECTION],
+		selection->window,
-			XCB_GET_PROPERTY_TYPE_ANY,
+		xwm->atoms[WL_SELECTION],
-			0, // offset
+		XCB_GET_PROPERTY_TYPE_ANY,
-			0x1fffffff // length
+		0, // offset
-			);
+		0x1fffffff // length
+		);
 
 	xcb_get_property_reply_t *reply =
 		xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
-
 	if (reply == NULL) {
 		return;
-	} else if (reply->type == xwm->atoms[INCR]) {
+	}
-		xwm->incr = 1;
+
+	if (reply->type == xwm->atoms[INCR]) {
+		selection->incr = 1;
 		free(reply);
 	} else {
-		xwm->incr = 0;
+		selection->incr = 0;
 		// reply's ownership is transferred to wm, which is responsible
 		// for freeing it
-		xwm_write_property(xwm, reply);
+		xwm_write_property(selection, reply);
 	}
 }
 
-struct x11_data_source {
+static void source_send(struct wlr_xwm_selection *selection,
-	struct wlr_data_source base;
+		struct wl_array *mime_types, struct wl_array *mime_types_atoms,
-	struct wlr_xwm *xwm;
-	struct wl_array mime_types_atoms;
-};
-
-static void data_source_accept(struct wlr_data_source *source, uint32_t time,
-		const char *mime_type) {
-}
-
-static void data_source_send(struct wlr_data_source *base,
 		const char *requested_mime_type, int32_t fd) {
-	struct x11_data_source *source = (struct x11_data_source *)base;
+	struct wlr_xwm *xwm = selection->xwm;
-	struct wlr_xwm *xwm = source->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, &source->base.mime_types) {
+	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;
-			xcb_atom_t *atoms = source->mime_types_atoms.data;
 			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,
-		xwm->selection_window,
+		selection->window,
-		xwm->atoms[CLIPBOARD],
+		selection->atom,
 		mime_type_atom,
 		xwm->atoms[WL_SELECTION],
 		XCB_TIME_CURRENT_TIME);
@@ -435,18 +483,62 @@ static void data_source_send(struct wlr_data_source *base,
 	xcb_flush(xwm->xcb_conn);
 
 	fcntl(fd, F_SETFL, O_WRONLY | O_NONBLOCK);
-	xwm->data_source_fd = fd;
+	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 *source) {
+static void data_source_cancel(struct wlr_data_source *base) {
+	// No-op
 }
 
-static void xwm_get_selection_targets(struct wlr_xwm *xwm) {
+struct x11_primary_selection_source {
-	// set the wayland clipboard selection to the copied selection
+	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 *source) {
+	// No-op
+}
+
+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
-		xwm->selection_window,
+		selection->window,
 		xwm->atoms[WL_SELECTION],
 		XCB_GET_PROPERTY_TYPE_ANY,
 		0, // offset
@@ -456,28 +548,14 @@ static void xwm_get_selection_targets(struct wlr_xwm *xwm) {
 	xcb_get_property_reply_t *reply =
 		xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
 	if (reply == NULL) {
-		return;
+		return false;
 	}
 
 	if (reply->type != XCB_ATOM_ATOM) {
 		free(reply);
-		return;
+		return false;
-	}
-
-	struct x11_data_source *source = calloc(1, sizeof(struct x11_data_source));
-	if (source == NULL) {
-		free(reply);
-		return;
 	}
 
-	wl_signal_init(&source->base.events.destroy);
-	source->base.accept = data_source_accept;
-	source->base.send = data_source_send;
-	source->base.cancel = data_source_cancel;
-	source->xwm = xwm;
-
-	wl_array_init(&source->base.mime_types);
-	wl_array_init(&source->mime_types_atoms);
 	xcb_atom_t *value = xcb_get_property_value(reply);
 	for (uint32_t i = 0; i < reply->value_len; i++) {
 		char *mime_type = NULL;
@@ -511,14 +589,14 @@ static void xwm_get_selection_targets(struct wlr_xwm *xwm) {
 
 		if (mime_type != NULL) {
 			char **mime_type_ptr =
-				wl_array_add(&source->base.mime_types, sizeof(*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(&source->mime_types_atoms, sizeof(*atom_ptr));
+				wl_array_add(mime_types_atoms, sizeof(*atom_ptr));
 			if (atom_ptr == NULL) {
 				break;
 			}
@@ -526,10 +604,54 @@ static void xwm_get_selection_targets(struct wlr_xwm *xwm) {
 		}
 	}
 
-	wlr_seat_set_selection(xwm->seat, &source->base,
-		wl_display_next_serial(xwm->xwayland->wl_display));
-
 	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 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));
+		}
+	}
 }
 
 static void xwm_handle_selection_notify(struct wlr_xwm *xwm,
@@ -537,7 +659,9 @@ static void xwm_handle_selection_notify(struct wlr_xwm *xwm,
 	xcb_selection_notify_event_t *selection_notify =
 		(xcb_selection_notify_event_t *) event;
 
-	if (selection_notify->selection != xwm->atoms[CLIPBOARD]) {
+	struct wlr_xwm_selection *selection =
+		xwm_get_selection(xwm, selection_notify->selection);
+	if (selection == NULL) {
 		return;
 	}
 
@@ -552,48 +676,54 @@ static void xwm_handle_selection_notify(struct wlr_xwm *xwm,
 		}
 
 		// This sets the Wayland clipboard (by calling wlr_seat_set_selection)
-		xwm_get_selection_targets(xwm);
+		xwm_selection_get_targets(selection);
 	} else {
-		xwm_get_selection_data(xwm);
+		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;
+		(xcb_xfixes_selection_notify_event_t *)event;
 
-	if (xfixes_selection_notify->selection != xwm->atoms[CLIPBOARD]) {
+	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 (xwm->selection_owner != xwm->selection_window) {
+		if (selection->owner != selection->window) {
 			// A real X client selection went away, not our
 			// proxy selection
-			wlr_seat_set_selection(xwm->seat, NULL,
+			if (selection == &xwm->clipboard_selection) {
-				wl_display_next_serial(xwm->xwayland->wl_display));
+				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));
+			}
 		}
 
-		xwm->selection_owner = XCB_WINDOW_NONE;
+		selection->owner = XCB_WINDOW_NONE;
 		return 1;
 	}
 
-	xwm->selection_owner = xfixes_selection_notify->owner;
+	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 == xwm->selection_window) {
+	if (xfixes_selection_notify->owner == selection->window) {
-		xwm->selection_timestamp = xfixes_selection_notify->timestamp;
+		selection->timestamp = xfixes_selection_notify->timestamp;
-		wlr_log(L_DEBUG, "our window, skipping");
 		return 1;
 	}
 
-	xwm->incr = 0;
+	selection->incr = 0;
 	// doing this will give a selection notify where we actually handle the sync
-	xcb_convert_selection(xwm->xcb_conn, xwm->selection_window,
+	xcb_convert_selection(xwm->xcb_conn, selection->window,
-		xfixes_selection_notify->selection,
+		selection->atom,
 		xwm->atoms[TARGETS],
 		xwm->atoms[WL_SELECTION],
 		xfixes_selection_notify->timestamp);
@@ -629,12 +759,23 @@ int xwm_handle_selection_event(struct wlr_xwm *xwm,
 	return 0;
 }
 
-void xwm_selection_init(struct wlr_xwm *xwm) {
+static void selection_init(struct wlr_xwm *xwm,
-	uint32_t values[1], mask;
+		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;
 
-	xwm->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);
+}
 
-	values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;
+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,
@@ -652,52 +793,69 @@ void xwm_selection_init(struct wlr_xwm *xwm) {
 		xwm->atoms[CLIPBOARD_MANAGER],
 		XCB_TIME_CURRENT_TIME);
 
-	mask =
+	selection_init(xwm, &xwm->clipboard_selection, xwm->atoms[CLIPBOARD]);
-		XCB_XFIXES_SELECTION_EVENT_MASK_SET_SELECTION_OWNER |
+	selection_init(xwm, &xwm->primary_selection, xwm->atoms[PRIMARY]);
-		XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_WINDOW_DESTROY |
+}
-		XCB_XFIXES_SELECTION_EVENT_MASK_SELECTION_CLIENT_CLOSE;
+
-	xcb_xfixes_select_selection_input(xwm->xcb_conn, xwm->selection_window,
+static void xwm_selection_set_owner(struct wlr_xwm_selection *selection,
-		xwm->atoms[CLIPBOARD], mask);
+		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 handle_seat_set_selection(struct wl_listener *listener,
+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_change);
+		wl_container_of(listener, xwm, seat_selection);
 	struct wlr_data_source *source = seat->selection_source;
 
-	if (source == NULL) {
+	if (source != NULL && source->send == data_source_send) {
-		if (xwm->selection_owner == xwm->selection_window) {
-			xcb_set_selection_owner(xwm->xcb_conn,
-				XCB_ATOM_NONE,
-				xwm->atoms[CLIPBOARD],
-				xwm->selection_timestamp);
-		}
-
 		return;
 	}
 
-	if (source->send == data_source_send) {
+	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;
 	}
 
-	xcb_set_selection_owner(xwm->xcb_conn,
+	xwm_selection_set_owner(&xwm->primary_selection, source != NULL);
-		xwm->selection_window,
-		xwm->atoms[CLIPBOARD],
-		XCB_TIME_CURRENT_TIME);
 }
 
 void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat) {
 	assert(xwm);
 	assert(seat);
 	if (xwm->seat) {
-		wl_list_remove(&xwm->seat_selection_change.link);
+		wl_list_remove(&xwm->seat_selection.link);
+		wl_list_remove(&xwm->seat_primary_selection.link);
 		xwm->seat = NULL;
 	}
 
-	wl_signal_add(&seat->events.selection, &xwm->seat_selection_change);
-	xwm->seat_selection_change.notify = handle_seat_set_selection;
 	xwm->seat = seat;
-	handle_seat_set_selection(&xwm->seat_selection_change, 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);
 }

xwayland/xwm.c

@@ -45,6 +45,7 @@ const char *atom_map[ATOM_LAST] = {
 	"_NET_WM_STATE_MAXIMIZED_HORZ",
 	"WM_STATE",
 	"CLIPBOARD",
+	"PRIMARY",
 	"_WL_SELECTION",
 	"TARGETS",
 	"CLIPBOARD_MANAGER",