From 6dffaa7bb79b88253f5fb9c6f106b19554a68b23 Mon Sep 17 00:00:00 2001 From: emersion Date: Mon, 25 Dec 2017 16:10:16 +0100 Subject: [PATCH] Implement xwayland primary selection sync --- include/wlr/types/wlr_data_device.h | 3 + include/wlr/types/wlr_primary_selection.h | 5 +- include/wlr/xwm.h | 37 +- types/wlr_data_device.c | 19 +- types/wlr_primary_selection.c | 10 +- xwayland/selection.c | 670 +++++++++++++--------- xwayland/xwm.c | 1 + 7 files changed, 462 insertions(+), 283 deletions(-) diff --git a/include/wlr/types/wlr_data_device.h b/include/wlr/types/wlr_data_device.h index 70d79a19..fa5a7834 100644 --- a/include/wlr/types/wlr_data_device.h +++ b/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 diff --git a/include/wlr/types/wlr_primary_selection.h b/include/wlr/types/wlr_primary_selection.h index a639b913..94309b57 100644 --- a/include/wlr/types/wlr_primary_selection.h +++ b/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 diff --git a/include/wlr/xwm.h b/include/wlr/xwm.h index 47e674c0..cbc2f132 100644 --- a/include/wlr/xwm.h +++ b/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; - xcb_window_t selection_owner; - 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_xwm_selection clipboard_selection; + struct wlr_xwm_selection primary_selection; 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); diff --git a/types/wlr_data_device.c b/types/wlr_data_device.c index c0399160..eb1b4e0f 100644 --- a/types/wlr_data_device.c +++ b/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 = - wl_resource_create(client, &wl_data_source_interface, - wl_resource_get_version(resource), id); + source->resource = wl_resource_create(client, &wl_data_source_interface, + 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 diff --git a/types/wlr_primary_selection.c b/types/wlr_primary_selection.c index 63bdeceb..5af90121 100644 --- a/types/wlr_primary_selection.c +++ b/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, diff --git a/xwayland/selection.c b/xwayland/selection.c index 25386b1a..8bcad509 100644 --- a/xwayland/selection.c +++ b/xwayland/selection.c @@ -7,131 +7,133 @@ #include #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, + .sequence = 0, + .time = selection->request.time, + .requestor = selection->request.requestor, + .selection = selection->request.selection, + .target = selection->request.target, + .property = property, + }; - memset(&selection_notify, 0, sizeof selection_notify); - selection_notify.response_type = XCB_SELECTION_NOTIFY; - selection_notify.sequence = 0; - selection_notify.time = xwm->selection_request.time; - selection_notify.requestor = xwm->selection_request.requestor; - selection_notify.selection = xwm->selection_request.selection; - selection_notify.target = xwm->selection_request.target; - selection_notify.property = property; - - xcb_send_event(xwm->xcb_conn, 0, // propagate - xwm->selection_request.requestor, - XCB_EVENT_MASK_NO_EVENT, (char *)&selection_notify); + xcb_send_event(selection->xwm->xcb_conn, + 0, // propagate + selection->request.requestor, + XCB_EVENT_MASK_NO_EVENT, + (char *)&selection_notify); } -static int xwm_flush_source_data(struct wlr_xwm *xwm) -{ - xcb_change_property(xwm->xcb_conn, +static int xwm_selection_flush_source_data(struct wlr_xwm_selection *selection) { + xcb_change_property(selection->xwm->xcb_conn, XCB_PROP_MODE_REPLACE, - xwm->selection_request.requestor, - xwm->selection_request.property, - xwm->selection_target, + selection->request.requestor, + selection->request.property, + selection->target, 8, // format - xwm->source_data.size, - xwm->source_data.data); - xwm->selection_property_set = 1; - int length = xwm->source_data.size; - xwm->source_data.size = 0; + 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 int xwm_read_data_source(int fd, uint32_t mask, void *data) { - struct wlr_xwm *xwm = data; - void *p; + struct wlr_xwm_selection *selection = data; + struct wlr_xwm *xwm = selection->xwm; - int current = xwm->source_data.size; - if (xwm->source_data.size < incr_chunk_size) { - p = wl_array_add(&xwm->source_data, incr_chunk_size); + 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); } 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); - wl_event_source_remove(xwm->property_source); - xwm->property_source = NULL; + xwm_selection_send_notify(selection, XCB_ATOM_NONE); + wl_event_source_remove(selection->property_source); + 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; - if (xwm->source_data.size >= incr_chunk_size) { - if (!xwm->incr) { + 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", - xwm->source_data.size); - xwm->incr = 1; + selection->source_data.size); + selection->incr = 1; xcb_change_property(xwm->xcb_conn, XCB_PROP_MODE_REPLACE, - xwm->selection_request.requestor, - xwm->selection_request.property, + selection->request.requestor, + selection->request.property, xwm->atoms[INCR], 32, /* format */ 1, &incr_chunk_size); - xwm->selection_property_set = 1; - xwm->flush_property_on_delete = 1; - wl_event_source_remove(xwm->property_source); - xwm->property_source = NULL; - xwm_send_selection_notify(xwm, xwm->selection_request.property); - } else if (xwm->selection_property_set) { + selection->property_set = true; + selection->flush_property_on_delete = 1; + wl_event_source_remove(selection->property_source); + selection->property_source = NULL; + xwm_selection_send_notify(selection, selection->request.property); + } 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; - wl_event_source_remove(xwm->property_source); - xwm->property_source = NULL; + selection->flush_property_on_delete = 1; + wl_event_source_remove(selection->property_source); + selection->property_source = NULL; } else { wlr_log(L_DEBUG, "got %zu bytes, " "property deleted, setting new property", - xwm->source_data.size); - xwm_flush_source_data(xwm); + selection->source_data.size); + 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_send_selection_notify(xwm, xwm->selection_request.property); + xwm_selection_flush_source_data(selection); + xwm_selection_send_notify(selection, selection->request.property); xcb_flush(xwm->xcb_conn); - wl_event_source_remove(xwm->property_source); - xwm->property_source = NULL; + wl_event_source_remove(selection->property_source); + selection->property_source = NULL; close(fd); - wl_array_release(&xwm->source_data); - xwm->selection_request.requestor = XCB_NONE; - } else if (len == 0 && xwm->incr) { + wl_array_release(&selection->source_data); + selection->request.requestor = XCB_NONE; + } else if (len == 0 && selection->incr) { wlr_log(L_DEBUG, "incr transfer complete"); - xwm->flush_property_on_delete = 1; - if (xwm->selection_property_set) { + selection->flush_property_on_delete = 1; + 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); - xwm_flush_source_data(xwm); + selection->source_data.size); + xwm_selection_flush_source_data(selection); } xcb_flush(xwm->xcb_conn); - wl_event_source_remove(xwm->property_source); - xwm->property_source = NULL; - close(xwm->data_source_fd); - xwm->data_source_fd = -1; + wl_event_source_remove(selection->property_source); + selection->property_source = NULL; + close(selection->source_fd); + 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, - const char *mime_type) { - struct wlr_data_source *source; - int p[2]; +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) { + 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); - xwm->selection_target = target; - xwm->data_source_fd = p[0]; + wl_array_init(&selection->source_data); + selection->target = target; + selection->source_fd = p[0]; struct wl_event_loop *loop = - wl_display_get_event_loop(xwm->xwayland->wl_display); - xwm->property_source = wl_event_loop_add_fd(loop, - xwm->data_source_fd, + 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_read_data_source, - xwm); + selection); - source = xwm->seat->selection_source; - source->send(source, mime_type, p[1]); + xwm_selection_source_send(selection, mime_type, p[1]); close(p[1]); } -static void xwm_send_timestamp(struct wlr_xwm *xwm) { - xcb_change_property(xwm->xcb_conn, +static void xwm_selection_send_timestamp(struct wlr_xwm_selection *selection) { + xcb_change_property(selection->xwm->xcb_conn, XCB_PROP_MODE_REPLACE, - xwm->selection_request.requestor, - xwm->selection_request.property, + selection->request.requestor, + 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 void xwm_send_targets(struct wlr_xwm *xwm) { - struct wlr_data_source *source = xwm->seat->selection_source; - size_t n = 2 + source->mime_types.size / sizeof(char *); +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_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) { + 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, - xwm->selection_request.property, + selection->request.requestor, + 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]) { - xwm_send_selection_notify(xwm, XCB_ATOM_NONE); - return; - } - - xwm->selection_request = *selection_request; - xwm->incr = 0; - xwm->flush_property_on_delete = 0; - 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); + // 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; + 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); - int remainder = xcb_get_property_value_length(xwm->property_reply) - - xwm->property_start; + 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 + xwm->property_start, remainder); + int len = write(fd, property + selection->property_start, remainder); if (len == -1) { - free(xwm->property_reply); - xwm->property_reply = NULL; - if (xwm->property_source) { - wl_event_source_remove(xwm->property_source); + free(selection->property_reply); + selection->property_reply = NULL; + if (selection->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, - len, xcb_get_property_value_length(xwm->property_reply)); + selection->property_start + len, + len, xcb_get_property_value_length(selection->property_reply)); - xwm->property_start += len; + selection->property_start += len; if (len == remainder) { - free(xwm->property_reply); - xwm->property_reply = NULL; - if (xwm->property_source) { - wl_event_source_remove(xwm->property_source); + free(selection->property_reply); + selection->property_reply = NULL; + if (selection->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; - xwm->property_reply = reply; - writable_callback(xwm->data_source_fd, WL_EVENT_WRITABLE, xwm); + selection->property_start = 0; + selection->property_reply = reply; + 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); - xwm->property_source = - wl_event_loop_add_fd(loop, - xwm->data_source_fd, - WL_EVENT_WRITABLE, - writable_callback, xwm); + 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, writable_callback, + selection); } } -static void xwm_get_selection_data(struct wlr_xwm *xwm) { - xcb_get_property_cookie_t cookie = - xcb_get_property(xwm->xcb_conn, - 1, // delete - xwm->selection_window, - xwm->atoms[WL_SELECTION], - XCB_GET_PROPERTY_TYPE_ANY, - 0, // offset - 0x1fffffff // length - ); +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; - } 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 { - struct wlr_data_source base; - 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, +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 x11_data_source *source = (struct x11_data_source *)base; - struct wlr_xwm *xwm = source->xwm; + 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, &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, - xwm->atoms[CLIPBOARD], + selection->window, + 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; } -static void data_source_cancel(struct wlr_data_source *source) { +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 xwm_get_selection_targets(struct wlr_xwm *xwm) { - // set the wayland clipboard selection to the copied selection +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) { + // No-op +} + +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 *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, - wl_display_next_serial(xwm->xwayland->wl_display)); + 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)); + } } - 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) { - xwm->selection_timestamp = xfixes_selection_notify->timestamp; - wlr_log(L_DEBUG, "our window, skipping"); + if (xfixes_selection_notify->owner == selection->window) { + selection->timestamp = xfixes_selection_notify->timestamp; 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, - xfixes_selection_notify->selection, + xcb_convert_selection(xwm->xcb_conn, selection->window, + 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; } +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[1], mask; - - xwm->selection_request.requestor = XCB_NONE; - - values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE; + 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 = - 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, xwm->selection_window, - xwm->atoms[CLIPBOARD], mask); + selection_init(xwm, &xwm->clipboard_selection, xwm->atoms[CLIPBOARD]); + selection_init(xwm, &xwm->primary_selection, xwm->atoms[PRIMARY]); } -static void handle_seat_set_selection(struct wl_listener *listener, +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_change); + wl_container_of(listener, xwm, seat_selection); struct wlr_data_source *source = seat->selection_source; - if (source == NULL) { - if (xwm->selection_owner == xwm->selection_window) { - xcb_set_selection_owner(xwm->xcb_conn, - XCB_ATOM_NONE, - xwm->atoms[CLIPBOARD], - xwm->selection_timestamp); - } - + if (source != NULL && source->send == data_source_send) { 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_window, - xwm->atoms[CLIPBOARD], - XCB_TIME_CURRENT_TIME); + xwm_selection_set_owner(&xwm->primary_selection, source != NULL); } 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); } diff --git a/xwayland/xwm.c b/xwayland/xwm.c index 6cbe9bda..a8fd4d95 100644 --- a/xwayland/xwm.c +++ b/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",