5b1a8d62b9
This allows for an optional validation stage when storing an input config. Currently, only the xkb keymap is validated. If storing the delta input config will result in any invalid xkb keymaps, the input config will not be stored and error will be populated with the first line of the xkbcommon log.
320 lines
8.3 KiB
C
320 lines
8.3 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
#include <stdlib.h>
|
|
#include <limits.h>
|
|
#include <float.h>
|
|
#include "sway/config.h"
|
|
#include "sway/input/keyboard.h"
|
|
#include "log.h"
|
|
|
|
struct input_config *new_input_config(const char* identifier) {
|
|
struct input_config *input = calloc(1, sizeof(struct input_config));
|
|
if (!input) {
|
|
sway_log(SWAY_DEBUG, "Unable to allocate input config");
|
|
return NULL;
|
|
}
|
|
sway_log(SWAY_DEBUG, "new_input_config(%s)", identifier);
|
|
if (!(input->identifier = strdup(identifier))) {
|
|
free(input);
|
|
sway_log(SWAY_DEBUG, "Unable to allocate input config");
|
|
return NULL;
|
|
}
|
|
|
|
input->input_type = NULL;
|
|
input->tap = INT_MIN;
|
|
input->tap_button_map = INT_MIN;
|
|
input->drag = 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_factor = FLT_MIN;
|
|
input->scroll_button = INT_MIN;
|
|
input->scroll_method = INT_MIN;
|
|
input->left_handed = INT_MIN;
|
|
input->repeat_delay = INT_MIN;
|
|
input->repeat_rate = INT_MIN;
|
|
input->xkb_numlock = INT_MIN;
|
|
input->xkb_capslock = INT_MIN;
|
|
|
|
return input;
|
|
}
|
|
|
|
void merge_input_config(struct input_config *dst, struct input_config *src) {
|
|
if (src->accel_profile != INT_MIN) {
|
|
dst->accel_profile = src->accel_profile;
|
|
}
|
|
if (src->click_method != INT_MIN) {
|
|
dst->click_method = src->click_method;
|
|
}
|
|
if (src->drag != INT_MIN) {
|
|
dst->drag = src->drag;
|
|
}
|
|
if (src->drag_lock != INT_MIN) {
|
|
dst->drag_lock = src->drag_lock;
|
|
}
|
|
if (src->dwt != INT_MIN) {
|
|
dst->dwt = src->dwt;
|
|
}
|
|
if (src->left_handed != INT_MIN) {
|
|
dst->left_handed = src->left_handed;
|
|
}
|
|
if (src->middle_emulation != INT_MIN) {
|
|
dst->middle_emulation = src->middle_emulation;
|
|
}
|
|
if (src->natural_scroll != INT_MIN) {
|
|
dst->natural_scroll = src->natural_scroll;
|
|
}
|
|
if (src->pointer_accel != FLT_MIN) {
|
|
dst->pointer_accel = src->pointer_accel;
|
|
}
|
|
if (src->scroll_factor != FLT_MIN) {
|
|
dst->scroll_factor = src->scroll_factor;
|
|
}
|
|
if (src->repeat_delay != INT_MIN) {
|
|
dst->repeat_delay = src->repeat_delay;
|
|
}
|
|
if (src->repeat_rate != INT_MIN) {
|
|
dst->repeat_rate = src->repeat_rate;
|
|
}
|
|
if (src->scroll_method != INT_MIN) {
|
|
dst->scroll_method = src->scroll_method;
|
|
}
|
|
if (src->scroll_button != INT_MIN) {
|
|
dst->scroll_button = src->scroll_button;
|
|
}
|
|
if (src->send_events != INT_MIN) {
|
|
dst->send_events = src->send_events;
|
|
}
|
|
if (src->tap != INT_MIN) {
|
|
dst->tap = src->tap;
|
|
}
|
|
if (src->tap_button_map != INT_MIN) {
|
|
dst->tap_button_map = src->tap_button_map;
|
|
}
|
|
if (src->xkb_layout) {
|
|
free(dst->xkb_layout);
|
|
dst->xkb_layout = strdup(src->xkb_layout);
|
|
}
|
|
if (src->xkb_model) {
|
|
free(dst->xkb_model);
|
|
dst->xkb_model = strdup(src->xkb_model);
|
|
}
|
|
if (src->xkb_options) {
|
|
free(dst->xkb_options);
|
|
dst->xkb_options = strdup(src->xkb_options);
|
|
}
|
|
if (src->xkb_rules) {
|
|
free(dst->xkb_rules);
|
|
dst->xkb_rules = strdup(src->xkb_rules);
|
|
}
|
|
if (src->xkb_variant) {
|
|
free(dst->xkb_variant);
|
|
dst->xkb_variant = strdup(src->xkb_variant);
|
|
}
|
|
if (src->xkb_numlock != INT_MIN) {
|
|
dst->xkb_numlock = src->xkb_numlock;
|
|
}
|
|
if (src->xkb_capslock != INT_MIN) {
|
|
dst->xkb_capslock = src->xkb_capslock;
|
|
}
|
|
if (src->mapped_from_region) {
|
|
free(dst->mapped_from_region);
|
|
dst->mapped_from_region =
|
|
malloc(sizeof(struct input_config_mapped_from_region));
|
|
memcpy(dst->mapped_from_region, src->mapped_from_region,
|
|
sizeof(struct input_config_mapped_from_region));
|
|
}
|
|
if (src->mapped_to_output) {
|
|
free(dst->mapped_to_output);
|
|
dst->mapped_to_output = strdup(src->mapped_to_output);
|
|
}
|
|
}
|
|
|
|
static bool validate_xkb_merge(struct input_config *dest,
|
|
struct input_config *src, char **xkb_error) {
|
|
struct input_config *temp = new_input_config("temp");
|
|
if (dest) {
|
|
merge_input_config(temp, dest);
|
|
}
|
|
merge_input_config(temp, src);
|
|
|
|
struct xkb_keymap *keymap = sway_keyboard_compile_keymap(temp, xkb_error);
|
|
free_input_config(temp);
|
|
if (!keymap) {
|
|
return false;
|
|
}
|
|
|
|
xkb_keymap_unref(keymap);
|
|
return true;
|
|
}
|
|
|
|
static bool validate_wildcard_on_all(struct input_config *wildcard,
|
|
char **error) {
|
|
for (int i = 0; i < config->input_configs->length; i++) {
|
|
struct input_config *ic = config->input_configs->items[i];
|
|
if (strcmp(wildcard->identifier, ic->identifier) != 0) {
|
|
sway_log(SWAY_DEBUG, "Validating xkb merge of * on %s",
|
|
ic->identifier);
|
|
if (!validate_xkb_merge(ic, wildcard, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < config->input_type_configs->length; i++) {
|
|
struct input_config *ic = config->input_type_configs->items[i];
|
|
sway_log(SWAY_DEBUG, "Validating xkb merge of * config on %s",
|
|
ic->identifier);
|
|
if (!validate_xkb_merge(ic, wildcard, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void merge_wildcard_on_all(struct input_config *wildcard) {
|
|
for (int i = 0; i < config->input_configs->length; i++) {
|
|
struct input_config *ic = config->input_configs->items[i];
|
|
if (strcmp(wildcard->identifier, ic->identifier) != 0) {
|
|
sway_log(SWAY_DEBUG, "Merging input * config on %s", ic->identifier);
|
|
merge_input_config(ic, wildcard);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < config->input_type_configs->length; i++) {
|
|
struct input_config *ic = config->input_type_configs->items[i];
|
|
sway_log(SWAY_DEBUG, "Merging input * config on %s", ic->identifier);
|
|
merge_input_config(ic, wildcard);
|
|
}
|
|
}
|
|
|
|
static bool validate_type_on_existing(struct input_config *type_wildcard,
|
|
char **error) {
|
|
for (int i = 0; i < config->input_configs->length; i++) {
|
|
struct input_config *ic = config->input_configs->items[i];
|
|
if (ic->input_type == NULL) {
|
|
continue;
|
|
}
|
|
|
|
if (strcmp(ic->input_type, type_wildcard->identifier + 5) == 0) {
|
|
sway_log(SWAY_DEBUG, "Validating merge of %s on %s",
|
|
type_wildcard->identifier, ic->identifier);
|
|
if (!validate_xkb_merge(ic, type_wildcard, error)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void merge_type_on_existing(struct input_config *type_wildcard) {
|
|
for (int i = 0; i < config->input_configs->length; i++) {
|
|
struct input_config *ic = config->input_configs->items[i];
|
|
if (ic->input_type == NULL) {
|
|
continue;
|
|
}
|
|
|
|
if (strcmp(ic->input_type, type_wildcard->identifier + 5) == 0) {
|
|
sway_log(SWAY_DEBUG, "Merging %s top of %s",
|
|
type_wildcard->identifier,
|
|
ic->identifier);
|
|
merge_input_config(ic, type_wildcard);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct input_config *store_input_config(struct input_config *ic,
|
|
char **error) {
|
|
bool wildcard = strcmp(ic->identifier, "*") == 0;
|
|
if (wildcard && error && !validate_wildcard_on_all(ic, error)) {
|
|
return NULL;
|
|
}
|
|
|
|
bool type = strncmp(ic->identifier, "type:", strlen("type:")) == 0;
|
|
if (type && error && !validate_type_on_existing(ic, error)) {
|
|
return NULL;
|
|
}
|
|
|
|
list_t *config_list = type ? config->input_type_configs
|
|
: config->input_configs;
|
|
|
|
struct input_config *current = NULL;
|
|
bool new_current = false;
|
|
|
|
int i = list_seq_find(config_list, input_identifier_cmp, ic->identifier);
|
|
if (i >= 0) {
|
|
current = config_list->items[i];
|
|
}
|
|
|
|
i = list_seq_find(config->input_configs, input_identifier_cmp, "*");
|
|
if (!current && i >= 0) {
|
|
current = new_input_config(ic->identifier);
|
|
merge_input_config(current, config->input_configs->items[i]);
|
|
new_current = true;
|
|
}
|
|
|
|
if (error && !validate_xkb_merge(current, ic, error)) {
|
|
if (new_current) {
|
|
free_input_config(current);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if (wildcard) {
|
|
merge_wildcard_on_all(ic);
|
|
}
|
|
|
|
if (type) {
|
|
merge_type_on_existing(ic);
|
|
}
|
|
|
|
if (current) {
|
|
merge_input_config(current, ic);
|
|
free_input_config(ic);
|
|
ic = current;
|
|
}
|
|
|
|
if (!current || new_current) {
|
|
list_add(config_list, ic);
|
|
}
|
|
|
|
sway_log(SWAY_DEBUG, "Config stored for input %s", ic->identifier);
|
|
|
|
return ic;
|
|
}
|
|
|
|
void input_config_fill_rule_names(struct input_config *ic,
|
|
struct xkb_rule_names *rules) {
|
|
rules->layout = ic->xkb_layout;
|
|
rules->model = ic->xkb_model;
|
|
rules->options = ic->xkb_options;
|
|
rules->rules = ic->xkb_rules;
|
|
rules->variant = ic->xkb_variant;
|
|
}
|
|
|
|
void free_input_config(struct input_config *ic) {
|
|
if (!ic) {
|
|
return;
|
|
}
|
|
free(ic->identifier);
|
|
free(ic->xkb_layout);
|
|
free(ic->xkb_model);
|
|
free(ic->xkb_options);
|
|
free(ic->xkb_rules);
|
|
free(ic->xkb_variant);
|
|
free(ic->mapped_from_region);
|
|
free(ic->mapped_to_output);
|
|
free(ic);
|
|
}
|
|
|
|
int input_identifier_cmp(const void *item, const void *data) {
|
|
const struct input_config *ic = item;
|
|
const char *identifier = data;
|
|
return strcmp(ic->identifier, identifier);
|
|
}
|