mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-09 10:06:20 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'switch-based-keymap-lookup'

Browse source
This commit is contained in:
Daniel Eklöf 2020-01-11 19:00:11 +01:00
commit 36d0f1fa5f
No known key found for this signature in database
GPG key ID: 5BBD4992C116573F
2 changed files with 176 additions and 156 deletions
Download patch file Download diff file Expand all files Collapse all files

243
input.c
View file

@ -166,6 +166,121 @@ keyboard_leave(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
}
}
static const struct key_data *
keymap_data_for_sym(xkb_keysym_t sym, size_t *count)
{
#define ALEN(a) (sizeof(a) / sizeof(a[0]))
switch (sym) {
case XKB_KEY_Escape: *count = ALEN(key_escape); return key_escape;
case XKB_KEY_Return: *count = ALEN(key_return); return key_return;
case XKB_KEY_Tab: *count = ALEN(key_tab); return key_tab;
case XKB_KEY_ISO_Left_Tab: *count = ALEN(key_backtab); return key_backtab;
case XKB_KEY_BackSpace: *count = ALEN(key_backspace); return key_backspace;
case XKB_KEY_Up: *count = ALEN(key_up); return key_up;
case XKB_KEY_Down: *count = ALEN(key_down); return key_down;
case XKB_KEY_Right: *count = ALEN(key_right); return key_right;
case XKB_KEY_Left: *count = ALEN(key_left); return key_left;
case XKB_KEY_Home: *count = ALEN(key_home); return key_home;
case XKB_KEY_End: *count = ALEN(key_end); return key_end;
case XKB_KEY_Insert: *count = ALEN(key_insert); return key_insert;
case XKB_KEY_Delete: *count = ALEN(key_delete); return key_delete;
case XKB_KEY_Page_Up: *count = ALEN(key_pageup); return key_pageup;
case XKB_KEY_Page_Down: *count = ALEN(key_pagedown); return key_pagedown;
case XKB_KEY_F1: *count = ALEN(key_f1); return key_f1;
case XKB_KEY_F2: *count = ALEN(key_f2); return key_f2;
case XKB_KEY_F3: *count = ALEN(key_f3); return key_f3;
case XKB_KEY_F4: *count = ALEN(key_f4); return key_f4;
case XKB_KEY_F5: *count = ALEN(key_f5); return key_f5;
case XKB_KEY_F6: *count = ALEN(key_f6); return key_f6;
case XKB_KEY_F7: *count = ALEN(key_f7); return key_f7;
case XKB_KEY_F8: *count = ALEN(key_f8); return key_f8;
case XKB_KEY_F9: *count = ALEN(key_f9); return key_f9;
case XKB_KEY_F10: *count = ALEN(key_f10); return key_f10;
case XKB_KEY_F11: *count = ALEN(key_f11); return key_f11;
case XKB_KEY_F12: *count = ALEN(key_f12); return key_f12;
case XKB_KEY_F13: *count = ALEN(key_f13); return key_f13;
case XKB_KEY_F14: *count = ALEN(key_f14); return key_f14;
case XKB_KEY_F15: *count = ALEN(key_f15); return key_f15;
case XKB_KEY_F16: *count = ALEN(key_f16); return key_f16;
case XKB_KEY_F17: *count = ALEN(key_f17); return key_f17;
case XKB_KEY_F18: *count = ALEN(key_f18); return key_f18;
case XKB_KEY_F19: *count = ALEN(key_f19); return key_f19;
case XKB_KEY_F20: *count = ALEN(key_f20); return key_f20;
case XKB_KEY_F21: *count = ALEN(key_f21); return key_f21;
case XKB_KEY_F22: *count = ALEN(key_f22); return key_f22;
case XKB_KEY_F23: *count = ALEN(key_f23); return key_f23;
case XKB_KEY_F24: *count = ALEN(key_f24); return key_f24;
case XKB_KEY_F25: *count = ALEN(key_f25); return key_f25;
case XKB_KEY_F26: *count = ALEN(key_f26); return key_f26;
case XKB_KEY_F27: *count = ALEN(key_f27); return key_f27;
case XKB_KEY_F28: *count = ALEN(key_f28); return key_f28;
case XKB_KEY_F29: *count = ALEN(key_f29); return key_f29;
case XKB_KEY_F30: *count = ALEN(key_f30); return key_f30;
case XKB_KEY_F31: *count = ALEN(key_f31); return key_f31;
case XKB_KEY_F32: *count = ALEN(key_f32); return key_f32;
case XKB_KEY_F33: *count = ALEN(key_f33); return key_f33;
case XKB_KEY_F34: *count = ALEN(key_f34); return key_f34;
case XKB_KEY_F35: *count = ALEN(key_f35); return key_f35;
case XKB_KEY_KP_Up: *count = ALEN(key_kp_up); return key_kp_up;
case XKB_KEY_KP_Down: *count = ALEN(key_kp_down); return key_kp_down;
case XKB_KEY_KP_Right: *count = ALEN(key_kp_right); return key_kp_right;
case XKB_KEY_KP_Left: *count = ALEN(key_kp_left); return key_kp_left;
case XKB_KEY_KP_Begin: *count = ALEN(key_kp_begin); return key_kp_begin;
case XKB_KEY_KP_Home: *count = ALEN(key_kp_home); return key_kp_home;
case XKB_KEY_KP_End: *count = ALEN(key_kp_end); return key_kp_end;
case XKB_KEY_KP_Insert: *count = ALEN(key_kp_insert); return key_kp_insert;
case XKB_KEY_KP_Delete: *count = ALEN(key_kp_delete); return key_kp_delete;
case XKB_KEY_KP_Page_Up: *count = ALEN(key_kp_pageup); return key_kp_pageup;
case XKB_KEY_KP_Page_Down: *count = ALEN(key_kp_pagedown); return key_kp_pagedown;
case XKB_KEY_KP_Enter: *count = ALEN(key_kp_enter); return key_kp_enter;
case XKB_KEY_KP_Divide: *count = ALEN(key_kp_divide); return key_kp_divide;
case XKB_KEY_KP_Multiply: *count = ALEN(key_kp_multiply); return key_kp_multiply;
case XKB_KEY_KP_Subtract: *count = ALEN(key_kp_subtract); return key_kp_subtract;
case XKB_KEY_KP_Add: *count = ALEN(key_kp_add); return key_kp_add;
case XKB_KEY_KP_Separator: *count = ALEN(key_kp_separator); return key_kp_separator;
case XKB_KEY_KP_0: *count = ALEN(key_kp_0); return key_kp_0;
case XKB_KEY_KP_1: *count = ALEN(key_kp_1); return key_kp_1;
case XKB_KEY_KP_2: *count = ALEN(key_kp_2); return key_kp_2;
case XKB_KEY_KP_3: *count = ALEN(key_kp_3); return key_kp_3;
case XKB_KEY_KP_4: *count = ALEN(key_kp_4); return key_kp_4;
case XKB_KEY_KP_5: *count = ALEN(key_kp_5); return key_kp_5;
case XKB_KEY_KP_6: *count = ALEN(key_kp_6); return key_kp_6;
case XKB_KEY_KP_7: *count = ALEN(key_kp_7); return key_kp_7;
case XKB_KEY_KP_8: *count = ALEN(key_kp_8); return key_kp_8;
case XKB_KEY_KP_9: *count = ALEN(key_kp_9); return key_kp_9;
}
#undef ALEN
return NULL;
}
static const struct key_data *
keymap_lookup(struct terminal *term, xkb_keysym_t sym, enum modifier mods)
{
size_t count;
const struct key_data *info = keymap_data_for_sym(sym, &count);
if (info == NULL)
return NULL;
for (size_t j = 0; j < count; j++) {
if (info[j].modifiers != MOD_ANY && info[j].modifiers != mods)
continue;
if (info[j].cursor_keys_mode != CURSOR_KEYS_DONTCARE &&
info[j].cursor_keys_mode != term->cursor_keys_mode)
continue;
if (info[j].keypad_keys_mode != KEYPAD_DONTCARE &&
info[j].keypad_keys_mode != term->keypad_keys_mode)
continue;
return &info[j];
}
return NULL;
}
static void
keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
uint32_t time, uint32_t key, uint32_t state)
@ -248,11 +363,9 @@ keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
"effective=0x%08x, repeats=%d",
sym, mods, consumed, significant, effective_mods, should_repeat);
enum modifier keymap_mods = MOD_NONE;
keymap_mods |= wayl->kbd.shift ? MOD_SHIFT : MOD_NONE;
keymap_mods |= wayl->kbd.alt ? MOD_ALT : MOD_NONE;
keymap_mods |= wayl->kbd.ctrl ? MOD_CTRL : MOD_NONE;
keymap_mods |= wayl->kbd.meta ? MOD_META : MOD_NONE;
/*
* Builtin shortcuts
*/
if (effective_mods == shift) {
if (sym == XKB_KEY_Page_Up) {
@ -289,33 +402,29 @@ keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
}
}
/*
* Keys generating escape sequences
*/
for (size_t i = 0; i < sizeof(key_map) / sizeof(key_map[0]); i++) {
const struct key_map *k = &key_map[i];
if (k->sym != sym)
continue;
enum modifier keymap_mods = MOD_NONE;
keymap_mods |= wayl->kbd.shift ? MOD_SHIFT : MOD_NONE;
keymap_mods |= wayl->kbd.alt ? MOD_ALT : MOD_NONE;
keymap_mods |= wayl->kbd.ctrl ? MOD_CTRL : MOD_NONE;
keymap_mods |= wayl->kbd.meta ? MOD_META : MOD_NONE;
for (size_t j = 0; j < k->count; j++) {
const struct key_data *info = &k->data[j];
if (info->modifiers != MOD_ANY && info->modifiers != keymap_mods)
continue;
const struct key_data *keymap = keymap_lookup(term, sym, keymap_mods);
if (keymap != NULL) {
term_to_slave(term, keymap->seq, strlen(keymap->seq));
if (info->cursor_keys_mode != CURSOR_KEYS_DONTCARE &&
info->cursor_keys_mode != term->cursor_keys_mode)
continue;
if (info->keypad_keys_mode != KEYPAD_DONTCARE &&
info->keypad_keys_mode != term->keypad_keys_mode)
continue;
term_to_slave(term, info->seq, strlen(info->seq));
term_reset_view(term);
selection_cancel(term);
goto maybe_repeat;
}
term_reset_view(term);
selection_cancel(term);
goto maybe_repeat;
}
/*
* Compose, and maybe emit "normal" character
*/
uint8_t buf[64] = {0};
int count = 0;
@ -330,55 +439,55 @@ keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
wayl->kbd.xkb_state, key, (char *)buf, sizeof(buf));
}
if (count > 0) {
if (count == 0)
goto maybe_repeat;
#define is_control_key(x) ((x) >= 0x40 && (x) <= 0x7f)
#define IS_CTRL(x) ((x) < 0x20 || ((x) >= 0x7f && (x) <= 0x9f))
if ((keymap_mods & MOD_CTRL) &&
!is_control_key(sym) &&
(count == 1 && !IS_CTRL(buf[0])) &&
sym < 256)
{
static const int mod_param_map[32] = {
[MOD_SHIFT] = 2,
[MOD_ALT] = 3,
[MOD_SHIFT | MOD_ALT] = 4,
[MOD_CTRL] = 5,
[MOD_SHIFT | MOD_CTRL] = 6,
[MOD_ALT | MOD_CTRL] = 7,
[MOD_SHIFT | MOD_ALT | MOD_CTRL] = 8,
[MOD_META] = 9,
[MOD_META | MOD_SHIFT] = 10,
[MOD_META | MOD_ALT] = 11,
[MOD_META | MOD_SHIFT | MOD_ALT] = 12,
[MOD_META | MOD_CTRL] = 13,
[MOD_META | MOD_SHIFT | MOD_CTRL] = 14,
[MOD_META | MOD_ALT | MOD_CTRL] = 15,
[MOD_META | MOD_SHIFT | MOD_ALT | MOD_CTRL] = 16,
};
if ((keymap_mods & MOD_CTRL) &&
!is_control_key(sym) &&
(count == 1 && !IS_CTRL(buf[0])) &&
sym < 256)
{
static const int mod_param_map[32] = {
[MOD_SHIFT] = 2,
[MOD_ALT] = 3,
[MOD_SHIFT | MOD_ALT] = 4,
[MOD_CTRL] = 5,
[MOD_SHIFT | MOD_CTRL] = 6,
[MOD_ALT | MOD_CTRL] = 7,
[MOD_SHIFT | MOD_ALT | MOD_CTRL] = 8,
[MOD_META] = 9,
[MOD_META | MOD_SHIFT] = 10,
[MOD_META | MOD_ALT] = 11,
[MOD_META | MOD_SHIFT | MOD_ALT] = 12,
[MOD_META | MOD_CTRL] = 13,
[MOD_META | MOD_SHIFT | MOD_CTRL] = 14,
[MOD_META | MOD_ALT | MOD_CTRL] = 15,
[MOD_META | MOD_SHIFT | MOD_ALT | MOD_CTRL] = 16,
};
assert(keymap_mods < sizeof(mod_param_map) / sizeof(mod_param_map[0]));
int modify_param = mod_param_map[keymap_mods];
assert(modify_param != 0);
assert(keymap_mods < sizeof(mod_param_map) / sizeof(mod_param_map[0]));
int modify_param = mod_param_map[keymap_mods];
assert(modify_param != 0);
char reply[1024];
snprintf(reply, sizeof(reply), "\x1b[27;%d;%d~", modify_param, sym);
term_to_slave(term, reply, strlen(reply));
}
char reply[1024];
snprintf(reply, sizeof(reply), "\x1b[27;%d;%d~", modify_param, sym);
term_to_slave(term, reply, strlen(reply));
}
else {
if (effective_mods & alt)
term_to_slave(term, "\x1b", 1);
else {
if (effective_mods & alt)
term_to_slave(term, "\x1b", 1);
term_to_slave(term, buf, count);
}
term_to_slave(term, buf, count);
}
clock_gettime(
term->wl->presentation_clock_id, &term->render.input_time);
term_reset_view(term);
selection_cancel(term);
}
clock_gettime(
term->wl->presentation_clock_id, &term->render.input_time);
term_reset_view(term);
selection_cancel(term);
maybe_repeat:
if (should_repeat)

