itycodes
/
convince
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sway input device

Browse Source
master
Tony Crisci 7 years ago
parent 462a451328
commit 163edc5a90
14 changed files with 237 additions and 194 deletions
Show Stats Download Patch File Download Diff File

1
include/sway/config.h
Unescape View File

@ -355,6 +355,7 @@ char *do_var_replacement(char *str);
struct cmd_results *check_security_config();
int input_identifier_cmp(const void *item, const void *data);
struct input_config *new_input_config(const char* identifier);
void merge_input_config(struct input_config *dst, struct input_config *src);
void apply_input_config(struct input_config *ic, struct libinput_device *dev);
void free_input_config(struct input_config *ic);

31
include/sway/input/input-manager.h
Unescape View File

@ -7,21 +7,40 @@
extern struct input_config *current_input_config;
/**
* The global singleton input manager
* TODO: make me not a global
*/
extern struct sway_input_manager *input_manager;
struct sway_input_device {
char *identifier;
struct wlr_input_device *wlr_device;
struct input_config *config;
struct sway_keyboard *keyboard; // managed by the seat
struct wl_list link;
};
struct sway_input_manager {
struct wl_listener input_add;
struct wl_listener input_remove;
struct sway_server *server;
list_t *seats;
struct wl_list devices;
struct wl_list seats;
};
struct input_config *new_input_config(const char* identifier);
char* libinput_dev_unique_id(struct libinput_device *dev);
struct sway_input_manager *sway_input_manager_create(
struct sway_server *server);
bool sway_input_manager_swayc_has_focus(struct sway_input_manager *input,
bool sway_input_manager_has_focus(struct sway_input_manager *input,
swayc_t *container);
void sway_input_manager_set_focus(struct sway_input_manager *input,
swayc_t *container);
void sway_input_manager_configure_xcursor(struct sway_input_manager *input);
void sway_input_manager_apply_config(struct sway_input_manager *input,
struct input_config *config);
#endif

4
include/sway/input/keyboard.h
Unescape View File

@ -2,7 +2,7 @@
struct sway_keyboard {
struct sway_seat *seat;
struct wlr_input_device *device;
struct sway_input_device *device;
struct wl_list link; // sway_seat::keyboards
struct wl_listener keyboard_key;
@ -10,6 +10,6 @@ struct sway_keyboard {
};
struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
struct wlr_input_device *device);
struct sway_input_device *device);
void sway_keyboard_destroy(struct sway_keyboard *keyboard);

13
include/sway/input/seat.h
Unescape View File

@ -10,26 +10,21 @@ struct sway_seat {
struct sway_input_manager *input;
swayc_t *focus;
struct wl_list keyboards; // sway_keyboard::link
struct wl_list pointers; // sway_pointer::link
list_t *devices;
struct wl_listener focus_destroy;
};
struct sway_pointer {
struct sway_seat *seat;
struct wlr_input_device *device;
struct wl_list link;
struct wl_list link; // input_manager::seats
};
struct sway_seat *sway_seat_create(struct sway_input_manager *input,
const char *seat_name);
void sway_seat_add_device(struct sway_seat *seat,
struct wlr_input_device *device);
struct sway_input_device *device);
void sway_seat_remove_device(struct sway_seat *seat,
struct wlr_input_device *device);
struct sway_input_device *device);
void sway_seat_configure_xcursor(struct sway_seat *seat);

23
sway/commands.c
Unescape View File

