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 },
{ "output", cmd_output },
{ "popup_during_fullscreen", cmd_popup_during_fullscreen },
{ "primary_selection", cmd_primary_selection },
{ "seat", cmd_seat },
{ "set", cmd_set },
{ "shadow_blur_radius", cmd_shadow_blur_radius },

180
sway/server.c
View file

@ -63,54 +63,61 @@
#define SWAY_LAYER_SHELL_VERSION 4
#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
* more logic here. */
struct wlr_drm_lease_request_v1 *req = data;
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");
wlr_drm_lease_request_v1_reject(req);
}
}
#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 (server.drm_lease_manager != NULL) {
if (server.drm_lease_manager != NULL)
{
struct wlr_drm_lease_device_v1 *drm_lease_dev;
wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link) {
if (drm_lease_dev->global == global) {
wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link)
{
if (drm_lease_dev->global == global)
{
return true;
}
}
}
#endif
return
global == server.output_manager_v1->global ||
global == server.output_power_manager_v1->global ||
global == server.input_method->global ||
global == server.foreign_toplevel_manager->global ||
global == server.data_control_manager_v1->global ||
global == server.screencopy_manager_v1->global ||
global == server.export_dmabuf_manager_v1->global ||
global == server.security_context_manager_v1->global ||
global == server.gamma_control_manager_v1->global ||
global == server.layer_shell->global ||
global == server.session_lock.manager->global ||
global == server.input->inhibit->global ||
global == server.input->keyboard_shortcuts_inhibit->global ||
global == server.input->virtual_keyboard->global ||
global == server.input->virtual_pointer->global;
return global == server.output_manager_v1->global ||
global == server.output_power_manager_v1->global ||
global == server.input_method->global ||
global == server.foreign_toplevel_manager->global ||
global == server.data_control_manager_v1->global ||
global == server.screencopy_manager_v1->global ||
global == server.export_dmabuf_manager_v1->global ||
global == server.security_context_manager_v1->global ||
global == server.gamma_control_manager_v1->global ||
global == server.layer_shell->global ||
global == server.session_lock.manager->global ||
global == server.input->inhibit->global ||
global == server.input->keyboard_shortcuts_inhibit->global ||
global == server.input->virtual_keyboard->global ||
global == server.input->virtual_pointer->global;
}
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
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;
}
#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
const struct wlr_security_context_v1_state *security_context =
wlr_security_context_manager_v1_lookup_client(
server.security_context_manager_v1, (struct wl_client *)client);
if (is_privileged(global)) {
server.security_context_manager_v1, (struct wl_client *)client);
if (is_privileged(global))
{
return security_context == NULL;
}
return true;
}
bool server_init(struct sway_server *server) {
bool server_init(struct sway_server *server)
{
sway_log(SWAY_DEBUG, "Initializing Wayland server");
server->wl_display = wl_display_create();
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);
server->backend = wlr_backend_autocreate(server->wl_display, &server->session);
if (!server->backend) {
if (!server->backend)
{
sway_log(SWAY_ERROR, "Unable to create backend");
return false;
}
server->renderer = fx_renderer_create(server->backend);
if (!server->renderer) {
if (!server->renderer)
{
sway_log(SWAY_ERROR, "Failed to create fx_renderer");
return false;
}
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);
server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer(
server->wl_display, 4, server->renderer);
}
server->allocator = wlr_allocator_autocreate(server->backend,
server->renderer);
if (!server->allocator) {
server->renderer);
if (!server->allocator)
{
sway_log(SWAY_ERROR, "Failed to create allocator");
return false;
}
server->compositor = wlr_compositor_create(server->wl_display, 6,
server->renderer);
server->renderer);
server->compositor_new_surface.notify = handle_compositor_new_surface;
wl_signal_add(&server->compositor->events.new_surface,
&server->compositor_new_surface);
&server->compositor_new_surface);
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);
server->gamma_control_set_gamma.notify = handle_gamma_control_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;
wl_signal_add(&server->backend->events.new_output, &server->new_output);
server->output_layout_change.notify = handle_output_layout_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);
@ -190,15 +203,15 @@ bool server_init(struct sway_server *server) {
sway_idle_inhibit_manager_v1_init();
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,
&server->layer_shell_surface);
&server->layer_shell_surface);
server->layer_shell_surface.notify = handle_layer_shell_surface;
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,
&server->xdg_shell_surface);
&server->xdg_shell_surface);
server->xdg_shell_surface.notify = handle_xdg_shell_surface;
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,
WLR_SERVER_DECORATION_MANAGER_MODE_SERVER);
wl_signal_add(&server->server_decoration_manager->events.new_decoration,
&server->server_decoration);
&server->server_decoration);
server->server_decoration.notify = handle_server_decoration;
wl_list_init(&server->decorations);
server->xdg_decoration_manager =
wlr_xdg_decoration_manager_v1_create(server->wl_display);
wl_signal_add(
&server->xdg_decoration_manager->events.new_toplevel_decoration,
&server->xdg_decoration);
&server->xdg_decoration_manager->events.new_toplevel_decoration,
&server->xdg_decoration);
server->xdg_decoration.notify = handle_xdg_decoration;
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);
server->pointer_constraint.notify = handle_pointer_constraint;
wl_signal_add(&server->pointer_constraints->events.new_constraint,
&server->pointer_constraint);
&server->pointer_constraint);
server->presentation =
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);
server->output_manager_apply.notify = handle_output_manager_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;
wl_signal_add(&server->output_manager_v1->events.test,
&server->output_manager_test);
&server->output_manager_test);
server->output_power_manager_v1 =
wlr_output_power_manager_v1_create(server->wl_display);
server->output_power_manager_set_mode.notify =
handle_output_power_manager_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->text_input = wlr_text_input_manager_v3_create(server->wl_display);
server->foreign_toplevel_manager =
@ -256,13 +269,16 @@ bool server_init(struct sway_server *server) {
sway_session_lock_init();
#if WLR_HAS_DRM_BACKEND
server->drm_lease_manager=
server->drm_lease_manager =
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;
wl_signal_add(&server->drm_lease_manager->events.request,
&server->drm_lease_request);
} else {
&server->drm_lease_request);
}
else
{
sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1");
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 =
xdg_activation_v1_handle_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 =
xdg_activation_v1_handle_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 =
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
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);
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);
break;
}
}
if (!server->socket) {
if (!server->socket)
{
sway_log(SWAY_ERROR, "Unable to open wayland socket");
wlr_backend_destroy(server->backend);
return false;
}
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");
wlr_backend_destroy(server->backend);
return false;
} else {
}
else
{
wlr_multi_backend_add(server->backend, server->headless_backend);
}
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");
root->fallback_output = output_create(wlr_output);
// This may have been set already via -Dtxn-timeout
if (!server->txn_timeout_ms) {
if (!server->txn_timeout_ms)
{
server->txn_timeout_ms = 200;
}
@ -343,7 +366,8 @@ bool server_init(struct sway_server *server) {
return true;
}
void server_fini(struct sway_server *server) {
void server_fini(struct sway_server *server)
{
// TODO: free sway-specific resources
#if HAVE_XWAYLAND
wlr_xwayland_destroy(server->xwayland.wlr_xwayland);
@ -353,23 +377,28 @@ void server_fini(struct sway_server *server) {
list_free(server->dirty_nodes);
}
bool server_start(struct sway_server *server) {
bool server_start(struct sway_server *server)
{
#if HAVE_XWAYLAND
if (config->xwayland != XWAYLAND_MODE_DISABLED) {
if (config->xwayland != XWAYLAND_MODE_DISABLED)
{
sway_log(SWAY_DEBUG, "Initializing Xwayland (lazy=%d)",
config->xwayland == XWAYLAND_MODE_LAZY);
config->xwayland == XWAYLAND_MODE_LAZY);
server->xwayland.wlr_xwayland =
wlr_xwayland_create(server->wl_display, server->compositor,
config->xwayland == XWAYLAND_MODE_LAZY);
if (!server->xwayland.wlr_xwayland) {
config->xwayland == XWAYLAND_MODE_LAZY);
if (!server->xwayland.wlr_xwayland)
{
sway_log(SWAY_ERROR, "Failed to start Xwayland");
unsetenv("DISPLAY");
} else {
}
else
{
wl_signal_add(&server->xwayland.wlr_xwayland->events.new_surface,
&server->xwayland_surface);
&server->xwayland_surface);
server->xwayland_surface.notify = handle_xwayland_surface;
wl_signal_add(&server->xwayland.wlr_xwayland->events.ready,
&server->xwayland_ready);
&server->xwayland_ready);
server->xwayland_ready.notify = handle_xwayland_ready;
setenv("DISPLAY", server->xwayland.wlr_xwayland->display_name, true);
@ -379,13 +408,15 @@ bool server_start(struct sway_server *server) {
}
#endif
if (config->primary_selection) {
if (config->primary_selection)
{
wlr_primary_selection_v1_device_manager_create(server->wl_display);
}
sway_log(SWAY_INFO, "Starting backend on wayland display '%s'",
server->socket);
if (!wlr_backend_start(server->backend)) {
server->socket);
if (!wlr_backend_start(server->backend))
{
sway_log(SWAY_ERROR, "Failed to start backend");
wlr_backend_destroy(server->backend);
return false;
@ -394,8 +425,9 @@ bool server_start(struct sway_server *server) {
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'",
server->socket);
server->socket);
wl_display_run(server->wl_display);
}