89
keymap.h
View file

@ -1,6 +1,5 @@
#pragma once
#include <stdbool.h>
#include <xkbcommon/xkbcommon.h>
#include "terminal.h"
@ -21,12 +20,6 @@ struct key_data {
const char *seq;
};
struct key_map {
xkb_keysym_t sym;
size_t count;
const struct key_data *data;
};
static const struct key_data key_escape[] = {
{MOD_ANY, CURSOR_KEYS_DONTCARE, KEYPAD_DONTCARE, "\033"},
};
@ -348,85 +341,3 @@ static const struct key_data key_kp_8[] = {DEFAULT_MODS_FOR_KP(x)};
static const struct key_data key_kp_9[] = {DEFAULT_MODS_FOR_KP(y)};
#undef DEFAULT_MODS_FOR_KP
#define ALEN(a) (sizeof(a) / sizeof(a[0]))
static const struct key_map key_map[] = {
{XKB_KEY_Escape, ALEN(key_escape), key_escape},
{XKB_KEY_Return, ALEN(key_return), key_return},
{XKB_KEY_Tab, ALEN(key_tab), key_tab},
{XKB_KEY_ISO_Left_Tab, ALEN(key_backtab), key_backtab},
{XKB_KEY_BackSpace, ALEN(key_backspace), key_backspace},
{XKB_KEY_Up, ALEN(key_up), key_up},
{XKB_KEY_Down, ALEN(key_down), key_down},
{XKB_KEY_Right, ALEN(key_right), key_right},
{XKB_KEY_Left, ALEN(key_left), key_left},
{XKB_KEY_Home, ALEN(key_home), key_home},
{XKB_KEY_End, ALEN(key_end), key_end},
{XKB_KEY_Insert, ALEN(key_insert), key_insert},
{XKB_KEY_Delete, ALEN(key_delete), key_delete},
{XKB_KEY_Page_Up, ALEN(key_pageup), key_pageup},
{XKB_KEY_Page_Down, ALEN(key_pagedown), key_pagedown},
{XKB_KEY_F1, ALEN(key_f1), key_f1},
{XKB_KEY_F2, ALEN(key_f2), key_f2},
{XKB_KEY_F3, ALEN(key_f3), key_f3},
{XKB_KEY_F4, ALEN(key_f4), key_f4},
{XKB_KEY_F5, ALEN(key_f5), key_f5},
{XKB_KEY_F6, ALEN(key_f6), key_f6},
{XKB_KEY_F7, ALEN(key_f7), key_f7},
{XKB_KEY_F8, ALEN(key_f8), key_f8},
{XKB_KEY_F9, ALEN(key_f9), key_f9},
{XKB_KEY_F10, ALEN(key_f10), key_f10},
{XKB_KEY_F11, ALEN(key_f11), key_f11},
{XKB_KEY_F12, ALEN(key_f12), key_f12},
{XKB_KEY_F13, ALEN(key_f13), key_f13},
{XKB_KEY_F14, ALEN(key_f14), key_f14},
{XKB_KEY_F15, ALEN(key_f15), key_f15},
{XKB_KEY_F16, ALEN(key_f16), key_f16},
{XKB_KEY_F17, ALEN(key_f17), key_f17},
{XKB_KEY_F18, ALEN(key_f18), key_f18},
{XKB_KEY_F19, ALEN(key_f19), key_f19},
{XKB_KEY_F20, ALEN(key_f20), key_f20},
{XKB_KEY_F21, ALEN(key_f21), key_f21},
{XKB_KEY_F22, ALEN(key_f22), key_f22},
{XKB_KEY_F23, ALEN(key_f23), key_f23},
{XKB_KEY_F24, ALEN(key_f24), key_f24},
{XKB_KEY_F25, ALEN(key_f25), key_f25},
{XKB_KEY_F26, ALEN(key_f26), key_f26},
{XKB_KEY_F27, ALEN(key_f27), key_f27},
{XKB_KEY_F28, ALEN(key_f28), key_f28},
{XKB_KEY_F29, ALEN(key_f29), key_f29},
{XKB_KEY_F30, ALEN(key_f30), key_f30},
{XKB_KEY_F31, ALEN(key_f31), key_f31},
{XKB_KEY_F32, ALEN(key_f32), key_f32},
{XKB_KEY_F33, ALEN(key_f33), key_f33},
{XKB_KEY_F34, ALEN(key_f34), key_f34},
{XKB_KEY_F35, ALEN(key_f35), key_f35},
{XKB_KEY_KP_Up, ALEN(key_kp_up), key_kp_up},
{XKB_KEY_KP_Down, ALEN(key_kp_down), key_kp_down},
{XKB_KEY_KP_Right, ALEN(key_kp_right), key_kp_right},
{XKB_KEY_KP_Left, ALEN(key_kp_left), key_kp_left},
{XKB_KEY_KP_Begin, ALEN(key_kp_begin), key_kp_begin},
{XKB_KEY_KP_Home, ALEN(key_kp_home), key_kp_home},
{XKB_KEY_KP_End, ALEN(key_kp_end), key_kp_end},
{XKB_KEY_KP_Insert, ALEN(key_kp_insert), key_kp_insert},
{XKB_KEY_KP_Delete, ALEN(key_kp_delete), key_kp_delete},
{XKB_KEY_KP_Page_Up,ALEN(key_kp_pageup), key_kp_pageup},
{XKB_KEY_KP_Page_Down, ALEN(key_kp_pagedown), key_kp_pagedown},
{XKB_KEY_KP_Enter, ALEN(key_kp_enter), key_kp_enter},
{XKB_KEY_KP_Divide, ALEN(key_kp_divide), key_kp_divide},
{XKB_KEY_KP_Multiply,ALEN(key_kp_multiply), key_kp_multiply},
{XKB_KEY_KP_Subtract,ALEN(key_kp_subtract), key_kp_subtract},
{XKB_KEY_KP_Add, ALEN(key_kp_add), key_kp_add},
{XKB_KEY_KP_Separator,ALEN(key_kp_separator), key_kp_separator},
{XKB_KEY_KP_0, ALEN(key_kp_0), key_kp_0},
{XKB_KEY_KP_1, ALEN(key_kp_1), key_kp_1},
{XKB_KEY_KP_2, ALEN(key_kp_2), key_kp_2},
{XKB_KEY_KP_3, ALEN(key_kp_3), key_kp_3},
{XKB_KEY_KP_4, ALEN(key_kp_4), key_kp_4},
{XKB_KEY_KP_5, ALEN(key_kp_5), key_kp_5},
{XKB_KEY_KP_6, ALEN(key_kp_6), key_kp_6},
{XKB_KEY_KP_7, ALEN(key_kp_7), key_kp_7},
{XKB_KEY_KP_8, ALEN(key_kp_8), key_kp_8},
{XKB_KEY_KP_9, ALEN(key_kp_9), key_kp_9},
};
#undef ALEN