alex/swayfx
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Add primary_selection config option

Browse source 
See: https://github.com/swaywm/sway/issues/4511

Adds a bool config option `primary_selection`, which explicitly
enables/disables the primary selection clipboard. Defaults to enabled.

This is implemented as a launch-only option which enables or disables the creation of the
`zwp_primary_selection_device_manager_v1` global.

Co-authored-by: Tilde Rose <t1lde@protonmail.com>
This commit is contained in:
Aidan Dang 2022-03-16 22:22:41 +00:00 committed by Alex Janka
parent da559b3ea1
commit 4166fd3728
2 changed files with 107 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
sway/commands.c
View file

@ -96,6 +96,7 @@ static const struct cmd_handler handlers[] = {
{ "no_focus", cmd_no_focus }, { "no_focus", cmd_no_focus },
{ "output", cmd_output }, { "output", cmd_output },
{ "popup_during_fullscreen", cmd_popup_during_fullscreen }, { "popup_during_fullscreen", cmd_popup_during_fullscreen },
{ "primary_selection", cmd_primary_selection },
{ "seat", cmd_seat }, { "seat", cmd_seat },
{ "set", cmd_set }, { "set", cmd_set },
{ "shadow_blur_radius", cmd_shadow_blur_radius }, { "shadow_blur_radius", cmd_shadow_blur_radius },

180
sway/server.c
View file

@ -63,54 +63,61 @@
#define SWAY_LAYER_SHELL_VERSION 4 #define SWAY_LAYER_SHELL_VERSION 4
#if WLR_HAS_DRM_BACKEND #if WLR_HAS_DRM_BACKEND
static void handle_drm_lease_request(struct wl_listener *listener, void *data) { static void handle_drm_lease_request(struct wl_listener *listener, void *data)
{
/* We only offer non-desktop outputs, but in the future we might want to do /* We only offer non-desktop outputs, but in the future we might want to do
* more logic here. */ * more logic here. */
struct wlr_drm_lease_request_v1 *req = data; struct wlr_drm_lease_request_v1 *req = data;
struct wlr_drm_lease_v1 *lease = wlr_drm_lease_request_v1_grant(req); struct wlr_drm_lease_v1 *lease = wlr_drm_lease_request_v1_grant(req);
if (!lease) { if (!lease)
{
sway_log(SWAY_ERROR, "Failed to grant lease request"); sway_log(SWAY_ERROR, "Failed to grant lease request");
wlr_drm_lease_request_v1_reject(req); wlr_drm_lease_request_v1_reject(req);
} }
} }
#endif #endif
static bool is_privileged(const struct wl_global *global) { static bool is_privileged(const struct wl_global *global)
{
#if WLR_HAS_DRM_BACKEND #if WLR_HAS_DRM_BACKEND
if (server.drm_lease_manager != NULL) { if (server.drm_lease_manager != NULL)
{
struct wlr_drm_lease_device_v1 *drm_lease_dev; struct wlr_drm_lease_device_v1 *drm_lease_dev;
wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link) { wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link)
if (drm_lease_dev->global == global) { {
if (drm_lease_dev->global == global)
{
return true; return true;
} }
} }
} }
#endif #endif
return return global == server.output_manager_v1->global ||
global == server.output_manager_v1->global || global == server.output_power_manager_v1->global ||
global == server.output_power_manager_v1->global || global == server.input_method->global ||
global == server.input_method->global || global == server.foreign_toplevel_manager->global ||
global == server.foreign_toplevel_manager->global || global == server.data_control_manager_v1->global ||
global == server.data_control_manager_v1->global || global == server.screencopy_manager_v1->global ||
global == server.screencopy_manager_v1->global || global == server.export_dmabuf_manager_v1->global ||
global == server.export_dmabuf_manager_v1->global || global == server.security_context_manager_v1->global ||
global == server.security_context_manager_v1->global || global == server.gamma_control_manager_v1->global ||
global == server.gamma_control_manager_v1->global || global == server.layer_shell->global ||
global == server.layer_shell->global || global == server.session_lock.manager->global ||
global == server.session_lock.manager->global || global == server.input->inhibit->global ||
global == server.input->inhibit->global || global == server.input->keyboard_shortcuts_inhibit->global ||
global == server.input->keyboard_shortcuts_inhibit->global || global == server.input->virtual_keyboard->global ||
global == server.input->virtual_keyboard->global || global == server.input->virtual_pointer->global;
global == server.input->virtual_pointer->global;
} }
static bool filter_global(const struct wl_client *client, static bool filter_global(const struct wl_client *client,
const struct wl_global *global, void *data) { const struct wl_global *global, void *data)
{
#if HAVE_XWAYLAND #if HAVE_XWAYLAND
struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland; struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
if (xwayland && global == xwayland->shell_v1->global) { if (xwayland && global == xwayland->shell_v1->global)
{
return xwayland->server != NULL && client == xwayland->server->client; return xwayland->server != NULL && client == xwayland->server->client;
} }
#endif #endif
@ -119,15 +126,17 @@ static bool filter_global(const struct wl_client *client,
// TODO: add a way for users to configure an allow-list // TODO: add a way for users to configure an allow-list
const struct wlr_security_context_v1_state *security_context = const struct wlr_security_context_v1_state *security_context =
wlr_security_context_manager_v1_lookup_client( wlr_security_context_manager_v1_lookup_client(
server.security_context_manager_v1, (struct wl_client *)client); server.security_context_manager_v1, (struct wl_client *)client);
if (is_privileged(global)) { if (is_privileged(global))
{
return security_context == NULL; return security_context == NULL;
} }
return true; return true;
} }
bool server_init(struct sway_server *server) { bool server_init(struct sway_server *server)
{
sway_log(SWAY_DEBUG, "Initializing Wayland server"); sway_log(SWAY_DEBUG, "Initializing Wayland server");
server->wl_display = wl_display_create(); server->wl_display = wl_display_create();
server->wl_event_loop = wl_display_get_event_loop(server->wl_display); server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
@ -135,37 +144,41 @@ bool server_init(struct sway_server *server) {
wl_display_set_global_filter(server->wl_display, filter_global, NULL); wl_display_set_global_filter(server->wl_display, filter_global, NULL);
server->backend = wlr_backend_autocreate(server->wl_display, &server->session); server->backend = wlr_backend_autocreate(server->wl_display, &server->session);
if (!server->backend) { if (!server->backend)
{
sway_log(SWAY_ERROR, "Unable to create backend"); sway_log(SWAY_ERROR, "Unable to create backend");
return false; return false;
} }
server->renderer = fx_renderer_create(server->backend); server->renderer = fx_renderer_create(server->backend);
if (!server->renderer) { if (!server->renderer)
{
sway_log(SWAY_ERROR, "Failed to create fx_renderer"); sway_log(SWAY_ERROR, "Failed to create fx_renderer");
return false; return false;
} }
wlr_renderer_init_wl_shm(server->renderer, server->wl_display); wlr_renderer_init_wl_shm(server->renderer, server->wl_display);
if (wlr_renderer_get_dmabuf_texture_formats(server->renderer) != NULL) { if (wlr_renderer_get_dmabuf_texture_formats(server->renderer) != NULL)
{
wlr_drm_create(server->wl_display, server->renderer); wlr_drm_create(server->wl_display, server->renderer);
server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer( server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer(
server->wl_display, 4, server->renderer); server->wl_display, 4, server->renderer);
} }
server->allocator = wlr_allocator_autocreate(server->backend, server->allocator = wlr_allocator_autocreate(server->backend,
server->renderer); server->renderer);
if (!server->allocator) { if (!server->allocator)
{
sway_log(SWAY_ERROR, "Failed to create allocator"); sway_log(SWAY_ERROR, "Failed to create allocator");
return false; return false;
} }
server->compositor = wlr_compositor_create(server->wl_display, 6, server->compositor = wlr_compositor_create(server->wl_display, 6,
server->renderer); server->renderer);
server->compositor_new_surface.notify = handle_compositor_new_surface; server->compositor_new_surface.notify = handle_compositor_new_surface;
wl_signal_add(&server->compositor->events.new_surface, wl_signal_add(&server->compositor->events.new_surface,
&server->compositor_new_surface); &server->compositor_new_surface);
wlr_subcompositor_create(server->wl_display); wlr_subcompositor_create(server->wl_display);
@ -176,13 +189,13 @@ bool server_init(struct sway_server *server) {
wlr_gamma_control_manager_v1_create(server->wl_display); wlr_gamma_control_manager_v1_create(server->wl_display);
server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma; server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma, wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma,
&server->gamma_control_set_gamma); &server->gamma_control_set_gamma);
server->new_output.notify = handle_new_output; server->new_output.notify = handle_new_output;
wl_signal_add(&server->backend->events.new_output, &server->new_output); wl_signal_add(&server->backend->events.new_output, &server->new_output);
server->output_layout_change.notify = handle_output_layout_change; server->output_layout_change.notify = handle_output_layout_change;
wl_signal_add(&root->output_layout->events.change, wl_signal_add(&root->output_layout->events.change,
&server->output_layout_change); &server->output_layout_change);
wlr_xdg_output_manager_v1_create(server->wl_display, root->output_layout); wlr_xdg_output_manager_v1_create(server->wl_display, root->output_layout);
@ -190,15 +203,15 @@ bool server_init(struct sway_server *server) {
sway_idle_inhibit_manager_v1_init(); sway_idle_inhibit_manager_v1_init();
server->layer_shell = wlr_layer_shell_v1_create(server->wl_display, server->layer_shell = wlr_layer_shell_v1_create(server->wl_display,
SWAY_LAYER_SHELL_VERSION); SWAY_LAYER_SHELL_VERSION);
wl_signal_add(&server->layer_shell->events.new_surface, wl_signal_add(&server->layer_shell->events.new_surface,
&server->layer_shell_surface); &server->layer_shell_surface);
server->layer_shell_surface.notify = handle_layer_shell_surface; server->layer_shell_surface.notify = handle_layer_shell_surface;
server->xdg_shell = wlr_xdg_shell_create(server->wl_display, server->xdg_shell = wlr_xdg_shell_create(server->wl_display,
SWAY_XDG_SHELL_VERSION); SWAY_XDG_SHELL_VERSION);
wl_signal_add(&server->xdg_shell->events.new_surface, wl_signal_add(&server->xdg_shell->events.new_surface,
&server->xdg_shell_surface); &server->xdg_shell_surface);
server->xdg_shell_surface.notify = handle_xdg_shell_surface; server->xdg_shell_surface.notify = handle_xdg_shell_surface;
server->tablet_v2 = wlr_tablet_v2_create(server->wl_display); server->tablet_v2 = wlr_tablet_v2_create(server->wl_display);
@ -209,15 +222,15 @@ bool server_init(struct sway_server *server) {
server->server_decoration_manager, server->server_decoration_manager,
WLR_SERVER_DECORATION_MANAGER_MODE_SERVER); WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
wl_signal_add(&server->server_decoration_manager->events.new_decoration, wl_signal_add(&server->server_decoration_manager->events.new_decoration,
&server->server_decoration); &server->server_decoration);
server->server_decoration.notify = handle_server_decoration; server->server_decoration.notify = handle_server_decoration;
wl_list_init(&server->decorations); wl_list_init(&server->decorations);
server->xdg_decoration_manager = server->xdg_decoration_manager =
wlr_xdg_decoration_manager_v1_create(server->wl_display); wlr_xdg_decoration_manager_v1_create(server->wl_display);
wl_signal_add( wl_signal_add(
&server->xdg_decoration_manager->events.new_toplevel_decoration, &server->xdg_decoration_manager->events.new_toplevel_decoration,
&server->xdg_decoration); &server->xdg_decoration);
server->xdg_decoration.notify = handle_xdg_decoration; server->xdg_decoration.notify = handle_xdg_decoration;
wl_list_init(&server->xdg_decorations); wl_list_init(&server->xdg_decorations);
@ -228,7 +241,7 @@ bool server_init(struct sway_server *server) {
wlr_pointer_constraints_v1_create(server->wl_display); wlr_pointer_constraints_v1_create(server->wl_display);
server->pointer_constraint.notify = handle_pointer_constraint; server->pointer_constraint.notify = handle_pointer_constraint;
wl_signal_add(&server->pointer_constraints->events.new_constraint, wl_signal_add(&server->pointer_constraints->events.new_constraint,
&server->pointer_constraint); &server->pointer_constraint);
server->presentation = server->presentation =
wlr_presentation_create(server->wl_display, server->backend); wlr_presentation_create(server->wl_display, server->backend);
@ -237,17 +250,17 @@ bool server_init(struct sway_server *server) {
wlr_output_manager_v1_create(server->wl_display); wlr_output_manager_v1_create(server->wl_display);
server->output_manager_apply.notify = handle_output_manager_apply; server->output_manager_apply.notify = handle_output_manager_apply;
wl_signal_add(&server->output_manager_v1->events.apply, wl_signal_add(&server->output_manager_v1->events.apply,
&server->output_manager_apply); &server->output_manager_apply);
server->output_manager_test.notify = handle_output_manager_test; server->output_manager_test.notify = handle_output_manager_test;
wl_signal_add(&server->output_manager_v1->events.test, wl_signal_add(&server->output_manager_v1->events.test,
&server->output_manager_test); &server->output_manager_test);
server->output_power_manager_v1 = server->output_power_manager_v1 =
wlr_output_power_manager_v1_create(server->wl_display); wlr_output_power_manager_v1_create(server->wl_display);
server->output_power_manager_set_mode.notify = server->output_power_manager_set_mode.notify =
handle_output_power_manager_set_mode; handle_output_power_manager_set_mode;
wl_signal_add(&server->output_power_manager_v1->events.set_mode, wl_signal_add(&server->output_power_manager_v1->events.set_mode,
&server->output_power_manager_set_mode); &server->output_power_manager_set_mode);
server->input_method = wlr_input_method_manager_v2_create(server->wl_display); server->input_method = wlr_input_method_manager_v2_create(server->wl_display);
server->text_input = wlr_text_input_manager_v3_create(server->wl_display); server->text_input = wlr_text_input_manager_v3_create(server->wl_display);
server->foreign_toplevel_manager = server->foreign_toplevel_manager =
@ -256,13 +269,16 @@ bool server_init(struct sway_server *server) {
sway_session_lock_init(); sway_session_lock_init();
#if WLR_HAS_DRM_BACKEND #if WLR_HAS_DRM_BACKEND
server->drm_lease_manager= server->drm_lease_manager =
wlr_drm_lease_v1_manager_create(server->wl_display, server->backend); wlr_drm_lease_v1_manager_create(server->wl_display, server->backend);
if (server->drm_lease_manager) { if (server->drm_lease_manager)
{
server->drm_lease_request.notify = handle_drm_lease_request; server->drm_lease_request.notify = handle_drm_lease_request;
wl_signal_add(&server->drm_lease_manager->events.request, wl_signal_add(&server->drm_lease_manager->events.request,
&server->drm_lease_request); &server->drm_lease_request);
} else { }
else
{
sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1"); sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1");
sway_log(SWAY_INFO, "VR will not be available"); sway_log(SWAY_INFO, "VR will not be available");
} }
@ -287,11 +303,11 @@ bool server_init(struct sway_server *server) {
server->xdg_activation_v1_request_activate.notify = server->xdg_activation_v1_request_activate.notify =
xdg_activation_v1_handle_request_activate; xdg_activation_v1_handle_request_activate;
wl_signal_add(&server->xdg_activation_v1->events.request_activate, wl_signal_add(&server->xdg_activation_v1->events.request_activate,
&server->xdg_activation_v1_request_activate); &server->xdg_activation_v1_request_activate);
server->xdg_activation_v1_new_token.notify = server->xdg_activation_v1_new_token.notify =
xdg_activation_v1_handle_new_token; xdg_activation_v1_handle_new_token;
wl_signal_add(&server->xdg_activation_v1->events.new_token, wl_signal_add(&server->xdg_activation_v1->events.new_token,
&server->xdg_activation_v1_new_token); &server->xdg_activation_v1_new_token);
struct wlr_cursor_shape_manager_v1 *cursor_shape_manager = struct wlr_cursor_shape_manager_v1 *cursor_shape_manager =
wlr_cursor_shape_manager_v1_create(server->wl_display, 1); wlr_cursor_shape_manager_v1_create(server->wl_display, 1);
@ -302,36 +318,43 @@ bool server_init(struct sway_server *server) {
// Avoid using "wayland-0" as display socket // Avoid using "wayland-0" as display socket
char name_candidate[16]; char name_candidate[16];
for (unsigned int i = 1; i <= 32; ++i) { for (unsigned int i = 1; i <= 32; ++i)
{
snprintf(name_candidate, sizeof(name_candidate), "wayland-%u", i); snprintf(name_candidate, sizeof(name_candidate), "wayland-%u", i);
if (wl_display_add_socket(server->wl_display, name_candidate) >= 0) { if (wl_display_add_socket(server->wl_display, name_candidate) >= 0)
{
server->socket = strdup(name_candidate); server->socket = strdup(name_candidate);
break; break;
} }
} }
if (!server->socket) { if (!server->socket)
{
sway_log(SWAY_ERROR, "Unable to open wayland socket"); sway_log(SWAY_ERROR, "Unable to open wayland socket");
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
return false; return false;
} }
server->headless_backend = wlr_headless_backend_create(server->wl_display); server->headless_backend = wlr_headless_backend_create(server->wl_display);
if (!server->headless_backend) { if (!server->headless_backend)
{
sway_log(SWAY_ERROR, "Failed to create secondary headless backend"); sway_log(SWAY_ERROR, "Failed to create secondary headless backend");
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
return false; return false;
} else { }
else
{
wlr_multi_backend_add(server->backend, server->headless_backend); wlr_multi_backend_add(server->backend, server->headless_backend);
} }
struct wlr_output *wlr_output = struct wlr_output *wlr_output =
wlr_headless_add_output(server->headless_backend, 800, 600); wlr_headless_add_output(server->headless_backend, 800, 600);
wlr_output_set_name(wlr_output, "FALLBACK"); wlr_output_set_name(wlr_output, "FALLBACK");
root->fallback_output = output_create(wlr_output); root->fallback_output = output_create(wlr_output);
// This may have been set already via -Dtxn-timeout // This may have been set already via -Dtxn-timeout
if (!server->txn_timeout_ms) { if (!server->txn_timeout_ms)
{
server->txn_timeout_ms = 200; server->txn_timeout_ms = 200;
} }
@ -343,7 +366,8 @@ bool server_init(struct sway_server *server) {
return true; return true;
} }
void server_fini(struct sway_server *server) { void server_fini(struct sway_server *server)
{
// TODO: free sway-specific resources // TODO: free sway-specific resources
#if HAVE_XWAYLAND #if HAVE_XWAYLAND
wlr_xwayland_destroy(server->xwayland.wlr_xwayland); wlr_xwayland_destroy(server->xwayland.wlr_xwayland);
@ -353,23 +377,28 @@ void server_fini(struct sway_server *server) {
list_free(server->dirty_nodes); list_free(server->dirty_nodes);
} }
bool server_start(struct sway_server *server) { bool server_start(struct sway_server *server)
{
#if HAVE_XWAYLAND #if HAVE_XWAYLAND
if (config->xwayland != XWAYLAND_MODE_DISABLED) { if (config->xwayland != XWAYLAND_MODE_DISABLED)
{
sway_log(SWAY_DEBUG, "Initializing Xwayland (lazy=%d)", sway_log(SWAY_DEBUG, "Initializing Xwayland (lazy=%d)",
config->xwayland == XWAYLAND_MODE_LAZY); config->xwayland == XWAYLAND_MODE_LAZY);
server->xwayland.wlr_xwayland = server->xwayland.wlr_xwayland =
wlr_xwayland_create(server->wl_display, server->compositor, wlr_xwayland_create(server->wl_display, server->compositor,
config->xwayland == XWAYLAND_MODE_LAZY); config->xwayland == XWAYLAND_MODE_LAZY);
if (!server->xwayland.wlr_xwayland) { if (!server->xwayland.wlr_xwayland)
{
sway_log(SWAY_ERROR, "Failed to start Xwayland"); sway_log(SWAY_ERROR, "Failed to start Xwayland");
unsetenv("DISPLAY"); unsetenv("DISPLAY");
} else { }
else
{
wl_signal_add(&server->xwayland.wlr_xwayland->events.new_surface, wl_signal_add(&server->xwayland.wlr_xwayland->events.new_surface,
&server->xwayland_surface); &server->xwayland_surface);
server->xwayland_surface.notify = handle_xwayland_surface; server->xwayland_surface.notify = handle_xwayland_surface;
wl_signal_add(&server->xwayland.wlr_xwayland->events.ready, wl_signal_add(&server->xwayland.wlr_xwayland->events.ready,
&server->xwayland_ready); &server->xwayland_ready);
server->xwayland_ready.notify = handle_xwayland_ready; server->xwayland_ready.notify = handle_xwayland_ready;
setenv("DISPLAY", server->xwayland.wlr_xwayland->display_name, true); setenv("DISPLAY", server->xwayland.wlr_xwayland->display_name, true);
@ -379,13 +408,15 @@ bool server_start(struct sway_server *server) {
} }
#endif #endif
if (config->primary_selection) { if (config->primary_selection)
{
wlr_primary_selection_v1_device_manager_create(server->wl_display); wlr_primary_selection_v1_device_manager_create(server->wl_display);
} }
sway_log(SWAY_INFO, "Starting backend on wayland display '%s'", sway_log(SWAY_INFO, "Starting backend on wayland display '%s'",
server->socket); server->socket);
if (!wlr_backend_start(server->backend)) { if (!wlr_backend_start(server->backend))
{
sway_log(SWAY_ERROR, "Failed to start backend"); sway_log(SWAY_ERROR, "Failed to start backend");
wlr_backend_destroy(server->backend); wlr_backend_destroy(server->backend);
return false; return false;
@ -394,8 +425,9 @@ bool server_start(struct sway_server *server) {
return true; return true;
} }
void server_run(struct sway_server *server) { void server_run(struct sway_server *server)
{
sway_log(SWAY_INFO, "Running compositor on wayland display '%s'", sway_log(SWAY_INFO, "Running compositor on wayland display '%s'",
server->socket); server->socket);
wl_display_run(server->wl_display); wl_display_run(server->wl_display);
} }