blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Implement xwayland primary selection sync

This commit is contained in:
emersion 2017-12-25 16:10:16 +01:00
parent 4d744aeb23
commit 6dffaa7bb7
No known key found for this signature in database
GPG Key ID: 0FDE7BE0E88F5E48
7 changed files with 462 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/wlr/types/wlr_data_device.h
View File

@ -34,6 +34,7 @@ struct wlr_data_source {
struct wl_resource *resource; struct wl_resource *resource;
struct wlr_data_offer *offer; struct wlr_data_offer *offer;
struct wlr_seat_client *seat_client; struct wlr_seat_client *seat_client;
struct wl_array mime_types; struct wl_array mime_types;
bool accepted; 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, 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);
#endif #endif

5
include/wlr/types/wlr_primary_selection.h
View File

@ -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_client_send_primary_selection(struct wlr_seat_client *seat_client);
void wlr_seat_set_primary_selection(struct wlr_seat *seat, 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 #endif

37
include/wlr/xwm.h
View File

@ -32,6 +32,7 @@ enum atom_name {
_NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_HORZ,
WM_STATE, WM_STATE,
CLIPBOARD, CLIPBOARD,
PRIMARY,
WL_SELECTION, WL_SELECTION,
TARGETS, TARGETS,
CLIPBOARD_MANAGER, CLIPBOARD_MANAGER,
@ -49,6 +50,24 @@ enum net_wm_state_action {
NET_WM_STATE_TOGGLE = 2, 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_xwm {
struct wlr_xwayland *xwayland; struct wlr_xwayland *xwayland;
struct wl_event_source *event_source; struct wl_event_source *event_source;
@ -63,20 +82,9 @@ struct wlr_xwm {
xcb_render_pictformat_t render_format_id; xcb_render_pictformat_t render_format_id;
xcb_cursor_t cursor; xcb_cursor_t cursor;
// selection properties
xcb_window_t selection_window; 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; struct wlr_xwayland_surface *focus_surface;
@ -86,7 +94,8 @@ struct wlr_xwm {
const xcb_query_extension_reply_t *xfixes; const xcb_query_extension_reply_t *xfixes;
struct wl_listener compositor_surface_create; 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); struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland);

19
types/wlr_data_device.c
View File

@ -927,6 +927,11 @@ static struct wl_data_source_interface data_source_impl = {
.set_actions = data_source_set_actions, .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, static void data_device_manager_create_data_source(struct wl_client *client,
struct wl_resource *resource, uint32_t id) { struct wl_resource *resource, uint32_t id) {
struct wlr_data_source *source = calloc(1, sizeof(struct wlr_data_source)); 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); wl_resource_post_no_memory(resource);
return; 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) { if (source->resource == NULL) {
free(source); free(source);
wl_resource_post_no_memory(resource); wl_resource_post_no_memory(resource);
return; return;
} }
wl_resource_set_implementation(source->resource, &data_source_impl,
source, data_source_resource_destroy);
source->accept = client_data_source_accept; source->accept = client_data_source_accept;
source->send = client_data_source_send; source->send = client_data_source_send;
source->cancel = client_data_source_cancel; 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 static const struct wl_data_device_manager_interface

10
types/wlr_primary_selection.c
View File

@ -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, static void device_manager_handle_create_source(struct wl_client *client,
struct wl_resource *manager_resource, uint32_t id) { struct wl_resource *manager_resource, uint32_t id) {
struct wlr_primary_selection_source *source = 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); wl_client_post_no_memory(client);
return; return;
} }
wlr_primary_selection_source_init(source);
int version = wl_resource_get_version(manager_resource); int version = wl_resource_get_version(manager_resource);
source->resource = wl_resource_create(client, 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->send = client_source_send;
source->cancel = client_source_cancel; 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, void device_manager_handle_get_device(struct wl_client *client,

670
xwayland/selection.c
View File

@ -7,131 +7,133 @@
#include <fcntl.h> #include <fcntl.h>
#include "wlr/util/log.h" #include "wlr/util/log.h"
#include "wlr/types/wlr_data_device.h" #include "wlr/types/wlr_data_device.h"
#include "wlr/types/wlr_primary_selection.h"
#include "wlr/xwm.h" #include "wlr/xwm.h"
static const size_t incr_chunk_size = 64 * 1024; 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_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); xcb_send_event(selection->xwm->xcb_conn,
selection_notify.response_type = XCB_SELECTION_NOTIFY; 0, // propagate
selection_notify.sequence = 0; selection->request.requestor,
selection_notify.time = xwm->selection_request.time; XCB_EVENT_MASK_NO_EVENT,
selection_notify.requestor = xwm->selection_request.requestor; (char *)&selection_notify);
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);
} }
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, 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 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; return length;
} }
static int xwm_read_data_source(int fd, uint32_t mask, void *data) { 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 { } 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); int len = read(fd, p, available);
if (len == -1) { if (len == -1) {
wlr_log(L_ERROR, "read error from data source: %m"); 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); 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\"", wlr_log(L_DEBUG, "read %d (available %d, mask 0x%x) bytes: \"%.*s\"",
len, available, mask, len, (char *) p); 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", 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_change_property(xwm->xcb_conn,
XCB_PROP_MODE_REPLACE, XCB_PROP_MODE_REPLACE,
xwm->selection_request.requestor, selection->request.requestor,
xwm->selection_request.property, selection->request.property,
xwm->atoms[INCR], xwm->atoms[INCR],
32, /* format */ 32, /* format */
1, &incr_chunk_size); 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 " 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 { } else {
wlr_log(L_DEBUG, "got %zu bytes, " wlr_log(L_DEBUG, "got %zu bytes, "
"property deleted, setting new property", "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"); wlr_log(L_DEBUG, "non-incr transfer complete");
/* Non-incr transfer all done. */ /* 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); 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); 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"); 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 " wlr_log(L_DEBUG, "got %zu bytes, waiting for "
"property delete", xwm->source_data.size); "property delete", selection->source_data.size);
} else { } else {
wlr_log(L_DEBUG, "got %zu bytes, " wlr_log(L_DEBUG, "got %zu bytes, "
"property deleted, setting new property", "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); 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); close(fd);
} else { } else {
wlr_log(L_DEBUG, "nothing happened, buffered the bytes"); 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; 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) { if (pipe(p) == -1) {
wlr_log(L_ERROR, "pipe failed: %m"); wlr_log(L_ERROR, "pipe failed: %m");
xwm_send_selection_notify(xwm, XCB_ATOM_NONE); xwm_selection_send_notify(selection, XCB_ATOM_NONE);
return; 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_SETFD, FD_CLOEXEC);
fcntl(p[1], F_SETFL, O_NONBLOCK); 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 = 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, WL_EVENT_READABLE,
xwm_read_data_source, 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]); 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, XCB_PROP_MODE_REPLACE,
xwm->selection_request.requestor, selection->request.requestor,
xwm->selection_request.property, selection->request.property,
XCB_ATOM_INTEGER, XCB_ATOM_INTEGER,
32, // format 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) { static struct wl_array *xwm_selection_source_get_mime_types(
struct wlr_data_source *source = xwm->seat->selection_source; struct wlr_xwm_selection *selection) {
size_t n = 2 + source->mime_types.size / sizeof(char *); 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)); xcb_atom_t *targets = malloc(n * sizeof(xcb_atom_t));
if (targets == NULL) { if (targets == NULL) {
return; return;
@ -196,7 +234,7 @@ static void xwm_send_targets(struct wlr_xwm *xwm) {
size_t i = 2; size_t i = 2;
char **mime_type_ptr; 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; char *mime_type = *mime_type_ptr;
xcb_atom_t atom; xcb_atom_t atom;
if (strcmp(mime_type, "text/plain;charset=utf-8") == 0) { 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_change_property(xwm->xcb_conn,
XCB_PROP_MODE_REPLACE, XCB_PROP_MODE_REPLACE,
xwm->selection_request.requestor, selection->request.requestor,
xwm->selection_request.property, selection->request.property,
XCB_ATOM_ATOM, XCB_ATOM_ATOM,
32, // format 32, // format
n, targets); n, targets);
xwm_send_selection_notify(xwm, xwm->selection_request.property); xwm_selection_send_notify(selection, selection->request.property);
free(targets); 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, static void xwm_handle_selection_request(struct wlr_xwm *xwm,
xcb_generic_event_t *event) { xcb_generic_event_t *event) {
xcb_selection_request_event_t *selection_request = xcb_selection_request_event_t *selection_request =
(xcb_selection_request_event_t *) event; (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]) { if (selection_request->selection == xwm->atoms[CLIPBOARD_MANAGER]) {
// The wlroots clipboard should already have grabbed // The wlroots clipboard should already have grabbed the first target,
// the first target, so just send selection notify // so just send selection notify now. This isn't synchronized with the
// now. This isn't synchronized with the clipboard // clipboard finishing getting the data, so there's a race here.
// finishing getting the data, so there's a race here. struct wlr_xwm_selection *selection = &xwm->clipboard_selection;
xwm_send_selection_notify(xwm, xwm->selection_request.property); selection->request = *selection_request;
selection->incr = 0;
selection->flush_property_on_delete = 0;
xwm_selection_send_notify(selection, selection->request.property);
return; 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) { if (xwm->seat->selection_source == NULL) {
wlr_log(L_DEBUG, "not handling selection request: " wlr_log(L_DEBUG, "not handling selection request: "
"no selection source assigned to xwayland seat"); "no selection source assigned to xwayland seat");
xwm_send_selection_notify(xwm, XCB_ATOM_NONE); xwm_selection_send_notify(selection, XCB_ATOM_NONE);
return; return;
} }
@ -266,18 +320,20 @@ static void xwm_handle_selection_request(struct wlr_xwm *xwm,
if (xwm->focus_surface == NULL) { if (xwm->focus_surface == NULL) {
wlr_log(L_DEBUG, "denying read access to clipboard: " wlr_log(L_DEBUG, "denying read access to clipboard: "
"no xwayland surface focused"); "no xwayland surface focused");
xwm_send_selection_notify(xwm, XCB_ATOM_NONE); xwm_selection_send_notify(selection, XCB_ATOM_NONE);
return; return;
} }
if (selection_request->target == xwm->atoms[TARGETS]) { if (selection_request->target == xwm->atoms[TARGETS]) {
xwm_send_targets(xwm); xwm_selection_send_targets(selection);
} else if (selection_request->target == xwm->atoms[TIMESTAMP]) { } 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]) { } 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]) { } 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 { } else {
xcb_get_atom_name_cookie_t name_cookie = xcb_get_atom_name_cookie_t name_cookie =
xcb_get_atom_name(xwm->xcb_conn, selection_request->target); 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); xcb_get_atom_name_reply(xwm->xcb_conn, name_cookie, NULL);
if (name_reply == NULL) { if (name_reply == NULL) {
wlr_log(L_DEBUG, "not handling selection request: unknown atom"); 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; return;
} }
size_t len = xcb_get_atom_name_name_length(name_reply); 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); memcpy(mime_type, xcb_get_atom_name_name(name_reply), len);
mime_type[len] = '\0'; 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(mime_type);
free(name_reply); free(name_reply);
} }
} }
static int writable_callback(int fd, uint32_t mask, void *data) { 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) { 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); close(fd);
wlr_log(L_ERROR, "write error to target fd: %m"); wlr_log(L_ERROR, "write error to target fd: %m");
return 1; return 1;
} }
wlr_log(L_DEBUG, "wrote %d (chunk size %d) of %d bytes", 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) { 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, xcb_delete_property(xwm->xcb_conn,
xwm->selection_window, selection->window,
xwm->atoms[WL_SELECTION]); xwm->atoms[WL_SELECTION]);
} else { } else {
wlr_log(L_DEBUG, "transfer complete"); wlr_log(L_DEBUG, "transfer complete");
@ -348,86 +405,77 @@ static int writable_callback(int fd, uint32_t mask, void *data) {
return 1; 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) { 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 = 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_t *reply =
xcb_get_property_reply(xwm->xcb_conn, cookie, NULL); xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
if (reply == NULL) { if (reply == NULL) {
return; return;
} else if (reply->type == xwm->atoms[INCR]) { }
xwm->incr = 1;
if (reply->type == xwm->atoms[INCR]) {
selection->incr = 1;
free(reply); free(reply);
} else { } else {
xwm->incr = 0; selection->incr = 0;
// reply's ownership is transferred to wm, which is responsible // reply's ownership is transferred to wm, which is responsible
// for freeing it // 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) { 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; bool found = false;
xcb_atom_t mime_type_atom; xcb_atom_t mime_type_atom;
char **mime_type_ptr; char **mime_type_ptr;
size_t i = 0; 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; char *mime_type = *mime_type_ptr;
if (strcmp(mime_type, requested_mime_type) == 0) { if (strcmp(mime_type, requested_mime_type) == 0) {
found = true; found = true;
xcb_atom_t *atoms = source->mime_types_atoms.data;
mime_type_atom = atoms[i]; mime_type_atom = atoms[i];
break; break;
} }
++i; ++i;
} }
if (!found) { if (!found) {
wlr_log(L_DEBUG, "cannot send X11 selection: unsupported MIME type");
return; return;
} }
xcb_convert_selection(xwm->xcb_conn, xcb_convert_selection(xwm->xcb_conn,
xwm->selection_window, selection->window,
xwm->atoms[CLIPBOARD], selection->atom,
mime_type_atom, mime_type_atom,
xwm->atoms[WL_SELECTION], xwm->atoms[WL_SELECTION],
XCB_TIME_CURRENT_TIME); XCB_TIME_CURRENT_TIME);
@ -435,18 +483,62 @@ static void data_source_send(struct wlr_data_source *base,
xcb_flush(xwm->xcb_conn); xcb_flush(xwm->xcb_conn);
fcntl(fd, F_SETFL, O_WRONLY | O_NONBLOCK); 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) { static void data_source_send(struct wlr_data_source *base,
// set the wayland clipboard selection to the copied selection 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, xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn,
1, // delete 1, // delete
xwm->selection_window, selection->window,
xwm->atoms[WL_SELECTION], xwm->atoms[WL_SELECTION],
XCB_GET_PROPERTY_TYPE_ANY, XCB_GET_PROPERTY_TYPE_ANY,
0, // offset 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_t *reply =
xcb_get_property_reply(xwm->xcb_conn, cookie, NULL); xcb_get_property_reply(xwm->xcb_conn, cookie, NULL);
if (reply == NULL) { if (reply == NULL) {
return; return false;
} }
if (reply->type != XCB_ATOM_ATOM) { if (reply->type != XCB_ATOM_ATOM) {
free(reply); 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); xcb_atom_t *value = xcb_get_property_value(reply);
for (uint32_t i = 0; i < reply->value_len; i++) { for (uint32_t i = 0; i < reply->value_len; i++) {
char *mime_type = NULL; char *mime_type = NULL;
@ -511,14 +589,14 @@ static void xwm_get_selection_targets(struct wlr_xwm *xwm) {
if (mime_type != NULL) { if (mime_type != NULL) {
char **mime_type_ptr = 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) { if (mime_type_ptr == NULL) {
break; break;
} }
*mime_type_ptr = mime_type; *mime_type_ptr = mime_type;
xcb_atom_t *atom_ptr = 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) { if (atom_ptr == NULL) {
break; 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); 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, 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 *selection_notify =
(xcb_selection_notify_event_t *) event; (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; 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) // This sets the Wayland clipboard (by calling wlr_seat_set_selection)
xwm_get_selection_targets(xwm); xwm_selection_get_targets(selection);
} else { } else {
xwm_get_selection_data(xwm); xwm_selection_get_data(selection);
} }
} }
static int xwm_handle_xfixes_selection_notify(struct wlr_xwm *xwm, static int xwm_handle_xfixes_selection_notify(struct wlr_xwm *xwm,
xcb_generic_event_t *event) { xcb_generic_event_t *event) {
xcb_xfixes_selection_notify_event_t *xfixes_selection_notify = 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; return 0;
} }
if (xfixes_selection_notify->owner == XCB_WINDOW_NONE) { 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 // A real X client selection went away, not our
// proxy selection // 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; 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 // We have to use XCB_TIME_CURRENT_TIME when we claim the
// selection, so grab the actual timestamp here so we can // selection, so grab the actual timestamp here so we can
// answer TIMESTAMP conversion requests correctly. // 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; return 1;
} }
xwm->incr = 0; selection->incr = 0;
// doing this will give a selection notify where we actually handle the sync // 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[TARGETS],
xwm->atoms[WL_SELECTION], xwm->atoms[WL_SELECTION],
xfixes_selection_notify->timestamp); xfixes_selection_notify->timestamp);
@ -629,12 +759,23 @@ int xwm_handle_selection_event(struct wlr_xwm *xwm,
return 0; 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) { void xwm_selection_init(struct wlr_xwm *xwm) {
uint32_t values[1], mask; uint32_t values[] = { XCB_EVENT_MASK_PROPERTY_CHANGE };
xwm->selection_request.requestor = XCB_NONE;
values[0] = XCB_EVENT_MASK_PROPERTY_CHANGE;
xwm->selection_window = xcb_generate_id(xwm->xcb_conn); xwm->selection_window = xcb_generate_id(xwm->xcb_conn);
xcb_create_window(xwm->xcb_conn, xcb_create_window(xwm->xcb_conn,
XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,
@ -652,52 +793,69 @@ void xwm_selection_init(struct wlr_xwm *xwm) {
xwm->atoms[CLIPBOARD_MANAGER], xwm->atoms[CLIPBOARD_MANAGER],
XCB_TIME_CURRENT_TIME); 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,
xwm->atoms[CLIPBOARD], mask);
} }
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) { void *data) {
struct wlr_seat *seat = data; struct wlr_seat *seat = data;
struct wlr_xwm *xwm = 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; 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; 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; 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) { void xwm_set_seat(struct wlr_xwm *xwm, struct wlr_seat *seat) {
assert(xwm); assert(xwm);
assert(seat); assert(seat);
if (xwm->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; 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; 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);
} }

1
xwayland/xwm.c
View File

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