dany/diyac
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
b0cf86aa0061c201f97b1a4929a5ef2dd746c47d
diyac/seat.c
Dany LE 0f31545ccd feat: add more protocols + touch support: 
* add touch support (experimental)
* add support for wlr_cursor_shape_v1
* add support for wlr_relative_pointer_manager_v1
2025-07-29 15:33:19 +02:00

711 lines
25 KiB
C
Raw Blame History

#define _POSIX_C_SOURCE 200112L
#include <wlr/types/wlr_input_device.h>
#include <wlr/types/wlr_data_device.h>
#include <stdlib.h>
#include <wlr/util/log.h>
#include <assert.h>
#include <strings.h>
#include <wlr/types/wlr_touch.h>
#include "seat.h"
#include "view.h"
#include "output.h"
#include "idle.h"
static struct wlr_output *output_by_name(struct diyac_server *server, const char *name)
{
assert(name);
struct diyac_output *output;
wl_list_for_each(output, &server->outputs, link)
{
if (!strcasecmp(output->wlr_output->name, name))
{
return output->wlr_output;
}
}
return NULL;
}
static void configure_keyboard(struct diyac_seat *seat, struct diyac_input *input, bool force)
{
(void)seat;
struct wlr_input_device *device = input->device;
assert(device->type == WLR_INPUT_DEVICE_KEYBOARD);
struct diyac_keyboard *keyboard = (struct diyac_keyboard *)input;
struct wlr_keyboard *kb = wlr_keyboard_from_input_device(device);
if (!keyboard->is_virtual || force)
{
/*
* Set layout based on environment variables XKB_DEFAULT_LAYOUT,
* XKB_DEFAULT_OPTIONS, and friends.
*/
struct xkb_rule_names rules = {0};
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
struct xkb_keymap *keymap = xkb_map_new_from_names(context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (keymap)
{
if (!wlr_keyboard_keymaps_match(kb->keymap, keymap))
{
wlr_keyboard_set_keymap(kb, keymap);
}
xkb_keymap_unref(keymap);
}
else
{
wlr_log(WLR_ERROR, "Failed to create xkb keymap");
}
xkb_context_unref(context);
}
wlr_keyboard_set_repeat_info(kb, 25, 600);
}
static void keyboard_handle_modifiers(
struct wl_listener *listener, void *data)
{
(void)data;
/* This event is raised when a modifier key, such as shift or alt, is
* pressed. We simply communicate this to the client. */
struct diyac_keyboard *keyboard =
wl_container_of(listener, keyboard, modifiers);
/*
* A seat can only have one keyboard, but this is a limitation of the
* Wayland protocol - not wlroots. We assign all connected keyboards to the
* same seat. You can swap out the underlying wlr_keyboard like this and
* wlr_seat handles this transparently.
*/
wlr_seat_set_keyboard(keyboard->input.seat->wlr_seat, keyboard->wlr_keyboard);
/* Send modifiers to the client. */
wlr_seat_keyboard_notify_modifiers(keyboard->input.seat->wlr_seat,
&keyboard->wlr_keyboard->modifiers);
}
static bool handle_keybinding(struct diyac_server *server, xkb_keysym_t sym)
{
/*
* Here we handle compositor keybindings. This is when the compositor is
* processing keys, rather than passing them on to the client for its own
* processing.
*
* This function assumes Alt is held down.
*/
switch (sym)
{
case XKB_KEY_Escape:
wl_display_terminate(server->wl_display);
break;
case XKB_KEY_F1:
/* Cycle to the next toplevel */
if (wl_list_length(&server->views) < 2)
{
break;
}
struct diyac_view *next_toplevel =
wl_container_of(server->views.prev, next_toplevel, link);
diyac_focus_view(next_toplevel, true);
break;
default:
return false;
}
return true;
}
static void keyboard_handle_key(
struct wl_listener *listener, void *data)
{
/* This event is raised when a key is pressed or released. */
struct diyac_keyboard *keyboard =
wl_container_of(listener, keyboard, key);
struct wlr_keyboard_key_event *event = data;
struct wlr_seat *seat = keyboard->input.seat->wlr_seat;
diya_idle_manager_notify_activity(seat);
/* Translate libinput keycode -> xkbcommon */
// wlr_log(WLR_INFO, "receive keycode %d", event->keycode);
uint32_t keycode = event->keycode + 8;
/* Get a list of keysyms based on the keymap for this keyboard */
const xkb_keysym_t *syms;
int nsyms = xkb_state_key_get_syms(
keyboard->wlr_keyboard->xkb_state, keycode, &syms);
bool handled = false;
uint32_t modifiers = wlr_keyboard_get_modifiers(keyboard->wlr_keyboard);
if ((modifiers & WLR_MODIFIER_ALT) &&
event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
{
/* If alt is held down and this button was _pressed_, we attempt to
* process it as a compositor keybinding. */
for (int i = 0; i < nsyms; i++)
{
handled |= handle_keybinding(keyboard->input.seat->server, syms[i]);
}
}
if (!handled)
{
/* Otherwise, we pass it along to the client. */
wlr_seat_set_keyboard(seat, keyboard->wlr_keyboard);
wlr_seat_keyboard_notify_key(seat, event->time_msec,
event->keycode, event->state);
}
}
static void input_handle_destroy(struct wl_listener *listener, void *data)
{
(void)data;
/* This event is raised by the keyboard base wlr_input_device to signal
* the destruction of the wlr_keyboard. It will no longer receive events
* and should be destroyed.
*/
struct diyac_input *input = wl_container_of(listener, input, destroy);
wl_list_remove(&input->link);
wl_list_remove(&input->destroy.link);
if (input->device->type == WLR_INPUT_DEVICE_KEYBOARD)
{
struct diyac_keyboard *keyboard = (struct diyac_keyboard *)input;
if (keyboard->is_virtual)
{
wlr_log(WLR_INFO, "Virtual keyboard destroyed");
}
wl_list_remove(&keyboard->modifiers.link);
wl_list_remove(&keyboard->key.link);
}
free(input);
}
static struct diyac_input *server_new_keyboard(struct diyac_seat *seat,
struct wlr_input_device *device, bool is_virtual)
{
struct wlr_keyboard *wlr_keyboard = wlr_keyboard_from_input_device(device);
struct diyac_keyboard *keyboard = calloc(1, sizeof(*keyboard));
keyboard->wlr_keyboard = wlr_keyboard;
keyboard->input.device = device;
keyboard->input.seat = seat;
keyboard->is_virtual = is_virtual;
/**
* Force configure default keyboard keymap for all new
* keyboard, including virtual keyboard
*/
configure_keyboard(seat, &keyboard->input, true);
/* Here we set up listeners for keyboard events. */
keyboard->modifiers.notify = keyboard_handle_modifiers;
wl_signal_add(&wlr_keyboard->events.modifiers, &keyboard->modifiers);
keyboard->key.notify = keyboard_handle_key;
wl_signal_add(&wlr_keyboard->events.key, &keyboard->key);
wlr_seat_set_keyboard(seat->wlr_seat, keyboard->wlr_keyboard);
/* And add the keyboard to our list of keyboards */
// wl_list_insert(&server->seat.keyboards, &keyboard->link);
return (struct diyac_input *)keyboard;
}
/*
static void configure_libinput(struct wlr_input_device *wlr_input_device)
{
if (!wlr_input_device) {
wlr_log(WLR_ERROR, "no wlr_input_device");
return;
}
struct input *input = wlr_input_device->data;
if (!wlr_input_device_is_libinput(wlr_input_device)) {
input->scroll_factor = 1.0;
return;
}
struct libinput_device *libinput_dev =
wlr_libinput_get_device_handle(wlr_input_device);
if (!libinput_dev) {
wlr_log(WLR_ERROR, "no libinput_dev");
return;
}
struct libinput_category *dc = get_category(wlr_input_device);
assert(dc);
if (libinput_device_config_tap_get_finger_count(libinput_dev) <= 0) {
wlr_log(WLR_INFO, "tap unavailable");
} else {
wlr_log(WLR_INFO, "tap configured");
libinput_device_config_tap_set_enabled(libinput_dev, dc->tap);
libinput_device_config_tap_set_button_map(libinput_dev,
dc->tap_button_map);
}
if (libinput_device_config_tap_get_finger_count(libinput_dev) <= 0
|| dc->tap_and_drag < 0) {
wlr_log(WLR_INFO, "tap-and-drag not configured");
} else {
wlr_log(WLR_INFO, "tap-and-drag configured");
libinput_device_config_tap_set_drag_enabled(
libinput_dev, dc->tap_and_drag);
}
if (libinput_device_config_tap_get_finger_count(libinput_dev) <= 0
|| dc->drag_lock < 0) {
wlr_log(WLR_INFO, "drag lock not configured");
} else {
wlr_log(WLR_INFO, "drag lock configured");
libinput_device_config_tap_set_drag_lock_enabled(
libinput_dev, dc->drag_lock);
}
if (libinput_device_config_scroll_has_natural_scroll(libinput_dev) <= 0
|| dc->natural_scroll < 0) {
wlr_log(WLR_INFO, "natural scroll not configured");
} else {
wlr_log(WLR_INFO, "natural scroll configured");
libinput_device_config_scroll_set_natural_scroll_enabled(
libinput_dev, dc->natural_scroll);
}
if (libinput_device_config_left_handed_is_available(libinput_dev) <= 0
|| dc->left_handed < 0) {
wlr_log(WLR_INFO, "left-handed mode not configured");
} else {
wlr_log(WLR_INFO, "left-handed mode configured");
libinput_device_config_left_handed_set(libinput_dev,
dc->left_handed);
}
if (libinput_device_config_accel_is_available(libinput_dev) == 0) {
wlr_log(WLR_INFO, "pointer acceleration unavailable");
} else {
wlr_log(WLR_INFO, "pointer acceleration configured");
if (dc->pointer_speed >= -1) {
libinput_device_config_accel_set_speed(libinput_dev,
dc->pointer_speed);
}
if (dc->accel_profile > 0) {
libinput_device_config_accel_set_profile(libinput_dev,
dc->accel_profile);
}
}
if (libinput_device_config_middle_emulation_is_available(libinput_dev)
== 0 || dc->middle_emu < 0) {
wlr_log(WLR_INFO, "middle emulation not configured");
} else {
wlr_log(WLR_INFO, "middle emulation configured");
libinput_device_config_middle_emulation_set_enabled(
libinput_dev, dc->middle_emu);
}
if (libinput_device_config_dwt_is_available(libinput_dev) == 0
|| dc->dwt < 0) {
wlr_log(WLR_INFO, "dwt not configured");
} else {
wlr_log(WLR_INFO, "dwt configured");
libinput_device_config_dwt_set_enabled(libinput_dev, dc->dwt);
}
if ((dc->click_method != LIBINPUT_CONFIG_CLICK_METHOD_NONE
&& (libinput_device_config_click_get_methods(libinput_dev)
& dc->click_method) == 0)
|| dc->click_method < 0) {
wlr_log(WLR_INFO, "click method not configured");
} else {
wlr_log(WLR_INFO, "click method configured");
libinput_device_config_click_set_method(libinput_dev, dc->click_method);
}
if ((dc->send_events_mode != LIBINPUT_CONFIG_SEND_EVENTS_ENABLED
&& (libinput_device_config_send_events_get_modes(libinput_dev)
& dc->send_events_mode) == 0)
|| dc->send_events_mode < 0) {
wlr_log(WLR_INFO, "send events mode not configured");
} else {
wlr_log(WLR_INFO, "send events mode configured");
libinput_device_config_send_events_set_mode(libinput_dev, dc->send_events_mode);
}
if (libinput_device_config_calibration_has_matrix(libinput_dev) == 0
|| !dc->have_calibration_matrix) {
wlr_log(WLR_INFO, "calibration matrix not configured");
} else {
wlr_log(WLR_INFO, "calibration matrix configured");
libinput_device_config_calibration_set_matrix(libinput_dev, dc->calibration_matrix);
}
wlr_log(WLR_INFO, "scroll factor configured");
input->scroll_factor = dc->scroll_factor;
}
*/
static struct diyac_input *server_new_pointer(struct diyac_seat *seat, struct wlr_input_device *device)
{
struct diyac_input *input = calloc(1, sizeof(*input));
input->device = device;
device->data = input;
/**
* @TODO:
* configure pointer via libinput
*
*/
wlr_cursor_attach_input_device(seat->cursor, device);
struct wlr_pointer *pointer = wlr_pointer_from_input_device(device);
wlr_log(WLR_INFO, "map pointer to output %s", pointer->output_name);
struct wlr_output *output = NULL;
if (pointer->output_name)
{
output = output_by_name(seat->server, pointer->output_name);
}
wlr_cursor_map_input_to_output(seat->cursor, device, output);
wlr_cursor_map_input_to_region(seat->cursor, device, NULL);
return input;
}
static struct diyac_input *server_new_touch(struct diyac_seat *seat, struct wlr_input_device *device)
{
struct diyac_input *input = calloc(1, sizeof(*input));
input->device = device;
device->data = input;
/**
* @TODO:
* configure touch device via libinput
*
*/
wlr_cursor_attach_input_device(seat->cursor, device);
struct wlr_touch *touch = wlr_touch_from_input_device(device);
wlr_log(WLR_INFO, "map pointer to output %s", touch->output_name);
struct wlr_output *output = NULL;
if (touch->output_name)
{
output = output_by_name(seat->server, touch->output_name);
}
wlr_cursor_map_input_to_output(seat->cursor, device, output);
wlr_cursor_map_input_to_region(seat->cursor, device, NULL);
return input;
}
static void seat_add_input(struct diyac_seat *seat, struct diyac_input *input)
{
input->seat = seat;
input->destroy.notify = input_handle_destroy;
wl_signal_add(&input->device->events.destroy, &input->destroy);
wl_list_insert(&seat->inputs, &input->link);
// update capability
/* We need to let the wlr_seat know what our capabilities are, which is
* communiciated to the client. In Diyac we always have a cursor, even if
* there are no pointer devices, so we always include that capability. */
uint32_t caps = 0;
wl_list_for_each(input, &seat->inputs, link)
{
switch (input->device->type)
{
case WLR_INPUT_DEVICE_KEYBOARD:
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
break;
case WLR_INPUT_DEVICE_POINTER:
caps |= WL_SEAT_CAPABILITY_POINTER;
break;
case WLR_INPUT_DEVICE_TOUCH:
caps |= WL_SEAT_CAPABILITY_TOUCH;
break;
default:
break;
}
}
wlr_seat_set_capabilities(seat->wlr_seat, caps);
}
static void server_new_input(struct wl_listener *listener, void *data)
{
/* This event is raised by the backend when a new input device becomes
* available. */
struct diyac_seat *seat =
wl_container_of(listener, seat, new_input);
struct wlr_input_device *device = data;
struct diyac_input *input = NULL;
switch (device->type)
{
case WLR_INPUT_DEVICE_KEYBOARD:
input = server_new_keyboard(seat, device, false);
break;
case WLR_INPUT_DEVICE_POINTER:
input = server_new_pointer(seat, device);
break;
case WLR_INPUT_DEVICE_TOUCH:
input = server_new_touch(seat, device);
break;
default:
return;
}
seat_add_input(seat, input);
}
static void seat_request_cursor(struct wl_listener *listener, void *data)
{
struct diyac_seat *seat = wl_container_of(
listener, seat, request_cursor);
/* This event is raised by the seat when a client provides a cursor image */
struct wlr_seat_pointer_request_set_cursor_event *event = data;
struct wlr_seat_client *focused_client =
seat->wlr_seat->pointer_state.focused_client;
/* This can be sent by any client, so we check to make sure this one is
* actually has pointer focus first. */
if (focused_client == event->seat_client)
{
/* Once we've vetted the client, we can tell the cursor to use the
* provided surface as the cursor image. It will set the hardware cursor
* on the output that it's currently on and continue to do so as the
* cursor moves between outputs. */
wlr_cursor_set_surface(seat->cursor, event->surface,
event->hotspot_x, event->hotspot_y);
}
}
static void seat_request_set_selection(struct wl_listener *listener, void *data)
{
/* This event is raised by the seat when a client wants to set the selection,
* usually when the user copies something. wlroots allows compositors to
* ignore such requests if they so choose, but in diyac we always honor
*/
struct diyac_seat *seat = wl_container_of(
listener, seat, request_set_selection);
struct wlr_seat_request_set_selection_event *event = data;
wlr_seat_set_selection(seat->wlr_seat, event->source, event->serial);
}
static void request_set_selection_notify(struct wl_listener *listener, void *data)
{
struct diyac_seat *seat = wl_container_of(
listener, seat, request_set_selection);
struct wlr_seat_request_set_selection_event *event = data;
wlr_seat_set_selection(seat->wlr_seat, event->source,
event->serial);
}
static void request_set_primary_selection_notify(struct wl_listener *listener, void *data)
{
struct diyac_seat *seat = wl_container_of(
listener, seat, request_set_primary_selection);
struct wlr_seat_request_set_primary_selection_event *event = data;
wlr_seat_set_primary_selection(seat->wlr_seat, event->source,
event->serial);
}
static void new_virtual_keyboard(struct wl_listener *listener, void *data)
{
wlr_log(WLR_INFO, "Create a new virtual keyboard with default layout");
struct diyac_seat *seat = wl_container_of(listener, seat, virtual_keyboard_new);
struct wlr_virtual_keyboard_v1 *virtual_keyboard = data;
struct wlr_input_device *device = &virtual_keyboard->keyboard.base;
struct diyac_input *input = server_new_keyboard(seat, device, true);
device->data = input;
seat_add_input(seat, input);
}
/*
* Configures a seat, which is a single "seat" at which a user sits and
* operates the computer. This conceptually includes up to one keyboard,
* pointer, touch, and drawing tablet device. We also rig up a listener to
* let us know when new input devices are available on the backend.
*/
void diyac_init_seat(struct diyac_server *server)
{
// server->seat = calloc(1, sizeof(struct diyac_seat));
server->seat.server = server;
server->seat.new_input.notify = server_new_input;
wl_signal_add(&server->backend->events.new_input, &server->seat.new_input);
server->seat.wlr_seat = wlr_seat_create(server->wl_display, "seat0");
wl_list_init(&server->seat.touch_points);
wl_list_init(&server->seat.inputs);
server->seat.request_cursor.notify = seat_request_cursor;
wl_signal_add(&server->seat.wlr_seat->events.request_set_cursor,
&server->seat.request_cursor);
server->seat.request_set_selection.notify = seat_request_set_selection;
wl_signal_add(&server->seat.wlr_seat->events.request_set_selection,
&server->seat.request_set_selection);
server->seat.request_set_selection.notify = request_set_selection_notify;
wl_signal_add(&server->seat.wlr_seat->events.request_set_selection,
&server->seat.request_set_selection);
server->seat.request_set_primary_selection.notify =
request_set_primary_selection_notify;
wl_signal_add(&server->seat.wlr_seat->events.request_set_primary_selection,
&server->seat.request_set_primary_selection);
// virtual keyboard support
server->seat.virtual_keyboard_manager = wlr_virtual_keyboard_manager_v1_create(server->wl_display);
wl_signal_add(&server->seat.virtual_keyboard_manager->events.new_virtual_keyboard,
&server->seat.virtual_keyboard_new);
server->seat.virtual_keyboard_new.notify = new_virtual_keyboard;
}
static void seat_focus(struct diyac_seat *seat, struct wlr_surface *surface, bool is_lock_surface)
{
/*
* Respect session lock. This check is critical, DO NOT REMOVE.
* It should also come before the !surface condition, or the
* lock screen may lose focus and become impossible to unlock.
*/
struct diyac_server *server = seat->server;
if (server->lock && !is_lock_surface)
{
return;
}
if (!surface)
{
wlr_seat_keyboard_notify_clear_focus(seat->wlr_seat);
return;
}
/* Respect input inhibit (also used by some lock screens) */
/*
if (input_inhibit_blocks_surface(seat, surface->resource)) {
return;
}
*/
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->wlr_seat);
if (keyboard)
{
wlr_seat_keyboard_notify_enter(seat->wlr_seat, surface,
keyboard->keycodes, keyboard->num_keycodes, &keyboard->modifiers);
}
/*
struct wlr_pointer_constraint_v1 *constraint =
wlr_pointer_constraints_v1_constraint_for_surface(server->constraints,
surface, seat->seat);
constrain_cursor(server, constraint);
*/
}
void diyac_seat_focus_surface(struct diyac_seat *seat, struct wlr_surface *surface)
{
/* Respect layer-shell exclusive keyboard-interactivity. */
if (seat->focused_layer && seat->focused_layer->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE)
{
return;
}
seat_focus(seat, surface, /*is_lock_surface*/ false);
}
void diyac_seat_focus_lock_surface(struct diyac_seat *seat, struct wlr_surface *surface)
{
seat_focus(seat, surface, /*is_lock_surface*/ true);
}
void diyac_seat_focus_layer(struct diyac_seat *seat, struct wlr_layer_surface_v1 *layer)
{
if (!layer)
{
seat->focused_layer = NULL;
diyac_seat_focus_topmost(seat, diyac_output_from_cursor(seat->server));
return;
/*
diyac_focus_topmost_view(seat->server, false);
return;
*/
}
if (seat->focused_layer == layer)
{
return;
}
if (seat->focused_layer)
wlr_log(WLR_INFO, "Layer focus changed %s -> %s", seat->focused_layer->namespace, layer->namespace);
// unfocus currently focus view
if (seat->server->active_view)
{
diya_view_unfocus(seat->server->active_view);
}
seat_focus(seat, layer->surface, /*is_lock_surface*/ false);
seat->focused_layer = layer;
/*
if (layer->current.layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP)
{
seat->focused_layer = layer;
}
*/
}
void diyac_seat_configure(struct diyac_server *server)
{
struct diyac_seat *seat = &server->seat;
struct diyac_input *input = NULL;
wl_list_for_each(input, &seat->inputs, link)
{
switch (input->device->type)
{
case WLR_INPUT_DEVICE_KEYBOARD:
configure_keyboard(seat, input, false);
break;
case WLR_INPUT_DEVICE_POINTER:
/*TODO: reconfigure libinput*/
break;
case WLR_INPUT_DEVICE_TOUCH:
/*TODO: reconfigure libinput*/
break;
default:
break;
}
}
}
void diyac_seat_focus_topmost(struct diyac_seat *seat, struct diyac_output *output)
{
for (int i = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY; i >= ZWLR_LAYER_SHELL_V1_LAYER_TOP; i--)
{
struct wlr_scene_tree *scene = output->layer_tree[i];
struct wl_list *node_list = &scene->children;
struct wlr_scene_node *node;
wl_list_for_each_reverse(node, node_list, link)
{
struct diyac_node_descriptor *node_descriptor = node->data;
if (!node->enabled || !node_descriptor || node_descriptor->type != DIYAC_NODE_LAYER_SURFACE)
{
continue;
}
struct diyac_layer_surface *surface = (struct diyac_layer_surface *)node_descriptor->data;
struct wlr_layer_surface_v1 *layer_surface = surface->scene_layer_surface->layer_surface;
if (!surface->mapped || layer_surface->current.keyboard_interactive == ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE)
{
continue;
}
wlr_log(WLR_INFO, " Update focus on layer: %s", layer_surface->namespace);
diyac_seat_focus_layer(seat, layer_surface);
return;
}
}
seat->focused_layer = NULL;
diyac_focus_topmost_view(seat->server, true);
}
void diyac_seat_pointer_end_grab(struct diyac_seat *seat, struct wlr_surface *surface)
{
if (!surface || !wlr_seat_pointer_has_grab(seat->wlr_seat))
{
return;
}
struct wlr_xdg_surface *xdg_surface =
wlr_xdg_surface_try_from_wlr_surface(surface);
if (!xdg_surface || xdg_surface->role != WLR_XDG_SURFACE_ROLE_POPUP)
{
/*
* If we have an active popup grab (an open popup) and we are
* not on the popup itself, end that grab to close the popup.
* Contrary to pointer button notifications, a tablet/touch
* button notification sometimes doesn't end grabs automatically
* on button notifications in another client (observed in GTK4),
* so end the grab manually.
*/
wlr_seat_pointer_end_grab(seat->wlr_seat);
}
}
Reference in New Issue View Git Blame Copy Permalink