@ -71,28 +71,7 @@ void input_cmd_apply(struct input_config *input) {
}
current_input_config = input;
if (input->identifier) {
// Try to find the input device and apply configuration now. If
// this is during startup then there will be no container and config
// will be applied during normal "new input" event from wlc.
/* TODO WLR
struct libinput_device *device = NULL;
for (int i = 0; i < input_devices->length; ++i) {
device = input_devices->items[i];
char* dev_identifier = libinput_dev_unique_id(device);
if (!dev_identifier) {
break;
}
int match = dev_identifier && strcmp(dev_identifier, input->identifier) == 0;
free(dev_identifier);
if (match) {
apply_input_config(input, device);
break;
}
}
*/
}
sway_input_manager_apply_config(input_manager, input);
}
/**

29
sway/config.c
Unescape View File

@ -226,6 +226,34 @@ static int qstrcmp(const void* a, const void* b) {
return strcmp(*((char**) a), *((char**) b));
}
struct input_config *new_input_config(const char* identifier) {
struct input_config *input = calloc(1, sizeof(struct input_config));
if (!input) {
sway_log(L_DEBUG, "Unable to allocate input config");
return NULL;
}
sway_log(L_DEBUG, "new_input_config(%s)", identifier);
if (!(input->identifier = strdup(identifier))) {
free(input);
sway_log(L_DEBUG, "Unable to allocate input config");
return NULL;
}
input->tap = INT_MIN;
input->drag_lock = INT_MIN;
input->dwt = INT_MIN;
input->send_events = INT_MIN;
input->click_method = INT_MIN;
input->middle_emulation = INT_MIN;
input->natural_scroll = INT_MIN;
input->accel_profile = INT_MIN;
input->pointer_accel = FLT_MIN;
input->scroll_method = INT_MIN;
input->left_handed = INT_MIN;
return input;
}
void merge_input_config(struct input_config *dst, struct input_config *src) {
if (src->identifier) {
if (dst->identifier) {
@ -453,6 +481,7 @@ bool load_include_configs(const char *path, struct sway_config *config) {
return true;
}
bool read_config(FILE *file, struct sway_config *config) {
bool success = true;
enum cmd_status block = CMD_BLOCK_END;

5
sway/desktop/output.c
Unescape View File

@ -136,10 +136,7 @@ void output_add_notify(struct wl_listener *listener, void *data) {
output->resolution.notify = output_resolution_notify;
wl_signal_add(&wlr_output->events.resolution, &output->resolution);
for (int i = 0; i < server->input->seats->length; ++i) {
struct sway_seat *seat = server->input->seats->items[i];
sway_seat_configure_xcursor(seat);
}
sway_input_manager_configure_xcursor(input_manager);
arrange_windows(output->swayc, -1, -1);
}

5
sway/desktop/wl_shell.c
Unescape View File

@ -129,8 +129,5 @@ void handle_wl_shell_surface(struct wl_listener *listener, void *data) {
arrange_windows(cont->parent, -1, -1);
for (int i = 0; i < server->input->seats->length; ++i) {
struct sway_seat *seat = server->input->seats->items[i];
sway_seat_set_focus(seat, cont);
}
sway_input_manager_set_focus(input_manager, cont);
}

5
sway/desktop/xdg_shell_v6.c
Unescape View File

@ -135,8 +135,5 @@ void handle_xdg_shell_v6_surface(struct wl_listener *listener, void *data) {
arrange_windows(cont->parent, -1, -1);
for (int i = 0; i < server->input->seats->length; ++i) {
struct sway_seat *seat = server->input->seats->items[i];
sway_seat_set_focus(seat, cont);
}
sway_input_manager_set_focus(input_manager, cont);
}

6
sway/desktop/xwayland.c
Unescape View File

@ -173,9 +173,5 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
sway_view->swayc = cont;
arrange_windows(cont->parent, -1, -1);
for (int i = 0; i < server->input->seats->length; ++i) {
struct sway_seat *seat = server->input->seats->items[i];
sway_seat_set_focus(seat, cont);
}
sway_input_manager_set_focus(input_manager, cont);
}

185
sway/input/input-manager.c
Unescape View File

@ -14,23 +14,70 @@
static const char *default_seat = "seat0";
// TODO make me not global
struct sway_input_manager *input_manager;
struct input_config *current_input_config = NULL;
static struct sway_seat *input_manager_get_seat(
struct sway_input_manager *input, const char *seat_name) {
struct sway_seat *seat = NULL;
for (int i = 0; i < input->seats->length; ++i) {
seat = input->seats->items[i];
wl_list_for_each(seat, &input->seats, link) {
if (strcmp(seat->seat->name, seat_name) == 0) {
return seat;
}
}
seat = sway_seat_create(input, seat_name);
list_add(input->seats, seat);
return sway_seat_create(input, seat_name);
}
static char *get_device_identifier(struct wlr_input_device *device) {
int vendor = device->vendor;
int product = device->product;
char *name = strdup(device->name);
char *p = name;
for (; *p; ++p) {
if (*p == ' ') {
*p = '_';
}
}
sway_log(L_DEBUG, "rewritten name %s", name);
int len = strlen(name) + sizeof(char) * 6;
char *identifier = malloc(len);
if (!identifier) {
sway_log(L_ERROR, "Unable to allocate unique input device name");
return NULL;
}
const char *fmt = "%d:%d:%s";
snprintf(identifier, len, fmt, vendor, product, name);
free(name);
return identifier;
}
return seat;
static struct sway_input_device *input_sway_device_from_wlr(struct sway_input_manager *input,
struct wlr_input_device *device) {
struct sway_input_device *sway_device = NULL;
wl_list_for_each(sway_device, &input->devices, link) {
if (sway_device->wlr_device == device) {
return sway_device;
}
}
return NULL;
}
static struct sway_input_device *input_sway_device_from_config(struct sway_input_manager *input,
struct input_config *config) {
struct sway_input_device *sway_device = NULL;
wl_list_for_each(sway_device, &input->devices, link) {
if (strcmp(sway_device->identifier, config->identifier) == 0) {
return sway_device;
}
}
return NULL;
}
static void input_add_notify(struct wl_listener *listener, void *data) {
@ -38,9 +85,27 @@ static void input_add_notify(struct wl_listener *listener, void *data) {
wl_container_of(listener, input, input_add);
struct wlr_input_device *device = data;
// TODO device configuration
struct sway_input_device *sway_device =
calloc(1, sizeof(struct sway_input_device));
if (!sway_assert(sway_device, "could not allocate input device")) {
return;
}
sway_device->wlr_device = device;
sway_device->identifier = get_device_identifier(device);
wl_list_insert(&input->devices, &sway_device->link);
// find config
for (int i = 0; i < config->input_configs->length; ++i) {
struct input_config *input_config = config->input_configs->items[i];
if (strcmp(input_config->identifier, sway_device->identifier) == 0) {
sway_device->config = input_config;
break;
}
}
struct sway_seat *seat = input_manager_get_seat(input, default_seat);
sway_seat_add_device(seat, device);
sway_seat_add_device(seat, sway_device);
}
static void input_remove_notify(struct wl_listener *listener, void *data) {
@ -48,9 +113,21 @@ static void input_remove_notify(struct wl_listener *listener, void *data) {
wl_container_of(listener, input, input_remove);
struct wlr_input_device *device = data;
// TODO device configuration
struct sway_seat *seat = input_manager_get_seat(input, default_seat);
sway_seat_remove_device(seat, device);
struct sway_input_device *sway_device =
input_sway_device_from_wlr(input, device);
if (!sway_assert(sway_device, "could not find sway device")) {
return;
}
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input->seats, link) {
sway_seat_remove_device(seat, sway_device);
}
wl_list_remove(&sway_device->link);
free(sway_device->identifier);
free(sway_device);
}
struct sway_input_manager *sway_input_manager_create(
@ -63,7 +140,8 @@ struct sway_input_manager *sway_input_manager_create(
// XXX probably don't need the full server
input->server = server;
input->seats = create_list();
wl_list_init(&input->devices);
wl_list_init(&input->seats);
// create the default seat
input_manager_get_seat(input, default_seat);
@ -77,69 +155,46 @@ struct sway_input_manager *sway_input_manager_create(
return input;
}
struct input_config *new_input_config(const char* identifier) {
struct input_config *input = calloc(1, sizeof(struct input_config));
if (!input) {
sway_log(L_DEBUG, "Unable to allocate input config");
return NULL;
}
sway_log(L_DEBUG, "new_input_config(%s)", identifier);
if (!(input->identifier = strdup(identifier))) {
free(input);
sway_log(L_DEBUG, "Unable to allocate input config");
return NULL;
bool sway_input_manager_has_focus(struct sway_input_manager *input,
swayc_t *container) {
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input->seats, link) {
if (seat->focus == container) {
return true;
}
}
input->tap = INT_MIN;
input->drag_lock = INT_MIN;
input->dwt = INT_MIN;
input->send_events = INT_MIN;
input->click_method = INT_MIN;
input->middle_emulation = INT_MIN;
input->natural_scroll = INT_MIN;
input->accel_profile = INT_MIN;
input->pointer_accel = FLT_MIN;
input->scroll_method = INT_MIN;
input->left_handed = INT_MIN;
return input;
return false;
}
char *libinput_dev_unique_id(struct libinput_device *device) {
int vendor = libinput_device_get_id_vendor(device);
int product = libinput_device_get_id_product(device);
char *name = strdup(libinput_device_get_name(device));
char *p = name;
for (; *p; ++p) {
if (*p == ' ') {
*p = '_';
}
void sway_input_manager_set_focus(struct sway_input_manager *input,
swayc_t *container) {
struct sway_seat *seat ;
wl_list_for_each(seat, &input->seats, link) {
sway_seat_set_focus(seat, container);
}
}
sway_log(L_DEBUG, "rewritten name %s", name);
void sway_input_manager_apply_config(struct sway_input_manager *input,
struct input_config *config) {
struct sway_input_device *sway_device =
input_sway_device_from_config(input, config);
if (!sway_device) {
return;
}
int len = strlen(name) + sizeof(char) * 6;
char *identifier = malloc(len);
if (!identifier) {
sway_log(L_ERROR, "Unable to allocate unique input device name");
return NULL;
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input->seats, link) {
sway_seat_remove_device(seat, sway_device);
}
const char *fmt = "%d:%d:%s";
snprintf(identifier, len, fmt, vendor, product, name);
free(name);
return identifier;
seat = input_manager_get_seat(input, default_seat);
sway_seat_add_device(seat, sway_device);
}
bool sway_input_manager_swayc_has_focus(struct sway_input_manager *input,
swayc_t *container) {
for (int i = 0; i < input->seats->length; ++i) {
struct sway_seat *seat = input->seats->items[i];
if (seat->focus == container) {
return true;
}
void sway_input_manager_configure_xcursor(struct sway_input_manager *input) {
struct sway_seat *seat = NULL;
wl_list_for_each(seat, &input->seats, link) {
sway_seat_configure_xcursor(seat);
}
return false;
}

18
sway/input/keyboard.c
Unescape View File

@ -6,7 +6,7 @@ static void handle_keyboard_key(struct wl_listener *listener, void *data) {
struct sway_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_key);
struct wlr_event_keyboard_key *event = data;
wlr_seat_set_keyboard(keyboard->seat->seat, keyboard->device);
wlr_seat_set_keyboard(keyboard->seat->seat, keyboard->device->wlr_device);
wlr_seat_keyboard_notify_key(keyboard->seat->seat, event->time_msec,
event->keycode, event->state);
}
@ -15,12 +15,12 @@ static void handle_keyboard_modifiers(struct wl_listener *listener,
void *data) {
struct sway_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_modifiers);
wlr_seat_set_keyboard(keyboard->seat->seat, keyboard->device);
wlr_seat_set_keyboard(keyboard->seat->seat, keyboard->device->wlr_device);
wlr_seat_keyboard_notify_modifiers(keyboard->seat->seat);
}
struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_input_device *device) {
struct sway_keyboard *keyboard =
calloc(1, sizeof(struct sway_keyboard));
if (!sway_assert(keyboard, "could not allocate sway keyboard")) {
@ -43,18 +43,18 @@ struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
return NULL;
}
wlr_keyboard_set_keymap(device->keyboard, xkb_map_new_from_names(context,
&rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
wlr_keyboard_set_keymap(device->wlr_device->keyboard,
xkb_map_new_from_names(context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_context_unref(context);
wl_signal_add(&device->keyboard->events.key, &keyboard->keyboard_key);
wl_signal_add(&device->wlr_device->keyboard->events.key,
&keyboard->keyboard_key);
keyboard->keyboard_key.notify = handle_keyboard_key;
wl_signal_add(&device->keyboard->events.modifiers, &keyboard->keyboard_modifiers);
wl_signal_add(&device->wlr_device->keyboard->events.modifiers,
&keyboard->keyboard_modifiers);
keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers;
wl_list_insert(&seat->keyboards, &keyboard->link);
return keyboard;
}

104
sway/input/seat.c
Unescape View File

@ -29,6 +29,7 @@ struct sway_seat *sway_seat_create(struct sway_input_manager *input,
}
seat->input = input;
seat->devices = create_list();
wlr_seat_set_capabilities(seat->seat,
WL_SEAT_CAPABILITY_KEYBOARD |
@ -37,67 +38,38 @@ struct sway_seat *sway_seat_create(struct sway_input_manager *input,
sway_seat_configure_xcursor(seat);
wl_list_init(&seat->keyboards);
wl_list_insert(&input->seats, &seat->link);
return seat;
}
static struct sway_pointer *seat_pointer_from_device(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_pointer *pointer = NULL;
wl_list_for_each(pointer, &seat->pointers, link) {
if (pointer->device == device) {
return pointer;
}
}
return pointer;
}
static struct sway_keyboard *seat_keyboard_from_device(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_keyboard *keyboard = NULL;
wl_list_for_each(keyboard, &seat->keyboards, link) {
if (keyboard->device == device) {
return keyboard;
}
}
return keyboard;
}
static void seat_add_pointer(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_input_device *sway_device) {
// TODO pointer configuration
if (seat_pointer_from_device(seat, device)) {
// already added
return;
}
struct sway_pointer *pointer = calloc(1, sizeof(struct sway_pointer));
pointer->seat = seat;
pointer->device = device;
wl_list_insert(&seat->pointers, &pointer->link);
wlr_cursor_attach_input_device(seat->cursor->cursor, device);
wlr_cursor_attach_input_device(seat->cursor->cursor,
sway_device->wlr_device);
}
static void seat_add_keyboard(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_input_device *device) {
// TODO keyboard configuration
if (seat_keyboard_from_device(seat, device)) {
// already added
return;
}
sway_keyboard_create(seat, device);
wlr_seat_set_keyboard(seat->seat, device);
wlr_seat_set_keyboard(seat->seat, device->wlr_device);
}
bool sway_seat_has_device(struct sway_seat *seat,
struct sway_input_device *device) {
return false;
}
void sway_seat_add_device(struct sway_seat *seat,
struct wlr_input_device *device) {
sway_log(L_DEBUG, "input add: %s", device->name);
switch (device->type) {
struct sway_input_device *device) {
if (sway_seat_has_device(seat, device)) {
return;
}
sway_log(L_DEBUG, "input add: %s", device->identifier);
switch (device->wlr_device->type) {
case WLR_INPUT_DEVICE_POINTER:
seat_add_pointer(seat, device);
break;
@ -110,31 +82,30 @@ void sway_seat_add_device(struct sway_seat *seat,
sway_log(L_DEBUG, "TODO: add other devices");
break;
}
list_add(seat->devices, device);
}
static void seat_remove_keyboard(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_keyboard *keyboard = seat_keyboard_from_device(seat, device);
if (keyboard) {
sway_keyboard_destroy(keyboard);
struct sway_input_device *device) {
if (device && device->keyboard) {
sway_keyboard_destroy(device->keyboard);
}
}
static void seat_remove_pointer(struct sway_seat *seat,
struct wlr_input_device *device) {
struct sway_pointer *pointer = seat_pointer_from_device(seat, device);
if (pointer) {
wl_list_remove(&pointer->link);
free(pointer);
wlr_cursor_detach_input_device(seat->cursor->cursor, device);
}
struct sway_input_device *device) {
wlr_cursor_detach_input_device(seat->cursor->cursor, device->wlr_device);
}
void sway_seat_remove_device(struct sway_seat *seat,
struct wlr_input_device *device) {
sway_log(L_DEBUG, "input remove: %s", device->name);
switch (device->type) {
struct sway_input_device *device) {
sway_log(L_DEBUG, "input remove: %s", device->identifier);
if (!sway_seat_has_device(seat, device)) {
return;
}
switch (device->wlr_device->type) {
case WLR_INPUT_DEVICE_POINTER:
seat_remove_pointer(seat, device);
break;
@ -147,6 +118,13 @@ void sway_seat_remove_device(struct sway_seat *seat,
sway_log(L_DEBUG, "TODO: remove other devices");
break;
}
for (int i = 0; i < seat->devices->length; ++i) {
if (seat->devices->items[i] == device) {
list_del(seat->devices, i);
break;
}
}
}
void sway_seat_configure_xcursor(struct sway_seat *seat) {
@ -211,7 +189,7 @@ void sway_seat_set_focus(struct sway_seat *seat, swayc_t *container) {
seat->focus = container;
if (last_focus &&
!sway_input_manager_swayc_has_focus(seat->input, last_focus)) {
!sway_input_manager_has_focus(seat->input, last_focus)) {
struct sway_view *view = last_focus->sway_view;
view->iface.set_activated(view, false);

2
sway/server.c
Unescape View File

@ -60,7 +60,7 @@ bool server_init(struct sway_server *server) {
return false;
}
server->input = sway_input_manager_create(server);
input_manager = sway_input_manager_create(server);
return true;
}

Write Preview
Loading…
Cancel
Save