wlroots-hyprland/rootston/seat.c

1021 lines
31 KiB
C
Raw Normal View History

2018-04-03 18:50:05 +02:00
#define _POSIX_C_SOURCE 199309L
2017-11-12 15:55:28 +01:00
#include <assert.h>
2017-11-03 14:01:34 +01:00
#include <stdlib.h>
2017-11-04 18:12:35 +01:00
#include <string.h>
2018-04-03 18:50:05 +02:00
#include <time.h>
2017-11-12 15:55:28 +01:00
#include <wayland-server.h>
#include <wlr/config.h>
2018-02-12 21:29:23 +01:00
#include <wlr/types/wlr_idle.h>
#include <wlr/types/wlr_layer_shell.h>
2017-11-12 11:10:56 +01:00
#include <wlr/types/wlr_xcursor_manager.h>
2017-11-04 18:12:35 +01:00
#include <wlr/util/log.h>
2018-02-12 21:29:23 +01:00
#include "rootston/cursor.h"
2017-11-03 14:01:34 +01:00
#include "rootston/input.h"
#include "rootston/keyboard.h"
2018-02-12 21:29:23 +01:00
#include "rootston/seat.h"
#include "rootston/xcursor.h"
2017-11-03 14:01:34 +01:00
static void handle_keyboard_key(struct wl_listener *listener, void *data) {
struct roots_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_key);
struct roots_desktop *desktop = keyboard->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, keyboard->seat->seat);
2017-11-03 14:01:34 +01:00
struct wlr_event_keyboard_key *event = data;
roots_keyboard_handle_key(keyboard, event);
}
static void handle_keyboard_modifiers(struct wl_listener *listener,
void *data) {
struct roots_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_modifiers);
struct roots_desktop *desktop = keyboard->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, keyboard->seat->seat);
roots_keyboard_handle_modifiers(keyboard);
2017-11-03 14:01:34 +01:00
}
2017-11-04 18:12:35 +01:00
static void handle_cursor_motion(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, motion);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_pointer_motion *event = data;
roots_cursor_handle_motion(cursor, event);
2017-11-04 18:12:35 +01:00
}
2017-11-18 20:03:31 +01:00
static void handle_cursor_motion_absolute(struct wl_listener *listener,
void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, motion_absolute);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_pointer_motion_absolute *event = data;
roots_cursor_handle_motion_absolute(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_cursor_button(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, button);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_pointer_button *event = data;
roots_cursor_handle_button(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_cursor_axis(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, axis);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_pointer_axis *event = data;
roots_cursor_handle_axis(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_touch_down(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, touch_down);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_touch_down *event = data;
roots_cursor_handle_touch_down(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_touch_up(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, touch_up);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_touch_up *event = data;
roots_cursor_handle_touch_up(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_touch_motion(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, touch_motion);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_touch_motion *event = data;
roots_cursor_handle_touch_motion(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_tool_axis(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, tool_axis);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_tablet_tool_axis *event = data;
roots_cursor_handle_tool_axis(cursor, event);
2017-11-04 18:12:35 +01:00
}
static void handle_tool_tip(struct wl_listener *listener, void *data) {
2017-11-05 15:20:11 +01:00
struct roots_cursor *cursor =
wl_container_of(listener, cursor, tool_tip);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-05 15:20:11 +01:00
struct wlr_event_tablet_tool_tip *event = data;
roots_cursor_handle_tool_tip(cursor, event);
2017-11-04 18:12:35 +01:00
}
2017-11-08 21:23:56 +01:00
static void handle_request_set_cursor(struct wl_listener *listener,
void *data) {
struct roots_cursor *cursor =
wl_container_of(listener, cursor, request_set_cursor);
struct roots_desktop *desktop = cursor->seat->input->server->desktop;
wlr_idle_notify_activity(desktop->idle, cursor->seat->seat);
2017-11-08 21:23:56 +01:00
struct wlr_seat_pointer_request_set_cursor_event *event = data;
roots_cursor_handle_request_set_cursor(cursor, event);
}
2017-11-18 20:03:31 +01:00
static void seat_reset_device_mappings(struct roots_seat *seat,
struct wlr_input_device *device) {
2017-11-05 15:20:11 +01:00
struct wlr_cursor *cursor = seat->cursor->cursor;
2017-11-04 18:12:35 +01:00
struct roots_config *config = seat->input->config;
wlr_cursor_map_input_to_output(cursor, device, NULL);
struct roots_device_config *dconfig;
if ((dconfig = roots_config_get_device(config, device))) {
2017-11-04 18:12:35 +01:00
wlr_cursor_map_input_to_region(cursor, device, dconfig->mapped_box);
}
}
static void seat_set_device_output_mappings(struct roots_seat *seat,
struct wlr_input_device *device, struct wlr_output *output) {
2017-11-05 15:20:11 +01:00
struct wlr_cursor *cursor = seat->cursor->cursor;
2017-11-04 18:12:35 +01:00
struct roots_config *config = seat->input->config;
struct roots_device_config *dconfig =
roots_config_get_device(config, device);
const char *mapped_output = NULL;
if (dconfig != NULL) {
mapped_output = dconfig->mapped_output;
}
if (mapped_output == NULL) {
mapped_output = device->output_name;
}
if (mapped_output && strcmp(mapped_output, output->name) == 0) {
2017-11-04 18:12:35 +01:00
wlr_cursor_map_input_to_output(cursor, device, output);
}
}
2017-11-07 21:56:11 +01:00
void roots_seat_configure_cursor(struct roots_seat *seat) {
2017-11-04 18:12:35 +01:00
struct roots_config *config = seat->input->config;
struct roots_desktop *desktop = seat->input->server->desktop;
2017-11-05 15:20:11 +01:00
struct wlr_cursor *cursor = seat->cursor->cursor;
2017-11-04 18:12:35 +01:00
struct roots_pointer *pointer;
struct roots_touch *touch;
struct roots_tablet_tool *tablet_tool;
struct roots_output *output;
// reset mappings
wlr_cursor_map_to_output(cursor, NULL);
wl_list_for_each(pointer, &seat->pointers, link) {
seat_reset_device_mappings(seat, pointer->device);
}
wl_list_for_each(touch, &seat->touch, link) {
seat_reset_device_mappings(seat, touch->device);
}
wl_list_for_each(tablet_tool, &seat->tablet_tools, link) {
seat_reset_device_mappings(seat, tablet_tool->device);
}
// configure device to output mappings
2017-11-18 17:34:24 +01:00
const char *mapped_output = NULL;
struct roots_cursor_config *cc =
roots_config_get_cursor(config, seat->seat->name);
if (cc != NULL) {
mapped_output = cc->mapped_output;
}
2017-11-04 18:12:35 +01:00
wl_list_for_each(output, &desktop->outputs, link) {
2017-11-18 17:34:24 +01:00
if (mapped_output &&
strcmp(mapped_output, output->wlr_output->name) == 0) {
2017-11-04 18:12:35 +01:00
wlr_cursor_map_to_output(cursor, output->wlr_output);
}
wl_list_for_each(pointer, &seat->pointers, link) {
2017-11-18 17:34:24 +01:00
seat_set_device_output_mappings(seat, pointer->device,
output->wlr_output);
2017-11-04 18:12:35 +01:00
}
wl_list_for_each(tablet_tool, &seat->tablet_tools, link) {
2017-11-18 17:34:24 +01:00
seat_set_device_output_mappings(seat, tablet_tool->device,
output->wlr_output);
2017-11-04 18:12:35 +01:00
}
wl_list_for_each(touch, &seat->touch, link) {
2017-11-18 17:34:24 +01:00
seat_set_device_output_mappings(seat, touch->device,
output->wlr_output);
2017-11-04 18:12:35 +01:00
}
}
}
static void roots_seat_init_cursor(struct roots_seat *seat) {
2017-11-05 15:20:11 +01:00
seat->cursor = roots_cursor_create(seat);
if (!seat->cursor) {
2017-11-04 18:12:35 +01:00
return;
}
2017-11-07 21:56:11 +01:00
seat->cursor->seat = seat;
2017-11-05 15:20:11 +01:00
struct wlr_cursor *wlr_cursor = seat->cursor->cursor;
2017-11-04 18:12:35 +01:00
struct roots_desktop *desktop = seat->input->server->desktop;
2017-11-05 15:20:11 +01:00
wlr_cursor_attach_output_layout(wlr_cursor, desktop->layout);
2017-11-04 18:12:35 +01:00
2017-11-07 21:56:11 +01:00
roots_seat_configure_cursor(seat);
roots_seat_configure_xcursor(seat);
2017-11-07 21:56:11 +01:00
2017-11-04 18:12:35 +01:00
// add input signals
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.motion, &seat->cursor->motion);
seat->cursor->motion.notify = handle_cursor_motion;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.motion_absolute,
&seat->cursor->motion_absolute);
seat->cursor->motion_absolute.notify = handle_cursor_motion_absolute;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.button, &seat->cursor->button);
seat->cursor->button.notify = handle_cursor_button;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.axis, &seat->cursor->axis);
seat->cursor->axis.notify = handle_cursor_axis;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.touch_down, &seat->cursor->touch_down);
seat->cursor->touch_down.notify = handle_touch_down;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.touch_up, &seat->cursor->touch_up);
seat->cursor->touch_up.notify = handle_touch_up;
2017-11-04 18:12:35 +01:00
2017-11-18 20:03:31 +01:00
wl_signal_add(&wlr_cursor->events.touch_motion,
&seat->cursor->touch_motion);
2017-11-05 15:20:11 +01:00
seat->cursor->touch_motion.notify = handle_touch_motion;
2017-11-04 18:12:35 +01:00
2017-11-18 20:03:31 +01:00
wl_signal_add(&wlr_cursor->events.tablet_tool_axis,
&seat->cursor->tool_axis);
2017-11-05 15:20:11 +01:00
seat->cursor->tool_axis.notify = handle_tool_axis;
2017-11-04 18:12:35 +01:00
2017-11-05 15:20:11 +01:00
wl_signal_add(&wlr_cursor->events.tablet_tool_tip, &seat->cursor->tool_tip);
seat->cursor->tool_tip.notify = handle_tool_tip;
2017-11-08 21:23:56 +01:00
wl_signal_add(&seat->seat->events.request_set_cursor,
&seat->cursor->request_set_cursor);
2017-11-08 21:23:56 +01:00
seat->cursor->request_set_cursor.notify = handle_request_set_cursor;
2017-11-04 18:12:35 +01:00
}
static void roots_drag_icon_handle_surface_commit(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, surface_commit);
roots_drag_icon_damage_whole(icon);
}
static void roots_drag_icon_handle_map(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, map);
roots_drag_icon_damage_whole(icon);
}
static void roots_drag_icon_handle_destroy(struct wl_listener *listener,
void *data) {
struct roots_drag_icon *icon =
wl_container_of(listener, icon, destroy);
roots_drag_icon_damage_whole(icon);
wl_list_remove(&icon->link);
wl_list_remove(&icon->surface_commit.link);
wl_list_remove(&icon->map.link);
wl_list_remove(&icon->destroy.link);
free(icon);
}
static void roots_seat_handle_new_drag_icon(struct wl_listener *listener,
void *data) {
struct roots_seat *seat = wl_container_of(listener, seat, new_drag_icon);
struct wlr_drag_icon *wlr_drag_icon = data;
struct roots_drag_icon *icon = calloc(1, sizeof(struct roots_drag_icon));
if (icon == NULL) {
return;
}
icon->seat = seat;
icon->wlr_drag_icon = wlr_drag_icon;
icon->surface_commit.notify = roots_drag_icon_handle_surface_commit;
wl_signal_add(&wlr_drag_icon->surface->events.commit, &icon->surface_commit);
icon->map.notify = roots_drag_icon_handle_map;
wl_signal_add(&wlr_drag_icon->events.map, &icon->map);
icon->destroy.notify = roots_drag_icon_handle_destroy;
wl_signal_add(&wlr_drag_icon->events.destroy, &icon->destroy);
wl_list_insert(&seat->drag_icons, &icon->link);
}
void roots_drag_icon_update_position(struct roots_drag_icon *icon) {
roots_drag_icon_damage_whole(icon);
struct wlr_drag_icon *wlr_icon = icon->wlr_drag_icon;
struct roots_seat *seat = icon->seat;
struct wlr_cursor *cursor = seat->cursor->cursor;
if (wlr_icon->is_pointer) {
icon->x = cursor->x + wlr_icon->sx;
icon->y = cursor->y + wlr_icon->sy;
} else {
struct wlr_touch_point *point =
wlr_seat_touch_get_point(seat->seat, wlr_icon->touch_id);
if (point == NULL) {
return;
}
icon->x = seat->touch_x + wlr_icon->sx;
icon->y = seat->touch_y + wlr_icon->sy;
}
roots_drag_icon_damage_whole(icon);
}
void roots_drag_icon_damage_whole(struct roots_drag_icon *icon) {
struct roots_output *output;
wl_list_for_each(output, &icon->seat->input->server->desktop->outputs,
link) {
output_damage_whole_drag_icon(output, icon);
}
}
static void seat_view_destroy(struct roots_seat_view *seat_view);
static void roots_seat_handle_destroy(struct wl_listener *listener,
void *data) {
struct roots_seat *seat = wl_container_of(listener, seat, destroy);
// TODO: probably more to be freed here
wl_list_remove(&seat->destroy.link);
struct roots_seat_view *view, *nview;
wl_list_for_each_safe(view, nview, &seat->views, link) {
seat_view_destroy(view);
}
}
void roots_seat_destroy(struct roots_seat *seat) {
roots_seat_handle_destroy(&seat->destroy, seat->seat);
wlr_seat_destroy(seat->seat);
}
2017-11-03 14:01:34 +01:00
struct roots_seat *roots_seat_create(struct roots_input *input, char *name) {
struct roots_seat *seat = calloc(1, sizeof(struct roots_seat));
if (!seat) {
return NULL;
}
2017-11-07 21:56:11 +01:00
wl_list_init(&seat->keyboards);
wl_list_init(&seat->pointers);
wl_list_init(&seat->touch);
wl_list_init(&seat->tablet_tools);
2017-11-17 12:45:07 +01:00
wl_list_init(&seat->views);
wl_list_init(&seat->drag_icons);
2017-11-07 21:56:11 +01:00
2017-11-05 15:20:11 +01:00
seat->input = input;
2017-11-08 21:23:56 +01:00
seat->seat = wlr_seat_create(input->server->wl_display, name);
if (!seat->seat) {
2017-11-04 18:12:35 +01:00
free(seat);
return NULL;
}
2017-11-08 21:23:56 +01:00
roots_seat_init_cursor(seat);
if (!seat->cursor) {
wlr_seat_destroy(seat->seat);
2017-11-04 18:12:35 +01:00
free(seat);
return NULL;
}
2017-11-03 14:01:34 +01:00
wl_list_insert(&input->seats, &seat->link);
2017-11-05 15:20:11 +01:00
seat->new_drag_icon.notify = roots_seat_handle_new_drag_icon;
wl_signal_add(&seat->seat->events.new_drag_icon, &seat->new_drag_icon);
seat->destroy.notify = roots_seat_handle_destroy;
wl_signal_add(&seat->seat->events.destroy, &seat->destroy);
2017-11-03 14:01:34 +01:00
return seat;
2017-11-03 14:01:34 +01:00
}
2018-01-16 20:33:55 +01:00
static void seat_update_capabilities(struct roots_seat *seat) {
uint32_t caps = 0;
if (!wl_list_empty(&seat->keyboards)) {
caps |= WL_SEAT_CAPABILITY_KEYBOARD;
}
if (!wl_list_empty(&seat->pointers) || !wl_list_empty(&seat->tablet_tools)) {
caps |= WL_SEAT_CAPABILITY_POINTER;
}
if (!wl_list_empty(&seat->touch)) {
caps |= WL_SEAT_CAPABILITY_TOUCH;
}
wlr_seat_set_capabilities(seat->seat, caps);
// Hide cursor if seat doesn't have pointer capability
if ((caps & WL_SEAT_CAPABILITY_POINTER) == 0) {
wlr_cursor_set_image(seat->cursor->cursor, NULL, 0, 0, 0, 0, 0, 0);
} else {
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
seat->cursor->default_xcursor, seat->cursor->cursor);
}
2018-01-16 20:33:55 +01:00
}
static void handle_keyboard_destroy(struct wl_listener *listener, void *data) {
struct roots_keyboard *keyboard =
wl_container_of(listener, keyboard, device_destroy);
struct roots_seat *seat = keyboard->seat;
wl_list_remove(&keyboard->device_destroy.link);
wl_list_remove(&keyboard->keyboard_key.link);
wl_list_remove(&keyboard->keyboard_modifiers.link);
roots_keyboard_destroy(keyboard);
seat_update_capabilities(seat);
}
2017-11-18 20:03:31 +01:00
static void seat_add_keyboard(struct roots_seat *seat,
struct wlr_input_device *device) {
2017-11-07 21:56:11 +01:00
assert(device->type == WLR_INPUT_DEVICE_KEYBOARD);
2017-11-18 20:03:31 +01:00
struct roots_keyboard *keyboard =
roots_keyboard_create(device, seat->input);
2017-11-10 00:32:54 +01:00
if (keyboard == NULL) {
wlr_log(L_ERROR, "could not allocate keyboard for seat");
return;
}
2017-11-03 14:01:34 +01:00
keyboard->seat = seat;
2017-11-04 18:12:35 +01:00
2017-11-08 15:04:33 +01:00
wl_list_insert(&seat->keyboards, &keyboard->link);
2017-11-03 14:01:34 +01:00
keyboard->device_destroy.notify = handle_keyboard_destroy;
wl_signal_add(&keyboard->device->events.destroy, &keyboard->device_destroy);
2017-11-03 14:01:34 +01:00
keyboard->keyboard_key.notify = handle_keyboard_key;
wl_signal_add(&keyboard->device->keyboard->events.key,
&keyboard->keyboard_key);
keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers;
wl_signal_add(&keyboard->device->keyboard->events.modifiers,
&keyboard->keyboard_modifiers);
2017-11-12 18:15:39 +01:00
wlr_seat_set_keyboard(seat->seat, device);
2017-11-03 14:01:34 +01:00
}
static void handle_pointer_destroy(struct wl_listener *listener, void *data) {
struct roots_pointer *pointer =
wl_container_of(listener, pointer, device_destroy);
struct roots_seat *seat = pointer->seat;
wl_list_remove(&pointer->link);
wlr_cursor_detach_input_device(seat->cursor->cursor, pointer->device);
wl_list_remove(&pointer->device_destroy.link);
free(pointer);
seat_update_capabilities(seat);
}
2017-11-18 20:03:31 +01:00
static void seat_add_pointer(struct roots_seat *seat,
struct wlr_input_device *device) {
2017-11-04 18:12:35 +01:00
struct roots_pointer *pointer = calloc(sizeof(struct roots_pointer), 1);
if (!pointer) {
wlr_log(L_ERROR, "could not allocate pointer for seat");
return;
}
device->data = pointer;
pointer->device = device;
pointer->seat = seat;
wl_list_insert(&seat->pointers, &pointer->link);
pointer->device_destroy.notify = handle_pointer_destroy;
wl_signal_add(&pointer->device->events.destroy, &pointer->device_destroy);
2017-11-05 15:20:11 +01:00
wlr_cursor_attach_input_device(seat->cursor->cursor, device);
2017-11-04 18:12:35 +01:00
roots_seat_configure_cursor(seat);
}
static void handle_touch_destroy(struct wl_listener *listener, void *data) {
struct roots_pointer *touch =
wl_container_of(listener, touch, device_destroy);
struct roots_seat *seat = touch->seat;
wl_list_remove(&touch->link);
wlr_cursor_detach_input_device(seat->cursor->cursor, touch->device);
wl_list_remove(&touch->device_destroy.link);
free(touch);
seat_update_capabilities(seat);
}
2017-11-18 20:03:31 +01:00
static void seat_add_touch(struct roots_seat *seat,
struct wlr_input_device *device) {
2017-11-04 18:12:35 +01:00
struct roots_touch *touch = calloc(sizeof(struct roots_touch), 1);
if (!touch) {
wlr_log(L_ERROR, "could not allocate touch for seat");
return;
}
device->data = touch;
touch->device = device;
touch->seat = seat;
wl_list_insert(&seat->touch, &touch->link);
touch->device_destroy.notify = handle_touch_destroy;
wl_signal_add(&touch->device->events.destroy, &touch->device_destroy);
2017-11-05 15:20:11 +01:00
wlr_cursor_attach_input_device(seat->cursor->cursor, device);
2017-11-04 18:12:35 +01:00
roots_seat_configure_cursor(seat);
}
2017-11-18 20:03:31 +01:00
static void seat_add_tablet_pad(struct roots_seat *seat,
struct wlr_input_device *device) {
2017-11-03 14:01:34 +01:00
// TODO
}
static void handle_tablet_tool_destroy(struct wl_listener *listener,
void *data) {
struct roots_tablet_tool *tablet_tool =
wl_container_of(listener, tablet_tool, device_destroy);
struct roots_seat *seat = tablet_tool->seat;
wlr_cursor_detach_input_device(seat->cursor->cursor, tablet_tool->device);
wl_list_remove(&tablet_tool->device_destroy.link);
wl_list_remove(&tablet_tool->link);
free(tablet_tool);
seat_update_capabilities(seat);
}
2017-11-18 20:03:31 +01:00
static void seat_add_tablet_tool(struct roots_seat *seat,
struct wlr_input_device *device) {
struct roots_tablet_tool *tablet_tool =
calloc(sizeof(struct roots_tablet_tool), 1);
2017-11-04 18:12:35 +01:00
if (!tablet_tool) {
wlr_log(L_ERROR, "could not allocate tablet_tool for seat");
return;
}
device->data = tablet_tool;
tablet_tool->device = device;
tablet_tool->seat = seat;
wl_list_insert(&seat->tablet_tools, &tablet_tool->link);
tablet_tool->device_destroy.notify = handle_tablet_tool_destroy;
wl_signal_add(&tablet_tool->device->events.destroy,
&tablet_tool->device_destroy);
2017-11-05 15:20:11 +01:00
wlr_cursor_attach_input_device(seat->cursor->cursor, device);
2017-11-04 18:12:35 +01:00
roots_seat_configure_cursor(seat);
}
void roots_seat_add_device(struct roots_seat *seat,
struct wlr_input_device *device) {
switch (device->type) {
case WLR_INPUT_DEVICE_KEYBOARD:
seat_add_keyboard(seat, device);
break;
case WLR_INPUT_DEVICE_POINTER:
seat_add_pointer(seat, device);
break;
case WLR_INPUT_DEVICE_TOUCH:
seat_add_touch(seat, device);
break;
case WLR_INPUT_DEVICE_TABLET_PAD:
seat_add_tablet_pad(seat, device);
break;
case WLR_INPUT_DEVICE_TABLET_TOOL:
seat_add_tablet_tool(seat, device);
break;
}
2018-01-16 20:33:55 +01:00
seat_update_capabilities(seat);
2017-11-04 18:12:35 +01:00
}
2017-11-07 21:56:11 +01:00
void roots_seat_configure_xcursor(struct roots_seat *seat) {
2017-11-18 17:34:24 +01:00
const char *cursor_theme = NULL;
struct roots_cursor_config *cc =
roots_config_get_cursor(seat->input->config, seat->seat->name);
if (cc != NULL) {
cursor_theme = cc->theme;
2017-12-11 10:36:22 +01:00
if (cc->default_image != NULL) {
seat->cursor->default_xcursor = cc->default_image;
}
2017-11-18 17:34:24 +01:00
}
2017-12-09 18:10:09 +01:00
if (!seat->cursor->xcursor_manager) {
seat->cursor->xcursor_manager =
wlr_xcursor_manager_create(cursor_theme, ROOTS_XCURSOR_SIZE);
if (seat->cursor->xcursor_manager == NULL) {
wlr_log(L_ERROR, "Cannot create XCursor manager for theme %s",
cursor_theme);
return;
}
2017-11-18 17:34:24 +01:00
}
struct roots_output *output;
wl_list_for_each(output, &seat->input->server->desktop->outputs, link) {
2017-12-15 01:00:03 +01:00
float scale = output->wlr_output->scale;
if (wlr_xcursor_manager_load(seat->cursor->xcursor_manager, scale)) {
wlr_log(L_ERROR, "Cannot load xcursor theme for output '%s' "
2017-12-15 01:00:03 +01:00
"with scale %f", output->wlr_output->name, scale);
}
}
2017-11-12 11:10:56 +01:00
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
2017-12-11 10:36:22 +01:00
seat->cursor->default_xcursor, seat->cursor->cursor);
2017-11-07 21:56:11 +01:00
wlr_cursor_warp(seat->cursor->cursor, NULL, seat->cursor->cursor->x,
seat->cursor->cursor->y);
}
bool roots_seat_has_meta_pressed(struct roots_seat *seat) {
struct roots_keyboard *keyboard;
2017-11-08 15:04:33 +01:00
wl_list_for_each(keyboard, &seat->keyboards, link) {
2017-11-07 21:56:11 +01:00
if (!keyboard->config->meta_key) {
continue;
}
uint32_t modifiers =
wlr_keyboard_get_modifiers(keyboard->device->keyboard);
if ((modifiers ^ keyboard->config->meta_key) == 0) {
return true;
}
}
return false;
}
struct roots_view *roots_seat_get_focus(struct roots_seat *seat) {
2017-11-19 18:15:11 +01:00
if (!seat->has_focus || wl_list_empty(&seat->views)) {
return NULL;
2017-11-07 21:56:11 +01:00
}
2017-11-19 18:15:11 +01:00
struct roots_seat_view *seat_view =
wl_container_of(seat->views.next, seat_view, link);
return seat_view->view;
2017-11-17 12:45:07 +01:00
}
static void seat_view_destroy(struct roots_seat_view *seat_view) {
struct roots_seat *seat = seat_view->seat;
if (seat_view->view == roots_seat_get_focus(seat)) {
2017-11-19 18:15:11 +01:00
seat->has_focus = false;
2017-11-17 12:45:07 +01:00
seat->cursor->mode = ROOTS_CURSOR_PASSTHROUGH;
}
2018-01-23 13:11:54 +01:00
if (seat_view == seat->cursor->pointer_view) {
seat->cursor->pointer_view = NULL;
}
2018-03-13 12:31:45 +01:00
wl_list_remove(&seat_view->view_unmap.link);
wl_list_remove(&seat_view->view_destroy.link);
2017-11-17 12:45:07 +01:00
wl_list_remove(&seat_view->link);
free(seat_view);
// Focus first view
if (!wl_list_empty(&seat->views)) {
struct roots_seat_view *first_seat_view = wl_container_of(
seat->views.next, first_seat_view, link);
2017-11-19 19:21:18 +01:00
roots_seat_set_focus(seat, first_seat_view->view);
2017-11-17 12:45:07 +01:00
}
}
2018-03-13 12:31:45 +01:00
static void seat_view_handle_unmap(struct wl_listener *listener, void *data) {
struct roots_seat_view *seat_view =
wl_container_of(listener, seat_view, view_unmap);
seat_view_destroy(seat_view);
}
2017-11-17 12:45:07 +01:00
static void seat_view_handle_destroy(struct wl_listener *listener, void *data) {
struct roots_seat_view *seat_view =
wl_container_of(listener, seat_view, view_destroy);
2017-11-17 12:45:07 +01:00
seat_view_destroy(seat_view);
}
2017-11-19 18:15:11 +01:00
static struct roots_seat_view *seat_add_view(struct roots_seat *seat,
struct roots_view *view) {
2017-11-17 12:45:07 +01:00
struct roots_seat_view *seat_view =
calloc(1, sizeof(struct roots_seat_view));
if (seat_view == NULL) {
2017-11-19 18:15:11 +01:00
return NULL;
2017-11-17 12:45:07 +01:00
}
seat_view->seat = seat;
seat_view->view = view;
2018-01-17 01:04:26 +01:00
wl_list_insert(seat->views.prev, &seat_view->link);
2017-11-17 12:45:07 +01:00
2018-03-13 12:31:45 +01:00
seat_view->view_unmap.notify = seat_view_handle_unmap;
wl_signal_add(&view->events.unmap, &seat_view->view_unmap);
seat_view->view_destroy.notify = seat_view_handle_destroy;
wl_signal_add(&view->events.destroy, &seat_view->view_destroy);
2017-11-19 18:15:11 +01:00
return seat_view;
2017-11-17 12:45:07 +01:00
}
2018-01-17 01:04:26 +01:00
struct roots_seat_view *roots_seat_view_from_view(
struct roots_seat *seat, struct roots_view *view) {
if (view == NULL) {
return NULL;
}
bool found = false;
struct roots_seat_view *seat_view = NULL;
wl_list_for_each(seat_view, &seat->views, link) {
if (seat_view->view == view) {
found = true;
break;
}
}
if (!found) {
seat_view = seat_add_view(seat, view);
if (seat_view == NULL) {
wlr_log(L_ERROR, "Allocation failed");
return NULL;
}
}
return seat_view;
}
2018-04-03 18:50:05 +02:00
bool roots_seat_allow_input(struct roots_seat *seat,
struct wl_resource *resource) {
return !seat->exclusive_client ||
wl_resource_get_client(resource) == seat->exclusive_client;
}
2017-11-19 19:21:18 +01:00
void roots_seat_set_focus(struct roots_seat *seat, struct roots_view *view) {
2018-04-03 18:50:05 +02:00
if (view && !roots_seat_allow_input(seat, view->wlr_surface->resource)) {
return;
}
// Make sure the view will be rendered on top of others, even if it's
// already focused in this seat
if (view != NULL) {
wl_list_remove(&view->link);
wl_list_insert(&seat->input->server->desktop->views, &view->link);
}
bool unfullscreen = true;
#ifdef WLR_HAS_XWAYLAND
if (view && view->type == ROOTS_XWAYLAND_VIEW &&
view->xwayland_surface->override_redirect) {
unfullscreen = false;
}
#endif
if (view && unfullscreen) {
struct roots_desktop *desktop = view->desktop;
struct roots_output *output;
struct wlr_box box;
view_get_box(view, &box);
wl_list_for_each(output, &desktop->outputs, link) {
if (output->fullscreen_view &&
output->fullscreen_view != view &&
wlr_output_layout_intersects(
desktop->layout,
output->wlr_output, &box)) {
view_set_fullscreen(output->fullscreen_view,
false, NULL);
}
}
}
struct roots_view *prev_focus = roots_seat_get_focus(seat);
2017-11-19 18:15:11 +01:00
if (view == prev_focus) {
return;
}
#ifdef WLR_HAS_XWAYLAND
2017-11-19 18:15:11 +01:00
if (view && view->type == ROOTS_XWAYLAND_VIEW &&
wlr_xwayland_surface_is_unmanaged(view->xwayland_surface)) {
2017-11-19 18:15:11 +01:00
return;
}
#endif
2017-11-19 18:15:11 +01:00
struct roots_seat_view *seat_view = NULL;
if (view != NULL) {
2018-01-17 01:04:26 +01:00
seat_view = roots_seat_view_from_view(seat, view);
if (seat_view == NULL) {
return;
2017-11-19 18:15:11 +01:00
}
}
seat->has_focus = false;
// Deactivate the old view if it is not focused by some other seat
2017-11-19 18:15:11 +01:00
if (prev_focus != NULL && !input_view_has_focus(seat->input, prev_focus)) {
view_activate(prev_focus, false);
}
if (view == NULL) {
seat->cursor->mode = ROOTS_CURSOR_PASSTHROUGH;
return;
2017-11-07 21:56:11 +01:00
}
2017-11-19 18:15:11 +01:00
wl_list_remove(&seat_view->link);
wl_list_insert(&seat->views, &seat_view->link);
2018-01-06 17:06:09 +01:00
view_damage_whole(view);
if (seat->focused_layer) {
return;
}
view_activate(view, true);
seat->has_focus = true;
2018-01-06 17:06:09 +01:00
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->seat);
if (keyboard != NULL) {
wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface,
keyboard->keycodes, keyboard->num_keycodes,
2018-01-17 14:31:15 +01:00
&keyboard->modifiers);
2018-01-06 17:06:09 +01:00
} else {
wlr_seat_keyboard_notify_enter(seat->seat, view->wlr_surface,
NULL, 0, NULL);
}
2017-11-07 21:56:11 +01:00
}
/**
* Focus semantics of layer surfaces are somewhat detached from the normal focus
* flow. For layers above the shell layer, for example, you cannot unfocus them.
* You also cannot alt-tab between layer surfaces and shell surfaces.
*/
void roots_seat_set_focus_layer(struct roots_seat *seat,
struct wlr_layer_surface *layer) {
if (!layer) {
seat->focused_layer = NULL;
return;
}
2018-04-03 18:50:05 +02:00
struct wlr_keyboard *keyboard = wlr_seat_get_keyboard(seat->seat);
if (!roots_seat_allow_input(seat, layer->resource)) {
return;
}
if (seat->has_focus) {
struct roots_view *prev_focus = roots_seat_get_focus(seat);
wlr_seat_keyboard_clear_focus(seat->seat);
view_activate(prev_focus, false);
}
seat->has_focus = false;
if (layer->layer >= ZWLR_LAYER_SHELL_V1_LAYER_TOP) {
seat->focused_layer = layer;
}
if (keyboard != NULL) {
wlr_seat_keyboard_notify_enter(seat->seat, layer->surface,
keyboard->keycodes, keyboard->num_keycodes,
&keyboard->modifiers);
} else {
wlr_seat_keyboard_notify_enter(seat->seat, layer->surface,
NULL, 0, NULL);
}
}
2018-04-03 18:50:05 +02:00
void roots_seat_set_exclusive_client(struct roots_seat *seat,
struct wl_client *client) {
if (!client) {
seat->exclusive_client = client;
// Triggers a refocus of the topmost surface layer if necessary
// TODO: Make layer surface focus per-output based on cursor position
struct roots_output *output;
wl_list_for_each(output, &seat->input->server->desktop->outputs, link) {
arrange_layers(output);
}
return;
}
if (seat->focused_layer) {
if (wl_resource_get_client(seat->focused_layer->resource) != client) {
roots_seat_set_focus_layer(seat, NULL);
}
}
if (seat->has_focus) {
struct roots_view *focus = roots_seat_get_focus(seat);
if (wl_resource_get_client(focus->wlr_surface->resource) != client) {
roots_seat_set_focus(seat, NULL);
}
}
if (seat->seat->pointer_state.focused_client) {
if (seat->seat->pointer_state.focused_client->client != client) {
wlr_seat_pointer_clear_focus(seat->seat);
}
}
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
struct wlr_touch_point *point;
wl_list_for_each(point, &seat->seat->touch_state.touch_points, link) {
if (point->client->client != client) {
wlr_seat_touch_point_clear_focus(seat->seat,
now.tv_nsec / 1000, point->touch_id);
}
}
seat->exclusive_client = client;
}
2017-11-19 19:21:18 +01:00
void roots_seat_cycle_focus(struct roots_seat *seat) {
if (wl_list_empty(&seat->views)) {
return;
}
2017-11-19 21:54:11 +01:00
struct roots_seat_view *first_seat_view = wl_container_of(
seat->views.next, first_seat_view, link);
if (!seat->has_focus) {
roots_seat_set_focus(seat, first_seat_view->view);
return;
}
if (wl_list_length(&seat->views) < 2) {
return;
}
// Focus the next view
struct roots_seat_view *next_seat_view = wl_container_of(
first_seat_view->link.next, next_seat_view, link);
roots_seat_set_focus(seat, next_seat_view->view);
// Move the first view to the end of the list
wl_list_remove(&first_seat_view->link);
wl_list_insert(seat->views.prev, &first_seat_view->link);
2017-11-19 19:21:18 +01:00
}
2017-11-07 21:56:11 +01:00
void roots_seat_begin_move(struct roots_seat *seat, struct roots_view *view) {
struct roots_cursor *cursor = seat->cursor;
cursor->mode = ROOTS_CURSOR_MOVE;
cursor->offs_x = cursor->cursor->x;
cursor->offs_y = cursor->cursor->y;
if (view->maximized) {
cursor->view_x = view->saved.x;
cursor->view_y = view->saved.y;
} else {
cursor->view_x = view->x;
cursor->view_y = view->y;
}
view_maximize(view, false);
2017-11-07 21:56:11 +01:00
wlr_seat_pointer_clear_focus(seat->seat);
2017-11-12 11:10:56 +01:00
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
ROOTS_XCURSOR_MOVE, seat->cursor->cursor);
2017-11-07 21:56:11 +01:00
}
void roots_seat_begin_resize(struct roots_seat *seat, struct roots_view *view,
uint32_t edges) {
2017-11-08 14:35:27 +01:00
struct roots_cursor *cursor = seat->cursor;
cursor->mode = ROOTS_CURSOR_RESIZE;
cursor->offs_x = cursor->cursor->x;
cursor->offs_y = cursor->cursor->y;
if (view->maximized) {
cursor->view_x = view->saved.x;
cursor->view_y = view->saved.y;
cursor->view_width = view->saved.width;
cursor->view_height = view->saved.height;
} else {
cursor->view_x = view->x;
cursor->view_y = view->y;
struct wlr_box box;
view_get_box(view, &box);
cursor->view_width = box.width;
cursor->view_height = box.height;
}
2017-11-08 14:35:27 +01:00
cursor->resize_edges = edges;
view_maximize(view, false);
2017-11-08 14:35:27 +01:00
wlr_seat_pointer_clear_focus(seat->seat);
2017-12-08 12:08:06 +01:00
const char *resize_name = wlr_xcursor_get_resize_name(edges);
2017-11-12 11:10:56 +01:00
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
2017-12-07 17:19:43 +01:00
resize_name, seat->cursor->cursor);
2017-11-07 21:56:11 +01:00
}
void roots_seat_begin_rotate(struct roots_seat *seat, struct roots_view *view) {
2017-11-08 14:35:27 +01:00
struct roots_cursor *cursor = seat->cursor;
cursor->mode = ROOTS_CURSOR_ROTATE;
cursor->offs_x = cursor->cursor->x;
cursor->offs_y = cursor->cursor->y;
cursor->view_rotation = view->rotation;
view_maximize(view, false);
2017-11-08 14:35:27 +01:00
wlr_seat_pointer_clear_focus(seat->seat);
2017-11-12 11:10:56 +01:00
wlr_xcursor_manager_set_cursor_image(seat->cursor->xcursor_manager,
ROOTS_XCURSOR_ROTATE, seat->cursor->cursor);
2017-11-07 21:56:11 +01:00
}
2018-02-08 13:13:33 +01:00
void roots_seat_end_compositor_grab(struct roots_seat *seat) {
struct roots_cursor *cursor = seat->cursor;
struct roots_view *view = roots_seat_get_focus(seat);
if (view == NULL) {
return;
}
switch(cursor->mode) {
case ROOTS_CURSOR_MOVE:
view_move(view, cursor->view_x, cursor->view_y);
break;
case ROOTS_CURSOR_RESIZE:
view_move_resize(view, cursor->view_x, cursor->view_y, cursor->view_width, cursor->view_height);
break;
case ROOTS_CURSOR_ROTATE:
view->rotation = cursor->view_rotation;
break;
case ROOTS_CURSOR_PASSTHROUGH:
break;
}
cursor->mode = ROOTS_CURSOR_PASSTHROUGH;
}
struct roots_seat *input_last_active_seat(struct roots_input *input) {
struct roots_seat *seat = NULL, *_seat;
wl_list_for_each(_seat, &input->seats, link) {
if (!seat || (seat->seat->last_event.tv_sec > _seat->seat->last_event.tv_sec &&
seat->seat->last_event.tv_nsec > _seat->seat->last_event.tv_nsec)) {
seat = _seat;
}
}
return seat;
}