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

3653 lines
123 KiB
C
Raw Normal View History

wip: initial input handling
2019-06-19 10:04:47 +02:00
#include "input.h"
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <threads.h>
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
#include <locale.h>
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
#include <errno.h>
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
#include <wctype.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
#include <sys/mman.h>
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
#include <sys/timerfd.h>
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
#include <sys/epoll.h>
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
#include <fcntl.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: generate BTN_BACK/BTN_FORWARD mouse down events when scrolling
2019-07-10 14:17:44 +02:00
#include <linux/input-event-codes.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
#include <xkbcommon/xkbcommon.h>
#include <xkbcommon/xkbcommon-keysyms.h>
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
#include <xkbcommon/xkbcommon-compose.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
#include <xdg-shell.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
#define LOG_MODULE "input"
ime: render pre-edit text This is done by allocating cells for the pre-edit text when receiving the text-input::done() call, and populating them by converting the utf-8 formatted pre-edit text to wchars. We also convert the pre-edit cursor position to cell positions (it can cover multiple cells). When rendering, we simply render the pre-edit cells on-top off the regular grid. While doing so, we also mark the underlying, “real”, cells as dirty, to ensure they are re-rendered when the pre-edit text is modified or removed.
2020-12-02 18:52:50 +01:00
#define LOG_ENABLE_DBG 0
wip: initial input handling
2019-06-19 10:04:47 +02:00
#include "log.h"
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
#include "commands.h"
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
#include "config.h"
#include "grid.h"
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
#include "keymap.h"
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
#include "kitty-keymap.h"
Replace GCC "unused" and "format" attributes with portable macros
2020-08-07 20:42:34 +01:00
#include "macros.h"
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
#include "quirks.h"
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
#include "render.h"
#include "search.h"
selection: add a selection API
2019-07-11 09:51:51 +02:00
#include "selection.h"
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
#include "spawn.h"
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
#include "terminal.h"
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
#include "tokenize.h"
input: add new Unicode input mode This mode is activated through the new key-bindings.unicode-input and search-bindings.unicode-input key bindings. When active, the user can “build” a Unicode codepoint by typing its hexadecimal value. Note that there’s no visual feedback in this mode. This is intentional. This mode is intended to be a fallback for users that don’t use an IME. Closes #1116
2022-07-28 18:09:16 +02:00
#include "unicode-mode.h"
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
#include "url-mode.h"
util.h: new header file defining commonly used macros
2020-05-01 11:46:24 +02:00
#include "util.h"
Use vt_to_slave() instead of calling write(term->ptmx, ...) everywhere
2019-07-15 15:42:21 +02:00
#include "vt.h"
libxkbcommon: don't require 1.8.0 The version bump was done since we now use XKB_VMOD_NAME_*; macros added in libxkbcommon 1.8.0. Not all distros have updated libxkbcommon yet (read: Debian). Since it's fairly easy to work around, let's do that. Closes #2103
2025-05-18 11:35:27 +02:00
#include "xkbcommon-vmod.h"
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
#include "xmalloc.h"
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
#include "xsnprintf.h"
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
struct pipe_context {
char *text;
size_t idx;
size_t left;
};
static bool
fdm_write_pipe(struct fdm *fdm, int fd, int events, void *data)
{
struct pipe_context *ctx = data;
if (events & EPOLLHUP)
goto pipe_closed;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(events & EPOLLOUT);
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
ssize_t written = write(fd, &ctx->text[ctx->idx], ctx->left);
if (written < 0) {
LOG_WARN("failed to write to pipe: %s", strerror(errno));
goto pipe_closed;
}
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(written <= ctx->left);
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
ctx->idx += written;
ctx->left -= written;
if (ctx->left == 0)
goto pipe_closed;
return true;
pipe_closed:
free(ctx->text);
free(ctx);
fdm_del(fdm, fd);
return true;
}
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
static void alternate_scroll(struct seat *seat, int amount, int button);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
static bool
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
execute_binding(struct seat *seat, struct terminal *term,
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
const struct key_binding *binding, uint32_t serial, int amount)
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
{
input/search/url: pass pointer-to key-binding struct to execute()
2022-02-08 19:43:00 +01:00
const enum bind_action_normal action = binding->action;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
switch (action) {
config: mouse-bindings: verify button isn't already mapped A button may only be mapped to a single action. Detect when the user tried to map the same button to multiple actions and error out. To clear a binding (for example, to free up a button from the default bindings), one can set the action it is bound to to `NONE` (e.g. `primary-paste=NONE`).
2020-03-12 10:46:27 +01:00
case BIND_ACTION_NONE:
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
config: mouse-bindings: verify button isn't already mapped A button may only be mapped to a single action. Detect when the user tried to map the same button to multiple actions and error out. To clear a binding (for example, to free up a button from the default bindings), one can set the action it is bound to to `NONE` (e.g. `primary-paste=NONE`).
2020-03-12 10:46:27 +01:00
config: add [key-bindings].noop action Key combinations assigned to this action will not be sent to the application. Closes #765
2021-10-24 11:49:37 +02:00
case BIND_ACTION_NOOP:
return true;
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_UP_PAGE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_up(term, term->rows);
return true;
}
break;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_UP_HALF_PAGE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_up(term, max(term->rows / 2, 1));
return true;
}
break;
config: add scrollback-{up,down}-half key bindings These new bindings scroll up/down half a page in the scrollback (instead of the full page scrolled by ‘scrollback-{up,down}’). Closes #128.
2020-09-09 19:40:48 +02:00
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_UP_LINE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_up(term, 1);
return true;
}
break;
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
case BIND_ACTION_SCROLLBACK_UP_MOUSE:
if (term->grid == &term->alt) {
if (term->alt_scrolling)
alternate_scroll(seat, amount, BTN_BACK);
} else
cmd_scrollback_up(term, amount);
break;
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_DOWN_PAGE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_down(term, term->rows);
return true;
}
break;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_DOWN_HALF_PAGE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_down(term, max(term->rows / 2, 1));
return true;
}
break;
config: add scrollback-{up,down}-half key bindings These new bindings scroll up/down half a page in the scrollback (instead of the full page scrolled by ‘scrollback-{up,down}’). Closes #128.
2020-09-09 19:40:48 +02:00
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
case BIND_ACTION_SCROLLBACK_DOWN_LINE:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->normal) {
cmd_scrollback_down(term, 1);
return true;
}
break;
key-binding: deprecate scrollback-up/down, add scrollback-up/down-line This deprecates/renames scrollback-up/down to scrollback-up/down-page. It also renames scrollback-up/down-half to scrollback-up/down-half-page, and adds the new bindings scrollback-up/down-line.
2020-09-10 18:17:47 +02:00
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
case BIND_ACTION_SCROLLBACK_DOWN_MOUSE:
if (term->grid == &term->alt) {
if (term->alt_scrolling)
alternate_scroll(seat, amount, BTN_FORWARD);
} else
cmd_scrollback_down(term, amount);
break;
config/input: add scrollback-home|end key bindings (unbound by default)
2022-02-23 19:03:54 +01:00
case BIND_ACTION_SCROLLBACK_HOME:
if (term->grid == &term->normal) {
cmd_scrollback_up(term, term->grid->num_rows);
return true;
}
break;
case BIND_ACTION_SCROLLBACK_END:
if (term->grid == &term->normal) {
cmd_scrollback_down(term, term->grid->num_rows);
return true;
}
break;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
case BIND_ACTION_CLIPBOARD_COPY:
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
selection_to_clipboard(seat, term, serial);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
case BIND_ACTION_CLIPBOARD_PASTE:
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
selection_from_clipboard(seat, term, serial);
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
term_reset_view(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
case BIND_ACTION_PRIMARY_PASTE:
multi-seat: re-enable selection support (excluding OSC 52)
2020-07-08 18:41:09 +02:00
selection_from_primary(seat, term);
input: reset view when pasting from primary We’re already doing this for keyboard input, and regular clipboard pastes.
2022-01-11 20:26:49 +01:00
term_reset_view(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
case BIND_ACTION_SEARCH_START:
search_begin(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
case BIND_ACTION_FONT_SIZE_UP:
term_font_size_increase(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
case BIND_ACTION_FONT_SIZE_DOWN:
term_font_size_decrease(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
case BIND_ACTION_FONT_SIZE_RESET:
term_font_size_reset(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
case BIND_ACTION_SPAWN_TERMINAL:
term_spawn_new(term);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
bindings: add minimize/maximize/fullscreen actions These actions are by default not bound to anything.
2020-03-12 09:34:09 +01:00
case BIND_ACTION_MINIMIZE:
xdg_toplevel_set_minimized(term->window->xdg_toplevel);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
bindings: add minimize/maximize/fullscreen actions These actions are by default not bound to anything.
2020-03-12 09:34:09 +01:00
case BIND_ACTION_MAXIMIZE:
input: maximize: unset fullscreen before toggling maximized state
2020-03-12 17:47:53 +01:00
if (term->window->is_fullscreen)
xdg_toplevel_unset_fullscreen(term->window->xdg_toplevel);
bindings: add minimize/maximize/fullscreen actions These actions are by default not bound to anything.
2020-03-12 09:34:09 +01:00
if (term->window->is_maximized)
xdg_toplevel_unset_maximized(term->window->xdg_toplevel);
else
xdg_toplevel_set_maximized(term->window->xdg_toplevel);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
bindings: add minimize/maximize/fullscreen actions These actions are by default not bound to anything.
2020-03-12 09:34:09 +01:00
case BIND_ACTION_FULLSCREEN:
if (term->window->is_fullscreen)
xdg_toplevel_unset_fullscreen(term->window->xdg_toplevel);
else
xdg_toplevel_set_fullscreen(term->window->xdg_toplevel, NULL);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
bindings: add minimize/maximize/fullscreen actions These actions are by default not bound to anything.
2020-03-12 09:34:09 +01:00
conf: add definitions for pipe-{scrollback,view} bindings
2020-07-15 09:46:13 +02:00
case BIND_ACTION_PIPE_SCROLLBACK:
input: pass through scrollback-* key bindings when alt screen is activw Since the alt screen have no scrollback, all scrollback-* actions are effectively no-ops when the alt screen is active. Make them available to the client application instead. Closes #573
2021-06-04 23:25:45 +02:00
if (term->grid == &term->alt)
break;
/* FALLTHROUGH */
config: add 'pipe-selected' key binding This works just like pipe-visible and pipe-scrollback, but pipes the user-selected text, if any, to the external tool. Closes #51
2020-07-31 17:02:53 +02:00
case BIND_ACTION_PIPE_VIEW:
config: add pipe-command-output key-binding
2022-12-08 11:45:23 +01:00
case BIND_ACTION_PIPE_SELECTED:
case BIND_ACTION_PIPE_COMMAND_OUTPUT: {
input/search/url: pass pointer-to key-binding struct to execute()
2022-02-08 19:43:00 +01:00
if (binding->aux->type != BINDING_AUX_PIPE)
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
struct pipe_context *ctx = NULL;
input: pipe: avoid goto's where variables may be uninitialized
2020-07-22 19:34:07 +02:00
int pipe_fd[2] = {-1, -1};
int stdout_fd = -1;
int stderr_fd = -1;
char *text = NULL;
size_t len = 0;
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
if (pipe(pipe_fd) < 0) {
LOG_ERRNO("failed to create pipe");
goto pipe_err;
}
input: pipe: avoid goto's where variables may be uninitialized
2020-07-22 19:34:07 +02:00
stdout_fd = open("/dev/null", O_WRONLY);
stderr_fd = open("/dev/null", O_WRONLY);
input: pipe-{visible,scrollback}: redirect stdout/stderr to /dev/null
2020-07-15 18:17:28 +02:00
if (stdout_fd < 0 || stderr_fd < 0) {
LOG_ERRNO("failed to open /dev/null");
goto pipe_err;
}
config: add 'pipe-selected' key binding This works just like pipe-visible and pipe-scrollback, but pipes the user-selected text, if any, to the external tool. Closes #51
2020-07-31 17:02:53 +02:00
bool success;
switch (action) {
case BIND_ACTION_PIPE_SCROLLBACK:
success = term_scrollback_to_text(term, &text, &len);
break;
case BIND_ACTION_PIPE_VIEW:
success = term_view_to_text(term, &text, &len);
break;
case BIND_ACTION_PIPE_SELECTED:
text = selection_to_text(term);
success = text != NULL;
len = text != NULL ? strlen(text) : 0;
break;
config: add pipe-command-output key-binding
2022-12-08 11:45:23 +01:00
case BIND_ACTION_PIPE_COMMAND_OUTPUT:
success = term_command_output_to_text(term, &text, &len);
break;
config: add 'pipe-selected' key binding This works just like pipe-visible and pipe-scrollback, but pipes the user-selected text, if any, to the external tool. Closes #51
2020-07-31 17:02:53 +02:00
default:
Convert some uses of xassert(false) to BUG("some error message")
2021-02-09 13:52:33 +00:00
BUG("Unhandled action type");
config: add 'pipe-selected' key binding This works just like pipe-visible and pipe-scrollback, but pipes the user-selected text, if any, to the external tool. Closes #51
2020-07-31 17:02:53 +02:00
success = false;
break;
}
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
if (!success)
goto pipe_err;
/* Make write-end non-blocking; required by the FDM */
{
int flags = fcntl(pipe_fd[1], F_GETFL);
if (flags < 0 ||
fcntl(pipe_fd[1], F_SETFL, flags | O_NONBLOCK) < 0)
{
LOG_ERRNO("failed to make write-end of pipe non-blocking");
goto pipe_err;
}
}
input: comments
2020-07-15 16:47:01 +02:00
/* Make sure write-end is closed on exec() - or the spawned
* program may not terminate*/
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
{
int flags = fcntl(pipe_fd[1], F_GETFD);
if (flags < 0 ||
fcntl(pipe_fd[1], F_SETFD, flags | FD_CLOEXEC) < 0)
{
LOG_ERRNO("failed to set FD_CLOEXEC on writeend of pipe");
goto pipe_err;
}
}
spawn: add optional reaper callback, return pid_t This will allow spawn() callers to do things when the spawned process has terminated.
2024-07-23 06:57:30 +02:00
if (spawn(term->reaper, term->cwd, binding->aux->pipe.args,
pipe_fd[0], stdout_fd, stderr_fd, NULL, NULL, NULL) < 0)
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
goto pipe_err;
/* Close read end */
close(pipe_fd[0]);
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
ctx = xmalloc(sizeof(*ctx));
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
*ctx = (struct pipe_context){
.text = text,
.left = len,
};
input: comments
2020-07-15 16:47:01 +02:00
/* Asynchronously write the output to the pipe */
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
if (!fdm_add(term->fdm, pipe_fd[1], EPOLLOUT, &fdm_write_pipe, ctx))
goto pipe_err;
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
conf: add definitions for pipe-{scrollback,view} bindings
2020-07-15 09:46:13 +02:00
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
pipe_err:
input: pipe-{visible,scrollback}: redirect stdout/stderr to /dev/null
2020-07-15 18:17:28 +02:00
if (stdout_fd >= 0)
close(stdout_fd);
if (stderr_fd >= 0)
close(stderr_fd);
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
if (pipe_fd[0] >= 0)
close(pipe_fd[0]);
if (pipe_fd[1] >= 0)
close(pipe_fd[1]);
free(text);
free(ctx);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
}
config: add show-urls-copy action This works just like show-urls-launch, except that instead of opening the URL (typically using xdg-open), it is placed in the clipboard when activated.
2021-02-04 20:55:08 +01:00
case BIND_ACTION_SHOW_URLS_COPY:
url-mode: add a key binding that enables “persistent” URL mode This is an alternative to ‘show-urls-launch’, where we stay in URL mode after activating an URL. Closes #964
2022-03-22 19:07:06 +01:00
case BIND_ACTION_SHOW_URLS_LAUNCH:
case BIND_ACTION_SHOW_URLS_PERSISTENT: {
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
xassert(!urls_mode_is_active(term));
url-mode: add a key binding that enables “persistent” URL mode This is an alternative to ‘show-urls-launch’, where we stay in URL mode after activating an URL. Closes #964
2022-03-22 19:07:06 +01:00
enum url_action url_action =
action == BIND_ACTION_SHOW_URLS_COPY ? URL_ACTION_COPY :
action == BIND_ACTION_SHOW_URLS_LAUNCH ? URL_ACTION_LAUNCH :
URL_ACTION_PERSISTENT;
config: add show-urls-copy action This works just like show-urls-launch, except that instead of opening the URL (typically using xdg-open), it is placed in the clipboard when activated.
2021-02-04 20:55:08 +01:00
config+url: add support for user-defined regex patterns Users can now define their own regex patterns, and use them via key bindings: [regex:foo] regex=foo(bar)? launch=path-to-script-or-application {match} [key-bindings] regex-launch=[foo] Control+Shift+q regex-copy=[foo] Control+Mod1+Shift+q That is, add a section called 'regex:', followed by an identifier. Define a regex and a launcher command line. Add a key-binding, regex-launch and/or regex-copy (similar to show-urls-launch and show-urls-copy), and connect them to the regex with the "[regex-name]" syntax (similar to how the pipe-* bindings work).
2025-02-03 08:55:47 +01:00
urls_collect(term, url_action, &term->conf->url.preg, true, &term->urls);
url-mode: use ‘jump-label-letters’ as the alphabet for key sequences Instead of hard coding the alphabet to “sadfjklewcmpgh”, use the letters from ‘jump-label-letters’. Closes #355
2021-02-13 11:43:28 +01:00
urls_assign_key_combos(term->conf, &term->urls);
config+url: add support for user-defined regex patterns Users can now define their own regex patterns, and use them via key bindings: [regex:foo] regex=foo(bar)? launch=path-to-script-or-application {match} [key-bindings] regex-launch=[foo] Control+Shift+q regex-copy=[foo] Control+Mod1+Shift+q That is, add a section called 'regex:', followed by an identifier. Define a regex and a launcher command line. Add a key-binding, regex-launch and/or regex-copy (similar to show-urls-launch and show-urls-copy), and connect them to the regex with the "[regex-name]" syntax (similar to how the pipe-* bindings work).
2025-02-03 08:55:47 +01:00
urls_render(term, &term->conf->url.launch);
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
return true;
config: add show-urls-copy action This works just like show-urls-launch, except that instead of opening the URL (typically using xdg-open), it is placed in the clipboard when activated.
2021-02-04 20:55:08 +01:00
}
config: add infrastructure to handle URL mode specific key bindings * Add “show-urls” action to regular key bindings * Add url-bindings section to foot.ini * Add “cancel” action to URL mode key bindings
2021-01-30 12:43:59 +01:00
wip: map key combos to custom text strings (including escapes) With this, it is now possible to map key combos to custom escapes. The new bindings are defined in a new section, “text-bindings”, on the form “string=key combo”. The string can consist of printable characters, or \xNN style hex digits: [text-bindings] abcd = Control+a \x1b[A = Control+b Control+c Control+d # map ctrl+b/c/d to UP
2022-02-06 19:36:44 +01:00
case BIND_ACTION_TEXT_BINDING:
xassert(binding->aux->type == BINDING_AUX_TEXT);
term_to_slave(term, binding->aux->text.data, binding->aux->text.len);
return true;
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
case BIND_ACTION_PROMPT_PREV: {
if (term->grid != &term->normal)
return false;
struct grid *grid = term->grid;
const int sb_start =
grid_sb_start_ignore_uninitialized(grid, term->rows);
/* Check each row from current view-1 (that is, the first
* currently not visible row), up to, and including, the
* scrollback start */
for (int r_sb_rel =
grid_row_abs_to_sb_precalc_sb_start(
grid, sb_start, grid->view) - 1;
r_sb_rel >= 0; r_sb_rel--)
{
const int r_abs =
grid_row_sb_to_abs_precalc_sb_start(grid, sb_start, r_sb_rel);
const struct row *row = grid->rows[r_abs];
xassert(row != NULL);
term: move row->prompt_marker into new struct, row->shell_integration
2022-12-08 10:35:30 +01:00
if (!row->shell_integration.prompt_marker)
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
continue;
grid->view = r_abs;
term_damage_view(term);
render_refresh(term);
break;
}
return true;
}
case BIND_ACTION_PROMPT_NEXT: {
if (term->grid != &term->normal)
return false;
struct grid *grid = term->grid;
const int num_rows = grid->num_rows;
if (grid->view == grid->offset) {
/* Already at the bottom */
return true;
}
/* Check each row from view+1, to the bottom of the scrollback */
for (int r_abs = (grid->view + 1) & (num_rows - 1);
;
r_abs = (r_abs + 1) & (num_rows - 1))
{
const struct row *row = grid->rows[r_abs];
xassert(row != NULL);
term: move row->prompt_marker into new struct, row->shell_integration
2022-12-08 10:35:30 +01:00
if (!row->shell_integration.prompt_marker) {
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
if (r_abs == grid->offset + term->rows - 1) {
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* We've reached the bottom of the scrollback */
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
break;
}
continue;
}
int sb_start = grid_sb_start_ignore_uninitialized(grid, term->rows);
int ofs_sb_rel =
grid_row_abs_to_sb_precalc_sb_start(grid, sb_start, grid->offset);
int new_view_sb_rel =
grid_row_abs_to_sb_precalc_sb_start(grid, sb_start, r_abs);
new_view_sb_rel = min(ofs_sb_rel, new_view_sb_rel);
grid->view = grid_row_sb_to_abs_precalc_sb_start(
grid, sb_start, new_view_sb_rel);
term_damage_view(term);
render_refresh(term);
input: don't clear text selection on modifier keypresses When kitty keyboard is enabled, pressing a modifier key will clear the text selection. This makes it difficult to copy text because the selection clears as soon as the user presses "ctrl". Tested-by: Robin Jarry <robin@jarry.cc> Signed-off-by: Tim Culverhouse <tim@timculverhouse.com>
2024-02-22 15:08:13 -06:00
break;
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
}
return true;
}
input: add new Unicode input mode This mode is activated through the new key-bindings.unicode-input and search-bindings.unicode-input key bindings. When active, the user can “build” a Unicode codepoint by typing its hexadecimal value. Note that there’s no visual feedback in this mode. This is intentional. This mode is intended to be a fallback for users that don’t use an IME. Closes #1116
2022-07-28 18:09:16 +02:00
case BIND_ACTION_UNICODE_INPUT:
unicode-mode: move state from seat to term This fixes an issue where entering unicode-mode in one foot client, also enabled unicode-mode on other foot clients. Both visually (although glitchy), and in effect. The reason the state was originally in the seat objects, was to fully support multi-seat. That is, one seat/keyboard entering unicode-mode should not affect other seats/keyboards. The issue with this is that seat objects are Wayland global. Thus, in server mode, all seat objects are shared between the foot clients. There is a similarity with IME, which also keeps state in the seat. There's one big difference, however, and that is IME has Wayland native enter/leave events, that the compositor emits when windows are focused/unfocused. These events allow us to reset IME state. For our own Unicode mode, there is nothing similar. This patch moves the Unicode state from seats, to the terminal struct. This does mean that if one seat/keyboard enters Unicode mode, then *all* seats/keyboards will affect the unicode state. This potential downside is outweighed by the fact that different foot clients no longer affect each other. Closes #1717
2024-05-21 07:06:45 +02:00
unicode_mode_activate(term);
input: add new Unicode input mode This mode is activated through the new key-bindings.unicode-input and search-bindings.unicode-input key bindings. When active, the user can “build” a Unicode codepoint by typing its hexadecimal value. Note that there’s no visual feedback in this mode. This is intentional. This mode is intended to be a fallback for users that don’t use an IME. Closes #1116
2022-07-28 18:09:16 +02:00
return true;
config: add new key-binding 'quit', unbound by default Closes #1475
2024-04-10 19:26:23 +02:00
case BIND_ACTION_QUIT:
term_shutdown(term);
return true;
config+url: add support for user-defined regex patterns Users can now define their own regex patterns, and use them via key bindings: [regex:foo] regex=foo(bar)? launch=path-to-script-or-application {match} [key-bindings] regex-launch=[foo] Control+Shift+q regex-copy=[foo] Control+Mod1+Shift+q That is, add a section called 'regex:', followed by an identifier. Define a regex and a launcher command line. Add a key-binding, regex-launch and/or regex-copy (similar to show-urls-launch and show-urls-copy), and connect them to the regex with the "[regex-name]" syntax (similar to how the pipe-* bindings work).
2025-02-03 08:55:47 +01:00
case BIND_ACTION_REGEX_LAUNCH:
case BIND_ACTION_REGEX_COPY:
if (binding->aux->type != BINDING_AUX_REGEX)
return true;
tll_foreach(term->conf->custom_regexes, it) {
const struct custom_regex *regex = &it->item;
if (streq(regex->name, binding->aux->regex_name)) {
xassert(!urls_mode_is_active(term));
enum url_action url_action = action == BIND_ACTION_REGEX_LAUNCH
? URL_ACTION_LAUNCH : URL_ACTION_COPY;
if (regex->regex == NULL) {
LOG_ERR("regex:%s has no regex defined", regex->name);
return true;
}
if (url_action == URL_ACTION_LAUNCH && regex->launch.argv.args == NULL) {
LOG_ERR("regex:%s has no launch command defined", regex->name);
return true;
}
urls_collect(term, url_action, &regex->preg, false, &term->urls);
urls_assign_key_combos(term->conf, &term->urls);
urls_render(term, &regex->launch);
return true;
}
}
LOG_ERR(
"no regex section named '%s' defined in the configuration",
binding->aux->regex_name);
return true;
key-bindings: add bindings to switch between color themes * color-theme-switch-1: select the primary color theme * color-theme-switch-2: select the alternative color theme * color-theme-toggle: toggle between the primary and alternative color themes
2025-04-20 07:58:02 +02:00
case BIND_ACTION_THEME_SWITCH_1:
config: add [colors-dark] and [colors-light], replacing [colors] and [colors2] The main reason for having two color sections is to be able to switch between dark and light. Thus, it's better if the section names reflect this, rather than the more generic 'colors' and 'colors2' (which was the dark one and which was the light one, now again?) When the second color section was added, we kept the original name, colors, to make sure we didn't break existing configurations, and third-party themes. However, in the long run, it's probably better to be specific in the section naming, to avoid confusion. So, add 'colors-dark', and 'colors-light'. Keep 'colors' and 'colors2' as aliases for now, but mark them as deprecated. They WILL be removed in a future release. Also rename the option values for initial-color-theme, from 1/2, to dark/light. Keep the old ones for now, marked as deprecated. Update all bundled themes to use the new names. In the light-only themes (i.e. themes that define a single, light, theme), use colors-light, and set initial-color-theme=light. Possible improvements: disable color switching if only one color section has been explicitly configured (todo: figure out how to handle the default color theme values...)
2025-12-19 09:29:06 +01:00
case BIND_ACTION_THEME_SWITCH_DARK:
term_theme_switch_to_dark(term);
key-bindings: add bindings to switch between color themes * color-theme-switch-1: select the primary color theme * color-theme-switch-2: select the alternative color theme * color-theme-toggle: toggle between the primary and alternative color themes
2025-04-20 07:58:02 +02:00
return true;
case BIND_ACTION_THEME_SWITCH_2:
config: add [colors-dark] and [colors-light], replacing [colors] and [colors2] The main reason for having two color sections is to be able to switch between dark and light. Thus, it's better if the section names reflect this, rather than the more generic 'colors' and 'colors2' (which was the dark one and which was the light one, now again?) When the second color section was added, we kept the original name, colors, to make sure we didn't break existing configurations, and third-party themes. However, in the long run, it's probably better to be specific in the section naming, to avoid confusion. So, add 'colors-dark', and 'colors-light'. Keep 'colors' and 'colors2' as aliases for now, but mark them as deprecated. They WILL be removed in a future release. Also rename the option values for initial-color-theme, from 1/2, to dark/light. Keep the old ones for now, marked as deprecated. Update all bundled themes to use the new names. In the light-only themes (i.e. themes that define a single, light, theme), use colors-light, and set initial-color-theme=light. Possible improvements: disable color switching if only one color section has been explicitly configured (todo: figure out how to handle the default color theme values...)
2025-12-19 09:29:06 +01:00
case BIND_ACTION_THEME_SWITCH_LIGHT:
term_theme_switch_to_light(term);
key-bindings: add bindings to switch between color themes * color-theme-switch-1: select the primary color theme * color-theme-switch-2: select the alternative color theme * color-theme-toggle: toggle between the primary and alternative color themes
2025-04-20 07:58:02 +02:00
return true;
case BIND_ACTION_THEME_TOGGLE:
term+input: refactor: move theme switching into term_theme_* functions
2025-06-09 07:37:29 +02:00
term_theme_toggle(term);
key-bindings: add bindings to switch between color themes * color-theme-switch-1: select the primary color theme * color-theme-switch-2: select the alternative color theme * color-theme-toggle: toggle between the primary and alternative color themes
2025-04-20 07:58:02 +02:00
return true;
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_BEGIN:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_CHAR_WISE, false);
return true;
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_BEGIN_BLOCK:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_BLOCK, false);
return true;
config: mouse bindings: add select-begin-block and select-row
2020-08-11 10:17:19 +02:00
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_EXTEND:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_extend(
seat, term, seat->mouse.col, seat->mouse.row, term->selection.kind);
return true;
config: add ‘select-extend-character-wise’ bind action This forces the (new) selection mode to be character-wise when extending a word- or line-wise selection. Default key binding is ctrl+RMB.
2021-01-06 11:11:46 +01:00
case BIND_ACTION_SELECT_EXTEND_CHAR_WISE:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
if (term->selection.kind != SELECTION_BLOCK) {
config: add ‘select-extend-character-wise’ bind action This forces the (new) selection mode to be character-wise when extending a word- or line-wise selection. Default key binding is ctrl+RMB.
2021-01-06 11:11:46 +01:00
selection_extend(
seat, term, seat->mouse.col, seat->mouse.row, SELECTION_CHAR_WISE);
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return true;
config: mouse bindings: add select-begin-block and select-row
2020-08-11 10:17:19 +02:00
}
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return false;
config: mouse bindings: add select-begin-block and select-row
2020-08-11 10:17:19 +02:00
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_WORD:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_WORD_WISE, false);
return true;
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_WORD_WS:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_WORD_WISE, true);
return true;
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
selection: add support for selecting the contents of a quote This patch changes the default of triple clicking, from selecting the current logical row, to first trying to select the contents of the quote under the cursor, and if failing to find a quote, selecting the current row (like before). This is implemented by adding a new key binding, 'select-quote'. It will search for surrounding quote characters, and if one is found on each side of the cursor, the quote is selected. If not, the entire row is selected instead. Subsequent selection operations will behave as if the selection is either a word selection (a quote was found), or a row selection (no quote found). Escaped quote characters are not supported: "foo \" bar" will match 'foo \', and not 'foo " bar'. Mismatched quotes are not custom handled. They will simply not match. Nested quotes ("123 'abc def' 456") are supported. Closes #1364
2023-09-19 16:23:34 +02:00
case BIND_ACTION_SELECT_QUOTE:
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_QUOTE_WISE, false);
break;
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_ROW:
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_LINE_WISE, false);
return true;
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
case BIND_ACTION_COUNT:
Convert some more uses of xassert(false) to BUG("...")
2021-02-09 15:16:19 +00:00
BUG("Invalid action type");
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return false;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
}
input: inhibit mouse events to client when a binding has consumed it This introduces a new state to a seat's mouse struct, 'consumed'. It is set on a mouse *press* event that is claimed by a mouse binding. It is cleared after a mouse *release* event. While set, *no* mouse motion or button events are sent to the client application.
2020-08-22 13:35:36 +02:00
return false;
wip: initial framework for dealing with key/mouse bindings in different modes This adds initial support for defining key and mouse bindings that are applied in different terminal modes/states. For example, there are two arrays dealing with key and mouse bindings in the "normal" mode. Most bindings will go here. There's also an array for "search" mode. These bindings will be used when the user has started a scrollback search. In the future, there may be a model selection mode as well. Or maybe "search" and "modal selection" will be combined into a single "keyboard" mode. We'll see. Since the keyboard bindings depend on the current XKB keymap, translation from the user specified key combination string cannot be done when loading the configuration, but must be done when we've received a keymap from the wayland server. We should explore if it's possible to load some kind of default keymap just to be able to verify the validity of the key combination strings at configuration load time, to be able to reject the configuration at startup. A couple of key bindings have been added as proof of concept. Mouse bindings aren't handled at all yet, and is likely to be re-written. For example, we can probably translate the configuration strings at configuration load time.
2020-03-08 12:08:46 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
static void
keyboard_keymap(void *data, struct wl_keyboard *wl_keyboard,
uint32_t format, int32_t fd, uint32_t size)
{
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
LOG_DBG("keyboard_keymap: keyboard=%p (format=%u, size=%u)",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
(void *)wl_keyboard, format, size);
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
struct wayland *wayl = seat->wayl;
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: ignore keymap if we don’t recognize its format
2020-11-09 19:59:12 +01:00
/*
* Free old keymap state
*/
wip: initial input handling
2019-06-19 10:04:47 +02:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->kbd.xkb_keymap != NULL) {
xkb_keymap_unref(seat->kbd.xkb_keymap);
seat->kbd.xkb_keymap = NULL;
input: free previous XKB state when we get a new one
2019-08-12 21:32:53 +02:00
}
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->kbd.xkb_state != NULL) {
xkb_state_unref(seat->kbd.xkb_state);
seat->kbd.xkb_state = NULL;
input: free previous XKB state when we get a new one
2019-08-12 21:32:53 +02:00
}
input: bind key bindings to raw key codes too Before, when looking for a matching user key binding, we only matched *symbols*. This means that the physical keys that generate a specific key binding is layout dependent. What's worse, it may not even be possible to generate the key binding at all. Russian is one such layout, where all the "normal" (us) symbols are replaced. By using raw key codes, we can get around this - the key code has a direct mapping to the physical key. However, matching raw key codes **only** doesn't always make sense either. For now, match **both** symbols _and_ key codes. Symbols take precedence. TODO: we might have to make this configurable _per binding_. Note: 'search' mode still uses mostly hardcoded shortcuts that still have this problem (i.e. ctrl+g doesn't work with a russian layout).
2020-03-18 14:29:34 +01:00
key-binding: new API, for handling sets of key bindings Up until now, our Wayland seats have been tracking key bindings. This makes sense, since the seat’s keymap determines how the key bindings are resolved. However, tying bindings to the seat/keymap alone isn’t enough, since we also depend on the current configuration (i.e. user settings) when resolving a key binding. This means configurations that doesn’t match the wayland object’s configuration, currently don’t resolve key bindings correctly. This applies to footclients where the user has overridden key bindings on the command line (e.g. --override key-bindings.foo=bar). Thus, to correctly resolve key bindings, each set of key bindings must be tied *both* to a seat/keymap, *and* a configuration. This patch introduces a key-binding manager, with an API to add/remove/lookup, and load/unload keymaps from sets of key bindings. In the API, sets are tied to a seat and terminal instance, since this makes the most sense (we need to instantiate, or incref a set whenever a new terminal instance is created). Internally, the set is tied to a seat and the terminal’s configuration. Sets are *added* when a new seat is added, and when a new terminal instance is created. Since there can only be one instance of each seat, sets are always removed when a seat is removed. Terminals on the other hand can re-use the same configuration (and typically do). Thus, sets ref-count the configuration. In other words, when instantiating a new terminal, we may not have to instantiate a new set of key bindings, but can often be incref:ed instead. Whenever the keymap changes on a seat, all key bindings sets associated with that seat reloads (re-resolves) their key bindings. Closes #931
2022-04-17 15:39:51 +02:00
key_binding_unload_keymap(wayl->key_binding_manager, seat);
config: wip: add support for modifiers in mouse bindings Mouse bindings can now include modifiers. They are specified in pretty much the same way as in keyboard bindings: Control+BTN_LEFT
2020-08-09 22:40:53 +02:00
input: ignore keymap if we don’t recognize its format
2020-11-09 19:59:12 +01:00
/* Verify keymap is in a format we understand */
switch ((enum wl_keyboard_keymap_format)format) {
case WL_KEYBOARD_KEYMAP_FORMAT_NO_KEYMAP:
input: keymap(): use a goto-label on error, to ensure we always close the keymap FD
2025-10-18 08:23:53 +02:00
goto err;
input: ignore keymap if we don’t recognize its format
2020-11-09 19:59:12 +01:00
case WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1:
break;
default:
LOG_WARN("unrecognized keymap format: %u", format);
input: keymap(): use a goto-label on error, to ensure we always close the keymap FD
2025-10-18 08:23:53 +02:00
goto err;
input: ignore keymap if we don’t recognize its format
2020-11-09 19:59:12 +01:00
}
char *map_str = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
if (map_str == MAP_FAILED) {
LOG_ERRNO("failed to mmap keyboard keymap");
input: keymap(): use a goto-label on error, to ensure we always close the keymap FD
2025-10-18 08:23:53 +02:00
goto err;
input: ignore keymap if we don’t recognize its format
2020-11-09 19:59:12 +01:00
}
while (map_str[size - 1] == '\0')
size--;
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
if (seat->kbd.xkb != NULL) {
seat->kbd.xkb_keymap = xkb_keymap_new_from_buffer(
seat->kbd.xkb, map_str, size, XKB_KEYMAP_FORMAT_TEXT_V1,
XKB_KEYMAP_COMPILE_NO_FLAGS);
}
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
input: keymap(): use a goto-label on error, to ensure we always close the keymap FD
2025-10-18 08:23:53 +02:00
munmap(map_str, size);
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
if (seat->kbd.xkb_keymap != NULL) {
seat->kbd.xkb_state = xkb_state_new(seat->kbd.xkb_keymap);
input: don’t use stale keycodes for arrow-up/down The keycodes will change if the seat’s keymap changes. Make sure we only do alternate scrolling if the seat has a keyboard, and use the *current* layout’s keycodes for arrow up/down (instead of the *first* layout’s).
2020-09-15 18:44:54 +02:00
input: use XKB_MOD_NAME_* macros instead of hard-coded strings
2020-11-11 18:25:54 +01:00
seat->kbd.mod_shift = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_SHIFT);
seat->kbd.mod_alt = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_ALT) ;
seat->kbd.mod_ctrl = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_CTRL);
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
seat->kbd.mod_super = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_LOGO);
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
seat->kbd.mod_caps = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_CAPS);
seat->kbd.mod_num = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_NUM);
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
/* Significant modifiers in the legacy keyboard protocol */
seat->kbd.legacy_significant = 0;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_shift != XKB_MOD_INVALID)
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
seat->kbd.legacy_significant |= 1 << seat->kbd.mod_shift;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_alt != XKB_MOD_INVALID)
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
seat->kbd.legacy_significant |= 1 << seat->kbd.mod_alt;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_ctrl != XKB_MOD_INVALID)
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
seat->kbd.legacy_significant |= 1 << seat->kbd.mod_ctrl;
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
if (seat->kbd.mod_super != XKB_MOD_INVALID)
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
seat->kbd.legacy_significant |= 1 << seat->kbd.mod_super;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
/* Significant modifiers in the kitty keyboard protocol */
seat->kbd.kitty_significant = seat->kbd.legacy_significant;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_caps != XKB_MOD_INVALID)
seat->kbd.kitty_significant |= 1 << seat->kbd.mod_caps;
if (seat->kbd.mod_num != XKB_MOD_INVALID)
seat->kbd.kitty_significant |= 1 << seat->kbd.mod_num;
input: get_current_modifiers() no longer strips insignificant mods Our internal binding handling cares about a different set of modifiers, compared to the kitty keyboard protocol. To handle this, get_current_modifiers() has been modified, to no longer strip the “unsignificant” modifiers. This is now up to the caller to do. To help, we keep two masks (for significant modifiers) in the seat struct; one for our internal binding handling (and the legacy keyboard protocol), and one for the kitty keyboard protocol. These two masks are updated when the seat’s keymap is updated/changed.
2021-11-21 11:27:31 +01:00
input: xkb: ignore virtual modifiers Some compositors (mutter/GNOME is one) adds _virtual_ modifiers to the set of active modifiers when e.g. Alt, Meta, Super or Hyper is pressed. For example, pressing Alt+b would result in *both* the Alt *and* the Mod1 modifier being set. Since foot makes close to zero assumptions on how the modifiers should be interpreted, this causes various breakages. For example, a foot shortcut defined as Mod1+b will not match, since the Alt modifiers is also set. This has forced users to redefine/override some of the default key bindings to include the additional modifiers. It also causes issues with the kitty keyboard protocol, for some key combinations. Mainly whether or not to use unshifted key or not, resulting in incorrect escape sequences. Since all the "real" modifiers are always set as well, we can safely ignore the virtual modifiers. Closes #2009
2025-03-29 10:34:40 +01:00
/*
* Create a mask of all "virtual" modifiers. Some compositors
* add these *in addition* to the "real" modifiers (Mod1,
* Mod2, etc).
*
* Since our modifier logic (both for internal shortcut
* processing, and e.g. the kitty keyboard protocol) makes
* very few assumptions on available modifiers, which keys map
* to which modifier etc, the presence of virtual modifiers
* causes various things to break.
*
* For example, if a foot shortcut is Mod1+b (i.e. Alt+b), it
* won't match if the compositor _also_ sets the Alt modifier
* (the corresponding shortcut in foot would be Alt+Mod1+b).
*
* See https://codeberg.org/dnkl/foot/issues/2009
*
* Mutter (GNOME) is known to set the virtual modifiers in
* addtiion to the real modifiers.
*
* As far as I know, there's no compositor that _only_ sets
* virtual modifiers (don't think that's even legal...?)
*/
{
xkb_mod_index_t alt = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_ALT);
xkb_mod_index_t meta = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_META);
xkb_mod_index_t super = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_SUPER);
xkb_mod_index_t hyper = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_HYPER);
xkb_mod_index_t num_lock = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_NUM);
xkb_mod_index_t scroll_lock = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_SCROLL);
xkb_mod_index_t level_three = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_LEVEL3);
xkb_mod_index_t level_five = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_VMOD_NAME_LEVEL5);
xkb_mod_index_t ignore = 0;
if (alt != XKB_MOD_INVALID) ignore |= 1 << alt;
if (meta != XKB_MOD_INVALID) ignore |= 1 << meta;
if (super != XKB_MOD_INVALID) ignore |= 1 << super;
if (hyper != XKB_MOD_INVALID) ignore |= 1 << hyper;
if (num_lock != XKB_MOD_INVALID) ignore |= 1 << num_lock;
if (scroll_lock != XKB_MOD_INVALID) ignore |= 1 << scroll_lock;
if (level_three != XKB_MOD_INVALID) ignore |= 1 << level_three;
if (level_five != XKB_MOD_INVALID) ignore |= 1 << level_five;
seat->kbd.virtual_modifiers = ignore;
}
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
seat->kbd.key_arrow_up = xkb_keymap_key_by_name(seat->kbd.xkb_keymap, "UP");
seat->kbd.key_arrow_down = xkb_keymap_key_by_name(seat->kbd.xkb_keymap, "DOWN");
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
}
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
key-binding: new API, for handling sets of key bindings Up until now, our Wayland seats have been tracking key bindings. This makes sense, since the seat’s keymap determines how the key bindings are resolved. However, tying bindings to the seat/keymap alone isn’t enough, since we also depend on the current configuration (i.e. user settings) when resolving a key binding. This means configurations that doesn’t match the wayland object’s configuration, currently don’t resolve key bindings correctly. This applies to footclients where the user has overridden key bindings on the command line (e.g. --override key-bindings.foo=bar). Thus, to correctly resolve key bindings, each set of key bindings must be tied *both* to a seat/keymap, *and* a configuration. This patch introduces a key-binding manager, with an API to add/remove/lookup, and load/unload keymaps from sets of key bindings. In the API, sets are tied to a seat and terminal instance, since this makes the most sense (we need to instantiate, or incref a set whenever a new terminal instance is created). Internally, the set is tied to a seat and the terminal’s configuration. Sets are *added* when a new seat is added, and when a new terminal instance is created. Since there can only be one instance of each seat, sets are always removed when a seat is removed. Terminals on the other hand can re-use the same configuration (and typically do). Thus, sets ref-count the configuration. In other words, when instantiating a new terminal, we may not have to instantiate a new set of key bindings, but can often be incref:ed instead. Whenever the keymap changes on a seat, all key bindings sets associated with that seat reloads (re-resolves) their key bindings. Closes #931
2022-04-17 15:39:51 +02:00
key_binding_load_keymap(wayl->key_binding_manager, seat);
input: keymap(): use a goto-label on error, to ensure we always close the keymap FD
2025-10-18 08:23:53 +02:00
err:
close(fd);
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
Revert "input: generate key down events on keyboard-enter" This reverts commit 84739d78c626ad12543417dc1e3038abd6a4e2d5.
2020-01-14 19:28:37 +01:00
static void
wip: initial input handling
2019-06-19 10:04:47 +02:00
keyboard_enter(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
struct wl_surface *surface, struct wl_array *keys)
{
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(surface != NULL);
input: assert serial received from compositor is non-zero
2022-04-23 15:54:37 +02:00
xassert(serial != 0);
input: keyboard/pointer_enter: assert surface != NULL
2019-11-28 19:46:27 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
wayland: remove all usages of wayl_terminal_from_surface() Use the 'user data' pointer from the wayland surface instead.
2020-02-29 12:13:58 +01:00
struct wl_window *win = wl_surface_get_user_data(surface);
struct terminal *term = win->term;
input: include seat name in debug log output
2020-07-11 11:13:45 +02:00
LOG_DBG("%s: keyboard_enter: keyboard=%p, serial=%u, surface=%p",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
seat->name, (void *)wl_keyboard, serial, (void *)surface);
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
focus in/out: terminal checks whether it is a state change or not
2020-07-09 09:16:54 +02:00
term_kbd_focus_in(term);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->kbd_focus = term;
seat: use separate 'enter' serials for keyboard and mouse
2020-07-09 11:20:46 +02:00
seat->kbd.serial = serial;
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
static bool
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
start_repeater(struct seat *seat, uint32_t key)
wip: initial input handling
2019-06-19 10:04:47 +02:00
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->kbd.repeat.dont_re_repeat)
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return true;
input: don’t enable keyboard repeat timer when repeat rate is zero wayland-client-protocol.h: Negative values for either rate or delay are illegal. A rate of zero will disable any repeating (regardless of the value of delay). This fixes a division-by-zero crash.
2021-01-16 12:27:58 +01:00
if (seat->kbd.repeat.rate == 0)
return true;
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
struct itimerspec t = {
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
.it_value = {.tv_sec = 0, .tv_nsec = seat->kbd.repeat.delay * 1000000},
.it_interval = {.tv_sec = 0, .tv_nsec = 1000000000 / seat->kbd.repeat.rate},
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
};
input: stop key repeater when input focus is lost
2019-06-21 18:40:53 +02:00
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
if (t.it_value.tv_nsec >= 1000000000) {
t.it_value.tv_sec += t.it_value.tv_nsec / 1000000000;
t.it_value.tv_nsec %= 1000000000;
}
if (t.it_interval.tv_nsec >= 1000000000) {
t.it_interval.tv_sec += t.it_interval.tv_nsec / 1000000000;
t.it_interval.tv_nsec %= 1000000000;
}
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (timerfd_settime(seat->kbd.repeat.fd, 0, &t, NULL) < 0) {
LOG_ERRNO("%s: failed to arm keyboard repeat timer", seat->name);
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return false;
input: stop key repeater when input focus is lost
2019-06-21 18:40:53 +02:00
}
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->kbd.repeat.key = key;
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return true;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
}
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
static bool
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
stop_repeater(struct seat *seat, uint32_t key)
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (key != -1 && key != seat->kbd.repeat.key)
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return true;
don't use empty struct initializers
2020-08-23 07:42:20 +02:00
if (timerfd_settime(seat->kbd.repeat.fd, 0, &(struct itimerspec){{0}}, NULL) < 0) {
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
LOG_ERRNO("%s: failed to disarm keyboard repeat timer", seat->name);
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return false;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
}
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
return true;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
}
static void
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
keyboard_leave(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
struct wl_surface *surface)
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: use a timer fd to handle keyboard key repeat Instead of running a repeater thread that writes the key to repeat over a pipe, use a simple timer fd. No more locking or condition signalling. No need to track start/stop/exist states. We simply set up the initial timeout value to be the 'delay', and the interval to be the repeat 'rate'.
2019-08-05 19:33:01 +02:00
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
LOG_DBG("keyboard_leave: keyboard=%p, serial=%u, surface=%p",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
(void *)wl_keyboard, serial, (void *)surface);
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->kbd_focus == NULL ||
input: sway 1.2 bug: keyboard_leave() called with surface == NULL
2019-11-28 19:24:16 +01:00
surface == NULL || /* Seen on Sway 1.2 */
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
((const struct wl_window *)wl_surface_get_user_data(surface))->term == seat->kbd_focus
wayland: remove all usages of wayl_terminal_from_surface() Use the 'user data' pointer from the wayland surface instead.
2020-02-29 12:13:58 +01:00
);
input: may get keyboard_exit() event with no focused terminal This happens on Sway when exiting a screen locker. Or at least that's when we see the problem; it's unclear if the event occurs when starting the screen locker, or when exiting it. Or maybe its both. Anyway, don't try to unfocus a NULL-terminal.
2019-11-21 18:17:02 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct terminal *old_focused = seat->kbd_focus;
seat->kbd_focus = NULL;
input: keyboard_leave: reset focused *before* doing anything else And update xcursor. This is necessary since we may still have mouse focus. But without keyboard focus, we don't display the 'text' xcursor.
2019-11-29 22:11:41 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
stop_repeater(seat, -1);
input: only call term_kbd_focus_{in,out}() on actual state change That is, only call term_kbd_focus_in() if we're the *first* seat focusing that terminal, and only call term_kbd_focus_out() if we're the *last* seat that focused it.
2020-07-09 08:46:25 +02:00
seat->kbd.shift = false;
seat->kbd.alt = false;
seat->kbd.ctrl = false;
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
seat->kbd.super = false;
input: reset modifiers in keyboard_leave() Closes #2034
2025-04-19 08:05:15 +02:00
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
if (seat->kbd.xkb_compose_state != NULL)
xkb_compose_state_reset(seat->kbd.xkb_compose_state);
input: reset modifier state on keyboard-leave
2020-01-13 19:58:57 +01:00
input: reset modifiers in keyboard_leave() Closes #2034
2025-04-19 08:05:15 +02:00
if (seat->kbd.xkb_state != NULL && seat->kbd.xkb_keymap != NULL) {
const xkb_layout_index_t layout_count = xkb_keymap_num_layouts(seat->kbd.xkb_keymap);
for (xkb_layout_index_t i = 0; i < layout_count; i++)
xkb_state_update_mask(seat->kbd.xkb_state, 0, 0, 0, i, i, i);
}
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
if (old_focused != NULL) {
seat->pointer.hidden = false;
term_xcursor_update_for_seat(old_focused, seat);
input: keyboard-leave: move comment to where it belongs
2020-01-02 19:30:34 +01:00
term_kbd_focus_out(old_focused);
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
} else {
input: document why wayl->focused may be NULL
2019-11-24 00:06:50 +01:00
/*
* Sway bug - under certain conditions we get a
* keyboard_leave() (and keyboard_key()) without first having
* received a keyboard_enter()
*/
input: keyboard/pointer_leave: warn if we didn't see corresponding enter event
2019-11-28 19:47:00 +01:00
LOG_WARN(
"compositor sent keyboard_leave event without a keyboard_enter "
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
"event: surface=%p", (void *)surface);
input: document why wayl->focused may be NULL
2019-11-24 00:06:50 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
static const struct key_data *
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
keymap_data_for_sym(xkb_keysym_t sym, size_t *count)
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
{
switch (sym) {
case XKB_KEY_Escape: *count = ALEN(key_escape); return key_escape;
case XKB_KEY_Return: *count = ALEN(key_return); return key_return;
keymap: handle shift+tab combos correctly, after consuming modifiers Shift+Tab is an odd bird in XKB; it produces a shifted variant of tab, ISO_Left_Tab, with Shift being a consumed modifier. From a terminal perspective, Tab and ISO_Left_Tab are the same key, with Shift+Tab generating ‘CSI Z’, and all other combos generating a ‘CSI 27;mods;9~’ escape. Before, when we didn’t filter out consumed modifiers, we could simply re-use the keymap for Tab when translating ISO_Left_Tab. This is no longer possible, since shift has been filtered out. As a result, Shift+Tab no longer generated ‘CSI Z’, but ‘\t’. I.e as if shift wasn’t being pressed. This patch adds a separate keymap table for ISO_Left_Tab. It’s MOD_ANY entry corresponds to Shift+Tab, and emits ‘CSI Z’. All its other entries *exclude* shift (since it has been consumed), *but*, the encoded modifier (in the escape sequences) *include* shift.
2021-02-28 11:50:05 +01:00
case XKB_KEY_ISO_Left_Tab: *count = ALEN(key_iso_left_tab); return key_iso_left_tab;
case XKB_KEY_Tab: *count = ALEN(key_tab); return key_tab;
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
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;
input: add key mapping for XKB_KEY_KP_Decimal
2020-06-27 20:03:41 +02:00
case XKB_KEY_KP_Decimal: *count = ALEN(key_kp_decimal); return key_kp_decimal;
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
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;
}
return NULL;
}
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
static const struct key_data *
input: keymap_lookup: remove unused argument ‘seat’
2021-05-25 17:57:39 +02:00
keymap_lookup(struct terminal *term, xkb_keysym_t sym, enum modifier mods)
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
{
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
size_t count;
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
const struct key_data *info = keymap_data_for_sym(sym, &count);
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
if (info == NULL)
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
return NULL;
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: enforce ‘numerical’ keypad mode when Num Lock override is enabled When num lock override has been enabled via “CSI?1035h” (the default), keypad is always considered to be in ‘numerical’ mode. This affects how keypad keys are translated to escape sequences when Num Lock is active. The keypad has four modes: * Num Lock off, numerical mode * Num Lock off, application mode * Num Lock on, numerical mode * Num Lock on, application mode The keymap is identical for numerical and application mode when Num Lock is off, meaning the keypad effectively has three different modes. In XTerm, numerical and application mode _can_ be the same, **if** the ‘numLock’ resource is set to true (the default). It is only when ‘numLock’ is false that the application mode is actually used. This patch changes foot to do the same. We don’t expose an option, but do implement “CSI ? 1035”. Closes #194
2020-11-11 18:28:37 +01:00
const enum cursor_keys cursor_keys_mode = term->cursor_keys_mode;
const enum keypad_keys keypad_keys_mode
input: relax requirements for overriding keypad application mode Don’t require NumLock to be locked. Foot has no idea _which_ modifier the user has mapped NumLock to, meaning we really cannot require it to be locked.
2020-12-01 18:27:56 +01:00
= term->num_lock_modifier ? KEYPAD_NUMERICAL : term->keypad_keys_mode;
input: enforce ‘numerical’ keypad mode when Num Lock override is enabled When num lock override has been enabled via “CSI?1035h” (the default), keypad is always considered to be in ‘numerical’ mode. This affects how keypad keys are translated to escape sequences when Num Lock is active. The keypad has four modes: * Num Lock off, numerical mode * Num Lock off, application mode * Num Lock on, numerical mode * Num Lock on, application mode The keymap is identical for numerical and application mode when Num Lock is off, meaning the keypad effectively has three different modes. In XTerm, numerical and application mode _can_ be the same, **if** the ‘numLock’ resource is set to true (the default). It is only when ‘numLock’ is false that the application mode is actually used. This patch changes foot to do the same. We don’t expose an option, but do implement “CSI ? 1035”. Closes #194
2020-11-11 18:28:37 +01:00
input: remove non-existing state from debug log
2020-12-23 18:13:40 +01:00
LOG_DBG("keypad mode: %d", keypad_keys_mode);
ime: wip: commit all changes in ‘done()’
2020-12-01 19:31:49 +01:00
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
for (size_t j = 0; j < count; j++) {
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
enum modifier modifiers = info[j].modifiers;
if (modifiers & MOD_MODIFY_OTHER_KEYS_STATE1) {
if (term->modify_other_keys_2)
continue;
modifiers &= ~MOD_MODIFY_OTHER_KEYS_STATE1;
}
if (modifiers & MOD_MODIFY_OTHER_KEYS_STATE2) {
if (!term->modify_other_keys_2)
continue;
modifiers &= ~MOD_MODIFY_OTHER_KEYS_STATE2;
}
if (modifiers != MOD_ANY && modifiers != mods)
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
continue;
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
if (info[j].cursor_keys_mode != CURSOR_KEYS_DONTCARE &&
input: enforce ‘numerical’ keypad mode when Num Lock override is enabled When num lock override has been enabled via “CSI?1035h” (the default), keypad is always considered to be in ‘numerical’ mode. This affects how keypad keys are translated to escape sequences when Num Lock is active. The keypad has four modes: * Num Lock off, numerical mode * Num Lock off, application mode * Num Lock on, numerical mode * Num Lock on, application mode The keymap is identical for numerical and application mode when Num Lock is off, meaning the keypad effectively has three different modes. In XTerm, numerical and application mode _can_ be the same, **if** the ‘numLock’ resource is set to true (the default). It is only when ‘numLock’ is false that the application mode is actually used. This patch changes foot to do the same. We don’t expose an option, but do implement “CSI ? 1035”. Closes #194
2020-11-11 18:28:37 +01:00
info[j].cursor_keys_mode != cursor_keys_mode)
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
continue;
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
if (info[j].keypad_keys_mode != KEYPAD_DONTCARE &&
input: enforce ‘numerical’ keypad mode when Num Lock override is enabled When num lock override has been enabled via “CSI?1035h” (the default), keypad is always considered to be in ‘numerical’ mode. This affects how keypad keys are translated to escape sequences when Num Lock is active. The keypad has four modes: * Num Lock off, numerical mode * Num Lock off, application mode * Num Lock on, numerical mode * Num Lock on, application mode The keymap is identical for numerical and application mode when Num Lock is off, meaning the keypad effectively has three different modes. In XTerm, numerical and application mode _can_ be the same, **if** the ‘numLock’ resource is set to true (the default). It is only when ‘numLock’ is false that the application mode is actually used. This patch changes foot to do the same. We don’t expose an option, but do implement “CSI ? 1035”. Closes #194
2020-11-11 18:28:37 +01:00
info[j].keypad_keys_mode != keypad_keys_mode)
input: add a switch-based function that translates XKB keysym to escape data
2020-01-11 18:18:31 +01:00
continue;
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
return &info[j];
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
}
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
return NULL;
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
}
macros: add UNITTEST macro and use to replace test_keymap_lookup()
2021-05-25 18:38:16 +01:00
UNITTEST
input: regression test for escape sequence generated for ctrl+shift+tab
2021-05-25 17:57:53 +02:00
{
struct terminal term = {
.num_lock_modifier = false,
.keypad_keys_mode = KEYPAD_NUMERICAL,
.cursor_keys_mode = CURSOR_KEYS_NORMAL,
};
const struct key_data *info = keymap_lookup(&term, XKB_KEY_ISO_Left_Tab, MOD_SHIFT | MOD_CTRL);
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
xassert(info != NULL);
util: add streq() function and use in place of strcmp(...) == 0
2024-01-24 23:17:28 +00:00
xassert(streq(info->seq, "\033[27;6;9~"));
input: regression test for escape sequence generated for ctrl+shift+tab
2021-05-25 17:57:53 +02:00
}
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
UNITTEST
{
struct terminal term = {
.modify_other_keys_2 = false,
};
const struct key_data *info = keymap_lookup(&term, XKB_KEY_Return, MOD_ALT);
xassert(info != NULL);
util: add streq() function and use in place of strcmp(...) == 0
2024-01-24 23:17:28 +00:00
xassert(streq(info->seq, "\033\r"));
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
term.modify_other_keys_2 = true;
info = keymap_lookup(&term, XKB_KEY_Return, MOD_ALT);
xassert(info != NULL);
util: add streq() function and use in place of strcmp(...) == 0
2024-01-24 23:17:28 +00:00
xassert(streq(info->seq, "\033[27;3;13~"));
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
}
config, input: allow configuring select-override modifiers
2021-09-27 19:09:07 +00:00
void
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
get_current_modifiers(const struct seat *seat,
xkb_mod_mask_t *effective,
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
xkb_mod_mask_t *consumed, uint32_t key,
bool filter_locked)
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
{
input: get_current_modifiers(): don’t crash if seat has no keyboard Closes #963
2022-03-04 17:54:19 +01:00
if (unlikely(seat->kbd.xkb_state == NULL)) {
if (effective != NULL)
*effective = 0;
if (consumed != NULL)
*consumed = 0;
input: filter out non-significant modifiers when matching mouse bindings Closes #736
2021-10-06 20:12:17 +02:00
}
input: get_current_modifiers(): don’t crash if seat has no keyboard Closes #963
2022-03-04 17:54:19 +01:00
else {
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
const xkb_mod_mask_t locked =
xkb_state_serialize_mods(seat->kbd.xkb_state, XKB_STATE_MODS_LOCKED);
input: get_current_modifiers(): don’t crash if seat has no keyboard Closes #963
2022-03-04 17:54:19 +01:00
if (effective != NULL) {
*effective = xkb_state_serialize_mods(
seat->kbd.xkb_state, XKB_STATE_MODS_EFFECTIVE);
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
if (filter_locked)
*effective &= ~locked;
input: get_current_modifiers(): don’t crash if seat has no keyboard Closes #963
2022-03-04 17:54:19 +01:00
}
if (consumed != NULL) {
*consumed = xkb_state_key_get_consumed_mods2(
seat->kbd.xkb_state, key, XKB_CONSUMED_MODE_XKB);
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
if (filter_locked)
*consumed &= ~locked;
input: get_current_modifiers(): don’t crash if seat has no keyboard Closes #963
2022-03-04 17:54:19 +01:00
}
input: get_current_modifiers(): use xkb_state_key_get_consumed_mods2() Explicitly request consumed modifiers using the `XKB` mode.
2021-11-27 18:44:29 +01:00
}
input: filter out non-significant modifiers when matching mouse bindings Closes #736
2021-10-06 20:12:17 +02:00
}
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
struct kbd_ctx {
xkb_layout_index_t layout;
xkb_keycode_t key;
xkb_keysym_t sym;
struct {
const xkb_keysym_t *syms;
size_t count;
} level0_syms;
xkb_mod_mask_t mods;
xkb_mod_mask_t consumed;
struct {
const uint8_t *buf;
size_t count;
} utf8;
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
uint32_t *utf32;
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
enum xkb_compose_status compose_status;
enum wl_keyboard_key_state key_state;
};
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
static bool
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
legacy_kbd_protocol(struct seat *seat, struct terminal *term,
const struct kbd_ctx *ctx)
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
{
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
if (ctx->key_state != WL_KEYBOARD_KEY_STATE_PRESSED)
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
return false;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
if (ctx->compose_status == XKB_COMPOSE_COMPOSING)
return false;
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
enum modifier keymap_mods = MOD_NONE;
keymap_mods |= seat->kbd.shift ? MOD_SHIFT : MOD_NONE;
keymap_mods |= seat->kbd.alt ? MOD_ALT : MOD_NONE;
keymap_mods |= seat->kbd.ctrl ? MOD_CTRL : MOD_NONE;
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
keymap_mods |= seat->kbd.super ? MOD_META : MOD_NONE;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
const xkb_keysym_t sym = ctx->sym;
const size_t count = ctx->utf8.count;
const uint8_t *const utf8 = ctx->utf8.buf;
csi/input: remove private mode 27127 This effectively reverts commit 31c73f0cf01e1d0bdcd1435136b010c1c1ab442c.
2022-02-09 20:50:20 +00:00
const struct key_data *keymap = keymap_lookup(term, sym, keymap_mods);
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
if (keymap != NULL) {
term_to_slave(term, keymap->seq, strlen(keymap->seq));
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
return true;
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
}
if (count == 0)
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
return false;
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
#define is_control_key(x) ((x) >= 0x40 && (x) <= 0x7f)
#define IS_CTRL(x) ((x) < 0x20 || ((x) >= 0x7f && (x) <= 0x9f))
input: improved debug logging of key press/release * Log which it is: press or release * Include locked modifiers * Include human-readable names of the modifiers
2024-02-20 16:18:55 +01:00
//LOG_DBG("term->modify_other_keys=%d, count=%zu, is_ctrl=%d (utf8=0x%02x), sym=%d",
//term->modify_other_keys_2, count, IS_CTRL(utf8[0]), utf8[0], sym);
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
bool ctrl_is_in_effect = (keymap_mods & MOD_CTRL) != 0;
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
bool ctrl_seq = is_control_key(sym) || (count == 1 && IS_CTRL(utf8[0]));
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
bool modify_other_keys2_in_effect = false;
if (term->modify_other_keys_2) {
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Try to mimic XTerm's behavior, when holding shift:
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
*
* - if other modifiers are pressed (e.g. Alt), emit a CSI escape
* - upper-case symbols A-Z are encoded as an CSI escape
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* - other upper-case symbols (e.g 'Ö') or emitted as is
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
* - non-upper cased symbols are _mostly_ emitted as is (foot
* always emits as is)
*
* Examples (assuming Swedish layout):
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* - Shift-a ('A') emits a CSI
* - Shift-, (';') emits ';'
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
* - Shift-Alt-, (Alt-;) emits a CSI
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* - Shift-ö ('Ö') emits 'Ö'
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
*/
/* Any modifiers, besides shift active? */
const xkb_mod_mask_t shift_mask = 1 << seat->kbd.mod_shift;
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
if ((ctx->mods & ~shift_mask & seat->kbd.legacy_significant) != 0)
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
modify_other_keys2_in_effect = true;
else {
const xkb_layout_index_t layout_idx = xkb_state_key_get_layout(
seat->kbd.xkb_state, ctx->key);
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Get pressed key's base symbol.
* - for 'A' (shift-a), that's 'a'
* - for ';' (shift-,), that's ','
input: improve XTerm compatibility when modifyOtherKeys=2 Before this, foot always emitted a CSI if _any_ modifier was active. XTerm doesn’t behave quite like this. Instead, it appears to special-case shift somewhat: If the generated symbol (e.g ‘A’) is the upper case version of the pressed key’s base symbol (‘a’), and is in the range a-z, emit a CSI. If not emit a plain symbol: Examples (Swedish layout): * shift-a (generated symbol is ‘A’) emits a CSI * shift-, (generated symbol is ‘;’) emits ‘;’ * shift-alt-, (generated symbol is ‘;’) emits a CSI Closes #1009
2022-04-07 12:42:44 +02:00
*/
const xkb_keysym_t *base_syms = NULL;
size_t base_count = xkb_keymap_key_get_syms_by_level(
seat->kbd.xkb_keymap, ctx->key, layout_idx, 0, &base_syms);
/* Check if base symbol(s) is a-z. If so, emit CSI */
const xkb_keysym_t lower_cased_sym = xkb_keysym_to_lower(ctx->sym);
for (size_t i = 0; i < base_count; i++) {
const xkb_keysym_t s = base_syms[i];
if (lower_cased_sym == s && s >= XKB_KEY_a && s <= XKB_KEY_z) {
modify_other_keys2_in_effect = true;
break;
}
}
}
}
if (keymap_mods != MOD_NONE && (modify_other_keys2_in_effect ||
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
(ctrl_is_in_effect && !ctrl_seq)))
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
{
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,
};
input: legacy: use ALEN(mod_param_map)
2021-11-21 15:07:38 +01:00
xassert(keymap_mods < ALEN(mod_param_map));
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
int modify_param = mod_param_map[keymap_mods];
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
xassert(modify_param != 0);
input: legacy: reduce size of reply buffer Its maximum size is known; the only two variables are two integers. We know the maximum length of an integer converted to a string.
2021-11-21 15:05:38 +01:00
char reply[32];
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
size_t n = xsnprintf(reply, sizeof(reply), "\x1b[27;%d;%d~", modify_param, sym);
term_to_slave(term, reply, n);
}
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
else if (keymap_mods & MOD_ALT) {
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
/*
* When the alt modifier is pressed, we do one out of three things:
*
* 1. we prefix the output bytes with ESC
* 2. we set the 8:th bit in the output byte
* 3. we ignore the alt modifier
*
* #1 is configured with \E[?1036, and is on by default
*
input: grammar: “an UTF-8” -> “a UTF-8”
2021-11-21 15:06:41 +01:00
* If #1 has been disabled, we use #2, *if* it's a single byte
* we're emitting. Since this is a UTF-8 terminal, we then
* UTF8-encode the 8-bit character. #2 is configured with
* \E[?1034, and is on by default.
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
*
* Lastly, if both #1 and #2 have been disabled, the alt
* modifier is ignored.
*/
if (term->meta.esc_prefix) {
term_to_slave(term, "\x1b", 1);
term_to_slave(term, utf8, count);
}
else if (term->meta.eight_bit && count == 1) {
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
const char32_t wc = 0x80 | utf8[0];
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
char utf8_meta[MB_CUR_MAX];
size_t chars = c32rtomb(utf8_meta, wc, &(mbstate_t){0});
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
if (chars != (size_t)-1)
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
term_to_slave(term, utf8_meta, chars);
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
else
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
term_to_slave(term, utf8, count);
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
}
else {
/* Alt ignored */
term_to_slave(term, utf8, count);
}
} else
term_to_slave(term, utf8, count);
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
return true;
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
}
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
UNITTEST
{
/* Verify the kitty keymap is sorted */
xkb_keysym_t last = 0;
for (size_t i = 0; i < ALEN(kitty_keymap); i++) {
const struct kitty_key_data *e = &kitty_keymap[i];
xassert(e->sym > last);
last = e->sym;
}
}
static int
kitty_search(const void *_key, const void *_e)
{
const xkb_keysym_t *key = _key;
const struct kitty_key_data *e = _e;
return *key - e->sym;
}
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
static bool
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
kitty_kbd_protocol(struct seat *seat, struct terminal *term,
const struct kbd_ctx *ctx)
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
{
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
const bool repeating = seat->kbd.repeat.dont_re_repeat;
const bool pressed = ctx->key_state == WL_KEYBOARD_KEY_STATE_PRESSED && !repeating;
const bool released = ctx->key_state == WL_KEYBOARD_KEY_STATE_RELEASED;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
const bool composing = ctx->compose_status == XKB_COMPOSE_COMPOSING;
input: kitty: merge handling of plain-text and composed characters All plain-text and composed characters are now printed as-is, in a single place. Also fix handling of “generic” keys when emitted as escapes; don’t use the raw XKB symbol as key in the escape, convert it to a unicode code point first. For many symbols, these are the same. But not all. For now, we fallback to using the symbol as is if XKB fails to convert it to a codepoint. Not sure if we should simply drop the key press instead. Composed characters also need special treatment; we can’t use the symbol as is, since it typically refers to the last key pressed (i.e. not the composed character). And, that key is also (usually) a special “dead” key, which cannot be converted to a unicode codepoint. So, what we do is convert the generated utf8 string, and (try to) convert it to a wchar. If it succeeds, use that. If not, fallback to using the XKB symbol (as above).
2021-11-29 20:13:23 +01:00
const bool composed = ctx->compose_status == XKB_COMPOSE_COMPOSED;
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
kitty: composed characters with “report associated text” The generic input handler now converts the composed character to it’s UTF-32 equivalent. This means we now provide a valid UTF-32 codepoint for both composed characters, and non-composed (plain-text) characters. Use this in the kitty protocol to simplify the logic around composed characters, by simply treating them as plain text.
2021-12-07 07:31:34 +01:00
const enum kitty_kbd_flags flags =
term->grid->kitty_kbd.flags[term->grid->kitty_kbd.idx];
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
const bool disambiguate = flags & KITTY_KBD_DISAMBIGUATE;
const bool report_events = flags & KITTY_KBD_REPORT_EVENT;
kitty: initial support for “report alternate key” In this mode, the “shifted” and “base layout” keys are added to the CSIs, as sub-parameters to the “key” parameter. Note that this PR only implements the “shifted” key, not the “base layout key”. This is done by converting the original XKB symbol to it’s corresponding UTF-32 codepoint. If this codepoint is different from the one we use as “key” in the CSI, we add it as a sub-parameter. Related to #319
2021-12-07 19:55:52 +01:00
const bool report_alternate = flags & KITTY_KBD_REPORT_ALTERNATE;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
const bool report_all_as_escapes = flags & KITTY_KBD_REPORT_ALL;
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
input: kitty: treat repeating == pressed when report-events is off
2021-11-28 19:20:37 +01:00
if (!report_events && released)
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
return false;
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* TODO: should we even bother with this, or just say it's not supported? */
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
if (!disambiguate && !report_all_as_escapes && pressed)
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
return legacy_kbd_protocol(seat, term, ctx);
kitty: composed characters with “report associated text” The generic input handler now converts the composed character to it’s UTF-32 equivalent. This means we now provide a valid UTF-32 codepoint for both composed characters, and non-composed (plain-text) characters. Use this in the kitty protocol to simplify the logic around composed characters, by simply treating them as plain text.
2021-12-07 07:31:34 +01:00
const xkb_keysym_t sym = ctx->sym;
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
const uint32_t *utf32 = ctx->utf32;
kitty: composed characters with “report associated text” The generic input handler now converts the composed character to it’s UTF-32 equivalent. This means we now provide a valid UTF-32 codepoint for both composed characters, and non-composed (plain-text) characters. Use this in the kitty protocol to simplify the logic around composed characters, by simply treating them as plain text.
2021-12-07 07:31:34 +01:00
const uint8_t *const utf8 = ctx->utf8.buf;
const size_t count = ctx->utf8.count;
input: kitty: update to latest version of the spec Starting with kitty 0.32.0, the modifier bits during modifier key events behave differently, compared to before. Or, rather, they have now been spec:ed; before, behavior was different on e.g. MacOS, and Linux. The new behavior is this: On key press, the modifier bits in the kitty key event *includes* the pressed modifier key. On key release, the modifier bits in the kitty key event does *not* include the released modifier key. In other words, The modifier bits reflects the state *after* the key event. This is the exact opposite of what foot did before this patch. The patch is really pretty small: in order to include the key in the modifier set, we simulate a key press to update the XKB state, using xkb_state_uppate_key(). For key pressed, we simulate an XKB_KEY_DOWN event, and for key releases we simulate an XKB_KEY_UP event. Then we re-retrieve the modifers, both the full set, and the consumed set. Closes #1561
2024-01-22 16:39:26 +01:00
/* Lookup sym in the pre-defined keysym table */
const struct kitty_key_data *info = bsearch(
&sym, kitty_keymap, ALEN(kitty_keymap), sizeof(kitty_keymap[0]),
&kitty_search);
xassert(info == NULL || info->sym == sym);
xkb_mod_mask_t mods = 0;
kitty kbd: update handling of locked modifiers The kitty keyboard specification has been updated/clarified yet again. Locked modifiers are to be ignored if the key event would result in plain text without the locked modifier being enabled. In short, locked modifiers are included in the set of modifiers reported in a key event. But having a locked modifier enabled doesn't turn all key events into CSIu sequences. For example, with only the disambiguate mode enabled, pressing 'a', or 'shift+a' results in a/A regardless of the state of Caps- or NumLock. But 'ctrl+a', which always results in a CSIu, will have a different modifier list, depending on whether Caps- or NumLock are enabled.
2024-03-02 08:16:17 +01:00
xkb_mod_mask_t locked = 0;
kitty kbd: switch from GTK to XKB mode for 'consumed' modifiers This fixes an issue where some key combinations resulted in different output (e.g. escape code vs. plain text) depending on the state of e.g. the NumLock key. One such example is Shift+space. Another example is Shift+BackSpace. This patch also removes the hardcoded CapsLock filter, when determining whether a key combo produces text or not, and instead uses the locked modifiers as reported by XKB.
2024-02-29 09:32:38 +01:00
xkb_mod_mask_t consumed = ctx->consumed;
input: kitty: update to latest version of the spec Starting with kitty 0.32.0, the modifier bits during modifier key events behave differently, compared to before. Or, rather, they have now been spec:ed; before, behavior was different on e.g. MacOS, and Linux. The new behavior is this: On key press, the modifier bits in the kitty key event *includes* the pressed modifier key. On key release, the modifier bits in the kitty key event does *not* include the released modifier key. In other words, The modifier bits reflects the state *after* the key event. This is the exact opposite of what foot did before this patch. The patch is really pretty small: in order to include the key in the modifier set, we simulate a key press to update the XKB state, using xkb_state_uppate_key(). For key pressed, we simulate an XKB_KEY_DOWN event, and for key releases we simulate an XKB_KEY_UP event. Then we re-retrieve the modifers, both the full set, and the consumed set. Closes #1561
2024-01-22 16:39:26 +01:00
if (info != NULL && info->is_modifier) {
/*
* Special-case modifier keys.
*
* Normally, the "current" XKB state reflects the state
* *before* the current key event. In other words, the
* modifiers for key events that affect the modifier state
* (e.g. one of the control keys, or shift keys etc) does
* *not* include the key itself.
*
* Put another way, if you press "control", the modifier set
* is empty in the key press event, but contains "ctrl" in the
* release event.
*
* The kitty protocol mandates the modifier list contain the
* key itself, in *both* the press and release event.
*
* We handle this by updating the XKB state to *include* the
* current key, retrieve the set of modifiers (including the
* set of consumed modifiers), and then revert the XKB update.
*/
xkb_state_update_key(
seat->kbd.xkb_state, ctx->key, pressed ? XKB_KEY_DOWN : XKB_KEY_UP);
kitty kbd: update handling of locked modifiers The kitty keyboard specification has been updated/clarified yet again. Locked modifiers are to be ignored if the key event would result in plain text without the locked modifier being enabled. In short, locked modifiers are included in the set of modifiers reported in a key event. But having a locked modifier enabled doesn't turn all key events into CSIu sequences. For example, with only the disambiguate mode enabled, pressing 'a', or 'shift+a' results in a/A regardless of the state of Caps- or NumLock. But 'ctrl+a', which always results in a CSIu, will have a different modifier list, depending on whether Caps- or NumLock are enabled.
2024-03-02 08:16:17 +01:00
get_current_modifiers(seat, &mods, NULL, 0, false);
locked = xkb_state_serialize_mods(
seat->kbd.xkb_state, XKB_STATE_MODS_LOCKED);
input: kitty: update to latest version of the spec Starting with kitty 0.32.0, the modifier bits during modifier key events behave differently, compared to before. Or, rather, they have now been spec:ed; before, behavior was different on e.g. MacOS, and Linux. The new behavior is this: On key press, the modifier bits in the kitty key event *includes* the pressed modifier key. On key release, the modifier bits in the kitty key event does *not* include the released modifier key. In other words, The modifier bits reflects the state *after* the key event. This is the exact opposite of what foot did before this patch. The patch is really pretty small: in order to include the key in the modifier set, we simulate a key press to update the XKB state, using xkb_state_uppate_key(). For key pressed, we simulate an XKB_KEY_DOWN event, and for key releases we simulate an XKB_KEY_UP event. Then we re-retrieve the modifers, both the full set, and the consumed set. Closes #1561
2024-01-22 16:39:26 +01:00
consumed = xkb_state_key_get_consumed_mods2(
kitty kbd: switch from GTK to XKB mode for 'consumed' modifiers This fixes an issue where some key combinations resulted in different output (e.g. escape code vs. plain text) depending on the state of e.g. the NumLock key. One such example is Shift+space. Another example is Shift+BackSpace. This patch also removes the hardcoded CapsLock filter, when determining whether a key combo produces text or not, and instead uses the locked modifiers as reported by XKB.
2024-02-29 09:32:38 +01:00
seat->kbd.xkb_state, ctx->key, XKB_CONSUMED_MODE_XKB);
input: kitty: update to latest version of the spec Starting with kitty 0.32.0, the modifier bits during modifier key events behave differently, compared to before. Or, rather, they have now been spec:ed; before, behavior was different on e.g. MacOS, and Linux. The new behavior is this: On key press, the modifier bits in the kitty key event *includes* the pressed modifier key. On key release, the modifier bits in the kitty key event does *not* include the released modifier key. In other words, The modifier bits reflects the state *after* the key event. This is the exact opposite of what foot did before this patch. The patch is really pretty small: in order to include the key in the modifier set, we simulate a key press to update the XKB state, using xkb_state_uppate_key(). For key pressed, we simulate an XKB_KEY_DOWN event, and for key releases we simulate an XKB_KEY_UP event. Then we re-retrieve the modifers, both the full set, and the consumed set. Closes #1561
2024-01-22 16:39:26 +01:00
#if 0
/*
* TODO: according to the XKB docs, state updates should
* always be in pairs: each press should be followed by a
* release. However, doing this just breaks the xkb state.
*
* *Not* pairing the above press/release with a corresponding
* release/press appears to do exactly what we want.
*/
xkb_state_update_key(
seat->kbd.xkb_state, ctx->key, pressed ? XKB_KEY_UP : XKB_KEY_DOWN);
#endif
} else {
kitty kbd: update handling of locked modifiers The kitty keyboard specification has been updated/clarified yet again. Locked modifiers are to be ignored if the key event would result in plain text without the locked modifier being enabled. In short, locked modifiers are included in the set of modifiers reported in a key event. But having a locked modifier enabled doesn't turn all key events into CSIu sequences. For example, with only the disambiguate mode enabled, pressing 'a', or 'shift+a' results in a/A regardless of the state of Caps- or NumLock. But 'ctrl+a', which always results in a CSIu, will have a different modifier list, depending on whether Caps- or NumLock are enabled.
2024-03-02 08:16:17 +01:00
/* Same as ctx->mods, but *without* filtering locked modifiers */
get_current_modifiers(seat, &mods, NULL, 0, false);
locked = xkb_state_serialize_mods(
seat->kbd.xkb_state, XKB_STATE_MODS_LOCKED);
input: kitty: update to latest version of the spec Starting with kitty 0.32.0, the modifier bits during modifier key events behave differently, compared to before. Or, rather, they have now been spec:ed; before, behavior was different on e.g. MacOS, and Linux. The new behavior is this: On key press, the modifier bits in the kitty key event *includes* the pressed modifier key. On key release, the modifier bits in the kitty key event does *not* include the released modifier key. In other words, The modifier bits reflects the state *after* the key event. This is the exact opposite of what foot did before this patch. The patch is really pretty small: in order to include the key in the modifier set, we simulate a key press to update the XKB state, using xkb_state_uppate_key(). For key pressed, we simulate an XKB_KEY_DOWN event, and for key releases we simulate an XKB_KEY_UP event. Then we re-retrieve the modifers, both the full set, and the consumed set. Closes #1561
2024-01-22 16:39:26 +01:00
}
mods &= seat->kbd.kitty_significant;
consumed &= seat->kbd.kitty_significant;
kitty kbd: update handling of locked modifiers The kitty keyboard specification has been updated/clarified yet again. Locked modifiers are to be ignored if the key event would result in plain text without the locked modifier being enabled. In short, locked modifiers are included in the set of modifiers reported in a key event. But having a locked modifier enabled doesn't turn all key events into CSIu sequences. For example, with only the disambiguate mode enabled, pressing 'a', or 'shift+a' results in a/A regardless of the state of Caps- or NumLock. But 'ctrl+a', which always results in a CSIu, will have a different modifier list, depending on whether Caps- or NumLock are enabled.
2024-03-02 08:16:17 +01:00
/*
* A note on locked modifiers; they *are* a part of the protocol,
* and *should* be included in the modifier set reported in the
* key event.
*
* However, *only* if the key would result in a CSIu *without* the
* locked modifier being enabled
*
* Translated: if *another* modifier is active, or if
* report-all-keys-as-escapes is enabled, then we include the
* locked modifier in the key event.
*
* But, if the key event would result in plain text output without
* the locked modifier, then we "ignore" the locked modifier and
* emit plain text anyway.
*/
bool is_text = count > 0 && utf32 != NULL && (mods & ~locked & ~consumed) == 0;
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
for (size_t i = 0; utf32[i] != U'\0'; i++) {
input: kitty: only set 'alternate' if the "unshifted" code is printable Fixes a regression where alt+backspace was reported as ^[[8:127;3u instead of ^[[127;3u.
2025-01-22 10:26:44 +01:00
if (!isc32print(utf32[i])) {
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
is_text = false;
break;
}
}
kitty: composed characters with “report associated text” The generic input handler now converts the composed character to it’s UTF-32 equivalent. This means we now provide a valid UTF-32 codepoint for both composed characters, and non-composed (plain-text) characters. Use this in the kitty protocol to simplify the logic around composed characters, by simply treating them as plain text.
2021-12-07 07:31:34 +01:00
const bool report_associated_text =
(flags & KITTY_KBD_REPORT_ASSOCIATED) && is_text && !released;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
if (composing) {
/* We never emit anything while composing, *except* modifiers
* (and only in report-all-keys-as-escape-codes mode) */
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
if (info != NULL && info->is_modifier)
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
goto emit_escapes;
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
return false;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
}
if (report_all_as_escapes)
goto emit_escapes;
kitty kbd: update handling of locked modifiers The kitty keyboard specification has been updated/clarified yet again. Locked modifiers are to be ignored if the key event would result in plain text without the locked modifier being enabled. In short, locked modifiers are included in the set of modifiers reported in a key event. But having a locked modifier enabled doesn't turn all key events into CSIu sequences. For example, with only the disambiguate mode enabled, pressing 'a', or 'shift+a' results in a/A regardless of the state of Caps- or NumLock. But 'ctrl+a', which always results in a CSIu, will have a different modifier list, depending on whether Caps- or NumLock are enabled.
2024-03-02 08:16:17 +01:00
if ((mods & ~locked & ~consumed) == 0) {
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
switch (sym) {
kitty kbd: don't generate release events for plain Enter+Tab+Backspace From the specification: The Enter, Tab and Backspace keys will not have release events unless Report all keys as escape codes is also set, so that the user can still type reset at a shell prompt when a program that sets this mode ends without resetting it. Closes #1892
2025-01-01 08:06:52 +01:00
case XKB_KEY_Return:
if (!released)
term_to_slave(term, "\r", 1);
return true;
case XKB_KEY_BackSpace:
if (!released)
term_to_slave(term, "\x7f", 1);
return true;
case XKB_KEY_Tab:
if (!released)
term_to_slave(term, "\t", 1);
return true;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
}
input: kitty: printables are emitted as text, even if Caps- or Num-Lock is in effect Not sure if this is the best/correct way to do it. But kitty seems to ignore at least Num-Lock for printables, while it _does_ affect other keys. For example, Return, which usually emits ‘\r’, are affected by Num-Lock and emit ‘CSI 13;129u’. Note that as soon as some other modifier is in effect, the Num-Lock modifier *is* encoded in the CSI, also for printables.
2021-11-21 11:38:36 +01:00
}
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
input: kitty: merge handling of plain-text and composed characters All plain-text and composed characters are now printed as-is, in a single place. Also fix handling of “generic” keys when emitted as escapes; don’t use the raw XKB symbol as key in the escape, convert it to a unicode code point first. For many symbols, these are the same. But not all. For now, we fallback to using the symbol as is if XKB fails to convert it to a codepoint. Not sure if we should simply drop the key press instead. Composed characters also need special treatment; we can’t use the symbol as is, since it typically refers to the last key pressed (i.e. not the composed character). And, that key is also (usually) a special “dead” key, which cannot be converted to a unicode codepoint. So, what we do is convert the generated utf8 string, and (try to) convert it to a wchar. If it succeeds, use that. If not, fallback to using the XKB symbol (as above).
2021-11-29 20:13:23 +01:00
/* Plain-text without modifiers, or commposed text, is emitted as-is */
kitty: only emit plain text on key press- and repeat events That is, release events always generate CSIs
2021-12-07 20:26:12 +01:00
if (is_text && !released) {
input: kitty: printables are emitted as text, even if Caps- or Num-Lock is in effect Not sure if this is the best/correct way to do it. But kitty seems to ignore at least Num-Lock for printables, while it _does_ affect other keys. For example, Return, which usually emits ‘\r’, are affected by Num-Lock and emit ‘CSI 13;129u’. Note that as soon as some other modifier is in effect, the Num-Lock modifier *is* encoded in the CSI, also for printables.
2021-11-21 11:38:36 +01:00
term_to_slave(term, utf8, count);
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
return true;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
}
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
emit_escapes:
;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
unsigned int encoded_mods = 0;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_shift != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_shift) ? (1 << 0) : 0;
if (seat->kbd.mod_alt != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_alt) ? (1 << 1) : 0;
if (seat->kbd.mod_ctrl != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_ctrl) ? (1 << 2) : 0;
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
if (seat->kbd.mod_super != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_super) ? (1 << 3) : 0;
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
if (seat->kbd.mod_caps != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_caps) ? (1 << 6) : 0;
if (seat->kbd.mod_num != XKB_MOD_INVALID)
encoded_mods |= mods & (1 << seat->kbd.mod_num) ? (1 << 7) : 0;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
encoded_mods++;
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
/*
* Figure out the main, alternate and base key codes.
*
* The main key is the unshifted version of the generated symbol,
* the alternate key is the shifted version, and base is the
* (unshifted) key assuming the default layout.
*
* For example, the user presses shift+a, then:
* - unshifted = 'a'
* - shifted = 'A'
* - base = 'a'
*
* Base will in many cases be the same as the unshifted key, but
* may differ if the active keyboard layout is non-ASCII (examples
* would be russian, or alternative layouts like neo etc).
*
* The shifted key is what we get from XKB, i.e. the resulting key
* from all active modifiers, plus the pressed key.
*/
int unshifted = -1, shifted = -1, base = -1;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
char final;
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
if (info != NULL) {
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
/* Use code from lookup table (cursor keys, enter, tab etc)*/
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
if (!info->is_modifier || report_all_as_escapes) {
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
shifted = info->key;
kitty: replace switch with a static keysym table
2021-12-11 14:51:56 +01:00
final = info->final;
}
} else {
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
/* Use keysym (typically its Unicode codepoint value) */
input: kitty: add shift/alt/ctrl/super/hyper/meta keys
2021-11-21 12:40:04 +01:00
input: kitty: always treat composed characters as ‘printable’ Certain dead key combinations results different escape sequences in foot, compared to kitty, when the kitty keyboard protocol is used. if (composed && is_text) key = utf32; else { key = xkb_keysym_to_utf32(sym_to_use); if (key == 0) return false; /* The *shifted* key. May be the same as the unshifted * key - if so, this is filtered out below, when * emitting the CSI */ alternate = xkb_keysym_to_utf32(sym); } If is_text=false, we’ll fall through to the non-composed logic. is_text is set to true if the character is printable *and* there aren’t any non-consumed modifiers enabled. shift+space is one example where shift is *not* consumed (typically - may be layouts where it is). As a result, pressing ", followed by shift+space with the international english keyboard layout (where " is a dead key) results in different sequences in foot and kitty. This patch fixes this by always treating composed characters as printable. Closes #1120
2022-07-26 18:44:29 +02:00
if (composed)
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
shifted = utf32[0]; /* TODO: what if there are multiple codepoints? */
else
shifted = xkb_keysym_to_utf32(sym);
kitty: report-alternate: apply base-layout key to composed characters
2021-12-07 21:48:42 +01:00
input: kitty: merge handling of plain-text and composed characters All plain-text and composed characters are now printed as-is, in a single place. Also fix handling of “generic” keys when emitted as escapes; don’t use the raw XKB symbol as key in the escape, convert it to a unicode code point first. For many symbols, these are the same. But not all. For now, we fallback to using the symbol as is if XKB fails to convert it to a codepoint. Not sure if we should simply drop the key press instead. Composed characters also need special treatment; we can’t use the symbol as is, since it typically refers to the last key pressed (i.e. not the composed character). And, that key is also (usually) a special “dead” key, which cannot be converted to a unicode codepoint. So, what we do is convert the generated utf8 string, and (try to) convert it to a wchar. If it succeeds, use that. If not, fallback to using the XKB symbol (as above).
2021-11-29 20:13:23 +01:00
final = 'u';
}
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
if (shifted <= 0)
input: kitty: don’t fallback to the XKB symbol When handling “generic” keys (i.e. keys not in the Kitty keymap), we use the pressed key’s Unicode codepoint as “key” in the kitty CSI. If we failed to convert the XKB symbol to a Unicode codepoint, we used to (before this patch), fallback to using the XKB symbol as is. This can never be correct... and it caused us to emit a meaningless CSI for XKB_KEY_ISO_Next_Group, which confused e.g. Kakoune.
2021-12-16 12:37:58 +01:00
return false;
input: kitty: improve handling of alternate+base keys even more * Always do a base key lookup. Before this, we didn't do that if we matched the XKB sym to a lookup table entry (i.e. keypads, cursor keys etc.) * Try to retrieve the unshifted symbol also when we matched the symbol to a lookup table entry. When successful, we now report an alternate key for keypad and cursor keys; before this patch, we only did that for keys that didn't have an entry in the lookup table (i.e. ASCII chars etc). This improves compatibility with kitty (and the kitty keyboard protocol) in more corner cases. One particular example is the neo keyboard layout, where part of the regular keys act as keypad keys when num-lock is active.
2025-01-20 10:34:45 +01:00
/* Base layout key. I.e the symbol the pressed key produces in
* the base/default layout (layout idx 0) */
const xkb_keysym_t *base_syms;
int base_sym_count = xkb_keymap_key_get_syms_by_level(
seat->kbd.xkb_keymap, ctx->key, 0, 0, &base_syms);
if (base_sym_count > 0)
base = xkb_keysym_to_utf32(base_syms[0]);
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
/*
* If the keysym is shifted, use its unshifted codepoint
* instead. In other words, ctrl+a and ctrl+shift+a should both
* use the same value for 'key' (97 - i.a. 'a').
*
* However, don't do this if a non-significant modifier was used
* to generate the symbol. This is needed since we cannot encode
* non-significant modifiers, and thus the "extra" modifier(s)
* would get lost.
*
* Example:
*
* the Swedish layout has '2', QUOTATION MARK ("double quote"),
* '@', and '²' on the same key. '2' is the base symbol.
*
* Shift+2 results in QUOTATION MARK
* AltGr+2 results in '@'
* AltGr+Shift+2 results in '²'
*
* The kitty kbd protocol can't encode AltGr. So, if we always
* used the base symbol ('2'), Alt+Shift+2 would result in the
* same escape sequence as AltGr+Alt+Shift+2.
*
* (yes, this matches what kitty does, as of 0.23.1)
*/
const bool use_level0_sym =
(ctx->mods & ~seat->kbd.kitty_significant) == 0 && ctx->level0_syms.count > 0;
unshifted = use_level0_sym ? xkb_keysym_to_utf32(ctx->level0_syms.syms[0]) : 0;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
xassert(encoded_mods >= 1);
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
char event[4];
kitty: when emitting associated text, don’t report mods/events unless necessary
2021-12-07 21:52:43 +01:00
if (report_events /*&& !pressed*/) {
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
/* Note: this deviates slightly from Kitty, which omits the
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* ":1" subparameter for key press events */
input: kitty: add support for the “report event” mode (0b10)
2021-11-28 18:45:28 +01:00
event[0] = ':';
event[1] = '0' + (pressed ? 1 : repeating ? 2 : 3);
event[2] = '\0';
} else
event[0] = '\0';
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
char buf[128], *p = buf;
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
size_t left = sizeof(buf);
size_t bytes;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
input: kitty: always use shifted key when it's the result of a compose Closes #1987
2025-03-10 15:47:20 +01:00
const int key = unshifted > 0 && isc32print(unshifted) && !composed ? unshifted : shifted;
input: kitty: refactor, try to simplify and be less confusing Use better named variables while juggling the shifted vs. unshifted key codes. Switch to variable names appropriate for the kitty keyboard protocol once we have all the unshifted, shifted and base key codes done. It's not until then we can decide which key code to use as the main key, and whether or not to report the alternate key code.
2025-01-22 12:37:36 +01:00
const int alternate = shifted;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
if (final == 'u' || final == '~') {
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
bytes = snprintf(p, left, "\x1b[%u", key);
p += bytes; left -= bytes;
kitty: implement “base layout key” in “report alternate key”
2021-12-07 20:25:14 +01:00
if (report_alternate) {
bool emit_alternate = alternate > 0 && alternate != key;
input: kitty: only set 'alternate' if the "unshifted" code is printable Fixes a regression where alt+backspace was reported as ^[[8:127;3u instead of ^[[127;3u.
2025-01-22 10:26:44 +01:00
bool emit_base = base > 0 && base != key && base != alternate && isc32print(base);
kitty: implement “base layout key” in “report alternate key”
2021-12-07 20:25:14 +01:00
if (emit_alternate) {
bytes = snprintf(p, left, ":%u", alternate);
p += bytes; left -= bytes;
}
if (emit_base) {
bytes = snprintf(
p, left, "%s:%u", !emit_alternate ? ":" : "", base);
p += bytes; left -= bytes;
}
kitty: initial support for “report alternate key” In this mode, the “shifted” and “base layout” keys are added to the CSIs, as sub-parameters to the “key” parameter. Note that this PR only implements the “shifted” key, not the “base layout key”. This is done by converting the original XKB symbol to it’s corresponding UTF-32 codepoint. If this codepoint is different from the one we use as “key” in the CSI, we add it as a sub-parameter. Related to #319
2021-12-07 19:55:52 +01:00
}
kitty: when emitting associated text, don’t report mods/events unless necessary
2021-12-07 21:52:43 +01:00
bool emit_mods = encoded_mods > 1 || event[0] != '\0';
if (emit_mods) {
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
bytes = snprintf(p, left, ";%u%s", encoded_mods, event);
p += bytes; left -= bytes;
kitty: when emitting associated text, don’t report mods/events unless necessary
2021-12-07 21:52:43 +01:00
}
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
kitty: when emitting associated text, don’t report mods/events unless necessary
2021-12-07 21:52:43 +01:00
if (report_associated_text) {
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
bytes = snprintf(p, left, "%s;%u", !emit_mods ? ";" : "", utf32[0]);
kitty: when emitting associated text, don’t report mods/events unless necessary
2021-12-07 21:52:43 +01:00
p += bytes; left -= bytes;
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
/* Additional text codepoints */
if (utf32[0] != U'\0') {
for (size_t i = 1; utf32[i] != U'\0'; i++) {
bytes = snprintf(p, left, ":%u", utf32[i]);
p += bytes; left -= bytes;
}
}
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
}
bytes = snprintf(p, left, "%c", final);
p += bytes; left -= bytes;
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
} else {
kitty: implement “report associated text” In this mode, key events that generate text now add a third CSI parameter, indicating the actual codepoint. Remember that we always use the *unshifted* key in the CSI escapes. With this mode, those CSI escapes now also included the text codepoint. I.e. what would have been emitted, had we not generated a CSI escape. As far as I can tell, this mode has no effect unless “report all keys as escape sequences” is enabled (reason being, without that, there aren’t any text events that generate CSIs - they’re always emitted as-is). Note that Kitty itself seems to be somewhat buggy in this mode. At least on Wayland, with my Swedish layout. For example ‘a’ and ‘A’ does generate the expected CSIs, but ‘å’ and ‘Å’ appears to be treated as non-text input. Furthermore, Kitty optimizes away the modifier parameter, if no modifiers are pressed (e.g. CSI 97;;97u), while we always emit the modifier (CSI 97;1;97u). Related to #319
2021-12-06 23:01:41 +01:00
if (encoded_mods > 1 || event[0] != '\0') {
bytes = snprintf(p, left, "\x1b[1;%u%s%c", encoded_mods, event, final);
p += bytes; left -= bytes;
} else {
bytes = snprintf(p, left, "\x1b[%c", final);
p += bytes; left -= bytes;
}
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
}
input: kitty: return the result of term_to_slave() If term_to_slave() fails, then the key wasn’t ‘handled’...
2021-12-12 15:08:46 +01:00
return term_to_slave(term, buf, sizeof(buf) - left);
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
}
input: copy libxkbcommon’s keysym_is_modifier() When determining whether a keysym is a modifier (to skip hiding the pointer when [mouse].hide-when-typing=yes), use the same matching logic xkbcommon does. This function, xkb_keysym_is_modifier() is unfortunately not part of the public API, which is why we copy it instead.
2022-04-20 18:23:20 +02:00
/* Copied from libxkbcommon (internal function) */
static bool
keysym_is_modifier(xkb_keysym_t keysym)
{
return
(keysym >= XKB_KEY_Shift_L && keysym <= XKB_KEY_Hyper_R) ||
input: codespell
2022-04-20 19:03:48 +02:00
/* libX11 only goes up to XKB_KEY_ISO_Level5_Lock. */
input: copy libxkbcommon’s keysym_is_modifier() When determining whether a keysym is a modifier (to skip hiding the pointer when [mouse].hide-when-typing=yes), use the same matching logic xkbcommon does. This function, xkb_keysym_is_modifier() is unfortunately not part of the public API, which is why we copy it instead.
2022-04-20 18:23:20 +02:00
(keysym >= XKB_KEY_ISO_Lock && keysym <= XKB_KEY_ISO_Last_Group_Lock) ||
keysym == XKB_KEY_Mode_switch ||
keysym == XKB_KEY_Num_Lock;
}
input: improved debug logging of key press/release * Log which it is: press or release * Include locked modifiers * Include human-readable names of the modifiers
2024-02-20 16:18:55 +01:00
#if defined(_DEBUG)
static void
modifier_string(xkb_mod_mask_t mods, size_t sz, char mod_str[static sz], const struct seat *seat)
{
if (sz == 0)
return;
mod_str[0] = '\0';
for (size_t i = 0; i < sizeof(xkb_mod_mask_t) * 8; i++) {
if (!(mods & (1u << i)))
continue;
strcat(mod_str, xkb_keymap_mod_get_name(seat->kbd.xkb_keymap, i));
strcat(mod_str, "+");
}
if (mod_str[0] != '\0') {
/* Strip the last '+' */
mod_str[strlen(mod_str) - 1] = '\0';
}
if (mod_str[0] == '\0') {
strcpy(mod_str, "<none>");
}
}
#endif
wip: initial input handling
2019-06-19 10:04:47 +02:00
static void
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
key_press_release(struct seat *seat, struct terminal *term, uint32_t serial,
uint32_t key, uint32_t state)
wip: initial input handling
2019-06-19 10:04:47 +02:00
{
input: assert serial received from compositor is non-zero
2022-04-23 15:54:37 +02:00
xassert(serial != 0);
input: update serial on each key press/release and mouse button The serial is used when copying/pasting data from the clipboard. Up until now, we’ve used the serial from the keyboard/mouse enter events. This works in most cases, but breaks in the following example: $ wl-copy WLCOPY /* Ctrl+Shift+v works fine (pastes "WLCOPY") */ $ printf "\033]52;c;eHl6\a" /* Ctrl+Shift+v pastes "WLCOPY" instead of "xyz" */ Shifting focus away and then back to the foot window, and re-executing the printf works, suggesting the “enter” serial is no longer valid after another process(?) has copied something to the clipboard. Updating the serial on key press/release (and the corresponding mouse serial on mouse button events) seems to fix this. I’ve also tested that “normal” copy/paste operations, within the same foot instance, and between foot and other applications, are still working. In at least river (wlroots based), and GNOME/mutter. Closes #753
2021-10-20 18:47:36 +02:00
seat->kbd.serial = serial;
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
if (seat->kbd.xkb == NULL ||
seat->kbd.xkb_keymap == NULL ||
seat->kbd.xkb_state == NULL)
{
input: keyboard: detect failure to mmap keymap
2020-07-14 08:52:11 +02:00
return;
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
}
input: keyboard: detect failure to mmap keymap
2020-07-14 08:52:11 +02:00
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
const bool pressed = state == WL_KEYBOARD_KEY_STATE_PRESSED;
//const bool repeated = pressed && seat->kbd.repeat.dont_re_repeat;
const bool released = state == WL_KEYBOARD_KEY_STATE_RELEASED;
if (released)
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
stop_repeater(seat, key);
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
bool should_repeat =
pressed && xkb_keymap_key_repeats(seat->kbd.xkb_keymap, key);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
xkb_keysym_t sym = xkb_state_key_get_one_sym(seat->kbd.xkb_state, key);
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: copy libxkbcommon’s keysym_is_modifier() When determining whether a keysym is a modifier (to skip hiding the pointer when [mouse].hide-when-typing=yes), use the same matching logic xkbcommon does. This function, xkb_keysym_is_modifier() is unfortunately not part of the public API, which is why we copy it instead.
2022-04-20 18:23:20 +02:00
if (pressed && term->conf->mouse.hide_when_typing && !keysym_is_modifier(sym)) {
input: don't hide cursor if key is 'shift' Since shift is used to enable selecting text in mouse-grabbing applications, hiding the cursor in this case is counter productive.
2020-08-01 15:39:25 +02:00
seat->pointer.hidden = true;
term_xcursor_update_for_seat(term, seat);
}
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
enum xkb_compose_status compose_status = XKB_COMPOSE_NOTHING;
if (seat->kbd.xkb_compose_state != NULL) {
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
if (pressed)
xkb_compose_state_feed(seat->kbd.xkb_compose_state, sym);
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
compose_status = xkb_compose_state_get_status(
seat->kbd.xkb_compose_state);
}
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
const bool composed = compose_status == XKB_COMPOSE_COMPOSED;
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
input: filter out non-significant modifiers when matching mouse bindings Closes #736
2021-10-06 20:12:17 +02:00
xkb_mod_mask_t mods, consumed;
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
get_current_modifiers(seat, &mods, &consumed, key, true);
input: get_current_modifiers() no longer strips insignificant mods Our internal binding handling cares about a different set of modifiers, compared to the kitty keyboard protocol. To handle this, get_current_modifiers() has been modified, to no longer strip the “unsignificant” modifiers. This is now up to the caller to do. To help, we keep two masks (for significant modifiers) in the seat struct; one for our internal binding handling (and the legacy keyboard protocol), and one for the kitty keyboard protocol. These two masks are updated when the seat’s keymap is updated/changed.
2021-11-21 11:27:31 +01:00
input: rewrite of how we match foot’s own key bindings Bindings are matched in one out of three ways: * By translated (by XKB) symbols * By untranslated symbols * By raw key codes A translated symbol is affected by pressed modifiers, some of which can be “consumed”. Consumed modifiers to not partake in the comparison with the binding’s modifiers. In this mode, ctrl+shift+2 maps to ctrl+@ on a US layout. Untranslated symbols, or un-shifted symbols refer to the “base” symbol of the pressed key, i.e. it’s unaffected by modifiers. In this mode, consumed modifiers *do* partake in the comparison with the binding’s modifiers, and ctrl+shift+2 maps to ctrl+shift+2 on a US layout. More examples: ctrl+shift+u maps to ctrl+U in the translated lookup, while ctrl+shift+u maps to ctrl+shift+u in the untranslated lookup. Finally, we also match raw key codes. This allows our bindings to work using the same physical keys when the user switches between latin and non-latin layouts. This means key bindings in foot.ini *must* not include both +shift+ and a *shifted* key. I.e. ctrl+shift+U is not a valid combo as it cannot be triggered. Unfortunately, this was how you were supposed to write bindings up until now... so, we try to detect such bindings, log a deprecation warning and then “fix” the binding for the user. When specifying bindings in foot.ini, both ctrl+U and ctrl+shift+u are valid, and will work. The latter is preferred though, since we cannot detect the raw key code for the former variant. Personally, I also prefer the latter one because it is more explicit; it’s more obvious which keys are involved. However, in some cases it makes more sense to use the other variant. Typically for non-letter combos.
2021-02-27 20:42:31 +01:00
xkb_layout_index_t layout_idx =
xkb_state_key_get_layout(seat->kbd.xkb_state, key);
const xkb_keysym_t *raw_syms = NULL;
size_t raw_count = xkb_keymap_key_get_syms_by_level(
seat->kbd.xkb_keymap, key, layout_idx, 0, &raw_syms);
key-binding: new API, for handling sets of key bindings Up until now, our Wayland seats have been tracking key bindings. This makes sense, since the seat’s keymap determines how the key bindings are resolved. However, tying bindings to the seat/keymap alone isn’t enough, since we also depend on the current configuration (i.e. user settings) when resolving a key binding. This means configurations that doesn’t match the wayland object’s configuration, currently don’t resolve key bindings correctly. This applies to footclients where the user has overridden key bindings on the command line (e.g. --override key-bindings.foo=bar). Thus, to correctly resolve key bindings, each set of key bindings must be tied *both* to a seat/keymap, *and* a configuration. This patch introduces a key-binding manager, with an API to add/remove/lookup, and load/unload keymaps from sets of key bindings. In the API, sets are tied to a seat and terminal instance, since this makes the most sense (we need to instantiate, or incref a set whenever a new terminal instance is created). Internally, the set is tied to a seat and the terminal’s configuration. Sets are *added* when a new seat is added, and when a new terminal instance is created. Since there can only be one instance of each seat, sets are always removed when a seat is removed. Terminals on the other hand can re-use the same configuration (and typically do). Thus, sets ref-count the configuration. In other words, when instantiating a new terminal, we may not have to instantiate a new set of key bindings, but can often be incref:ed instead. Whenever the keymap changes on a seat, all key bindings sets associated with that seat reloads (re-resolves) their key bindings. Closes #931
2022-04-17 15:39:51 +02:00
const struct key_binding_set *bindings = key_binding_for(
terminal: don’t unref a not-yet-referenced key-binding set Key-binding sets are bound to a seat/configuration pair. The conf reference is done when a new terminal instance is created. When that same terminal instance is destroyed, the key binding set is unref:ed. If the terminal instance is destroyed *before* the key binding set has been referenced, we’ll still unref it. This creates an imbalance. In particular, when the there is exactly one other terminal instance referencing that same key binding set, that terminal instance will trigger a foot server crash as soon as it receives a key press/release event. This happens because the next-to-last terminal instance brought the reference count of the binding set down to 0, causing it to be free:d. Thus, we *must* reference the binding set *before* we can error out (when instantiating a new terminal instance). At this point, we don’t yet have a valid terminal instance. But, that’s ok, because all the key_binding_new_for_term() did with the terminal instance was get the "struct wayland" and "struct config" pointers. So, rename the function and simply pass these pointers explicitly. Similarly, change key_binding_for() to take a "struct config" pointer, rather than a "struct terminal" pointer. Also rename key_binding_unref_term() -> key_binding_unref().
2022-09-05 19:23:40 +02:00
seat->wayl->key_binding_manager, term->conf, seat);
key-binding: new API, for handling sets of key bindings Up until now, our Wayland seats have been tracking key bindings. This makes sense, since the seat’s keymap determines how the key bindings are resolved. However, tying bindings to the seat/keymap alone isn’t enough, since we also depend on the current configuration (i.e. user settings) when resolving a key binding. This means configurations that doesn’t match the wayland object’s configuration, currently don’t resolve key bindings correctly. This applies to footclients where the user has overridden key bindings on the command line (e.g. --override key-bindings.foo=bar). Thus, to correctly resolve key bindings, each set of key bindings must be tied *both* to a seat/keymap, *and* a configuration. This patch introduces a key-binding manager, with an API to add/remove/lookup, and load/unload keymaps from sets of key bindings. In the API, sets are tied to a seat and terminal instance, since this makes the most sense (we need to instantiate, or incref a set whenever a new terminal instance is created). Internally, the set is tied to a seat and the terminal’s configuration. Sets are *added* when a new seat is added, and when a new terminal instance is created. Since there can only be one instance of each seat, sets are always removed when a seat is removed. Terminals on the other hand can re-use the same configuration (and typically do). Thus, sets ref-count the configuration. In other words, when instantiating a new terminal, we may not have to instantiate a new set of key bindings, but can often be incref:ed instead. Whenever the keymap changes on a seat, all key bindings sets associated with that seat reloads (re-resolves) their key bindings. Closes #931
2022-04-17 15:39:51 +02:00
xassert(bindings != NULL);
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
if (pressed) {
unicode-mode: move state from seat to term This fixes an issue where entering unicode-mode in one foot client, also enabled unicode-mode on other foot clients. Both visually (although glitchy), and in effect. The reason the state was originally in the seat objects, was to fully support multi-seat. That is, one seat/keyboard entering unicode-mode should not affect other seats/keyboards. The issue with this is that seat objects are Wayland global. Thus, in server mode, all seat objects are shared between the foot clients. There is a similarity with IME, which also keeps state in the seat. There's one big difference, however, and that is IME has Wayland native enter/leave events, that the compositor emits when windows are focused/unfocused. These events allow us to reset IME state. For our own Unicode mode, there is nothing similar. This patch moves the Unicode state from seats, to the terminal struct. This does mean that if one seat/keyboard enters Unicode mode, then *all* seats/keyboards will affect the unicode state. This potential downside is outweighed by the fact that different foot clients no longer affect each other. Closes #1717
2024-05-21 07:06:45 +02:00
if (term->unicode_mode.active) {
unicode-input: move input (key press) handling to unicode_mode_input()
2022-07-28 19:34:13 +02:00
unicode_mode_input(seat, term, sym);
input: add new Unicode input mode This mode is activated through the new key-bindings.unicode-input and search-bindings.unicode-input key bindings. When active, the user can “build” a Unicode codepoint by typing its hexadecimal value. Note that there’s no visual feedback in this mode. This is intentional. This mode is intended to be a fallback for users that don’t use an IME. Closes #1116
2022-07-28 18:09:16 +02:00
return;
}
else if (term->is_searching) {
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
if (should_repeat)
start_repeater(seat, key);
search_input(
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
seat, term, bindings, key, sym, mods, consumed,
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
raw_syms, raw_count, serial);
return;
}
else if (urls_mode_is_active(term)) {
if (should_repeat)
start_repeater(seat, key);
urls_input(
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
seat, term, bindings, key, sym, mods, consumed,
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
raw_syms, raw_count, serial);
return;
}
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
}
input: improved debug logging of pressed keys
2020-11-30 20:01:46 +01:00
#if defined(_DEBUG) && defined(LOG_ENABLE_DBG) && LOG_ENABLE_DBG
char sym_name[100];
xkb_keysym_get_name(sym, sym_name, sizeof(sym_name));
input: improved debug logging of key press/release * Log which it is: press or release * Include locked modifiers * Include human-readable names of the modifiers
2024-02-20 16:18:55 +01:00
char active_mods_str[256] = {0};
char consumed_mods_str[256] = {0};
char locked_mods_str[256] = {0};
const xkb_mod_mask_t locked =
xkb_state_serialize_mods(seat->kbd.xkb_state, XKB_STATE_MODS_LOCKED);
modifier_string(mods, sizeof(active_mods_str), active_mods_str, seat);
modifier_string(consumed, sizeof(consumed_mods_str), consumed_mods_str, seat);
modifier_string(locked, sizeof(locked_mods_str), locked_mods_str, seat);
LOG_DBG("%s: %s (%u/0x%x), seat=%s, term=%p, serial=%u, "
"mods=%s (0x%08x), consumed=%s (0x%08x), locked=%s (0x%08x), "
"repeats=%d",
pressed ? "pressed" : "released", sym_name, sym, sym,
seat->name, (void *)term, serial,
active_mods_str, mods, consumed_mods_str, consumed,
locked_mods_str, locked, should_repeat);
input: workaround GNOME messing up pointer leave/enter after moving window GNOME doesn’t send pointer enter after finishing a window move. In subsequent move operations, it is also possible to make it skip sending pointer leave when starting the move operations. This caused foot to assert in debug builds, and add the same button multiple times to the list of buttons currently being pressed.
2021-08-04 17:27:34 +02:00
#endif
input: implement keypad application mode This commit also replaces the previous (temporary) key map with a much more complete one.
2019-07-09 14:27:26 +02:00
input: comments
2020-01-11 18:59:46 +01:00
/*
input: convert the rest of the normal key bindings to configurable bindings New actions defined and implemented: * scrollback up/down * font size up/down/reset * spawn terminal Break out key combo parsing to a new function, parse_key_binding_for_action(). This function parses a string containing one or more space separated key combo definitions on the form (mod1+mod2+...+key), where key is a XKB key name (e.g. KP_Add). Convert all hardcoded key bindings to configuration based bindings. These still cannot actually be configured by the user, but at least lives in the conf struct.
2020-03-08 15:17:29 +01:00
* User configurable bindings
input: comments
2020-01-11 18:59:46 +01:00
*/
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
if (pressed) {
key-bindings: try all bindings in translated mode before matching untranslated, and then finally raw When trying to match key bindings, we do three types of matching: * Match the _translated_ symbol (e.g. Control+C) * Match the _untranslated_ symbol (e.g. Control+Shift+c) * Match raw keyboard codes This was done for *each* key binding. This meant we sometimes matched a keybinding in raw mode, even though there was a translated/untranslated binding that would match it too. All depending on the internal order of the key binding list. This patch changes it, so that we first try all bindings in translated mode, then all bindings in untranslated mode, and finally all bindings in raw mode. Closes #1929
2025-01-27 10:51:03 +01:00
/* Match untranslated symbols */
tll_foreach(bindings->key, it) {
const struct key_binding *bind = &it->item;
input: bind key bindings to raw key codes too Before, when looking for a matching user key binding, we only matched *symbols*. This means that the physical keys that generate a specific key binding is layout dependent. What's worse, it may not even be possible to generate the key binding at all. Russian is one such layout, where all the "normal" (us) symbols are replaced. By using raw key codes, we can get around this - the key code has a direct mapping to the physical key. However, matching raw key codes **only** doesn't always make sense either. For now, match **both** symbols _and_ key codes. Symbols take precedence. TODO: we might have to make this configurable _per binding_. Note: 'search' mode still uses mostly hardcoded shortcuts that still have this problem (i.e. ctrl+g doesn't work with a russian layout).
2020-03-18 14:29:34 +01:00
input: ignore key-bindings without modifiers when matching untranslated/raw When matching the unshifted symbol, or the raw key code, ignore all key bindings that don't have any modifiers. This fixes an issue where it was impossible to enter (some of the) numbers on the keypad, **if** there was a key-binding for e.g. KP_Page_Up, or KP_Page_Down.
2025-01-31 07:35:54 +01:00
if (bind->mods != mods || bind->mods == 0)
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
continue;
for (size_t i = 0; i < raw_count; i++) {
input/search/url: pass pointer-to key-binding struct to execute()
2022-02-08 19:43:00 +01:00
if (bind->k.sym == raw_syms[i] &&
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
execute_binding(seat, term, bind, serial, 1))
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
{
goto maybe_repeat;
}
}
key-bindings: try all bindings in translated mode before matching untranslated, and then finally raw When trying to match key bindings, we do three types of matching: * Match the _translated_ symbol (e.g. Control+C) * Match the _untranslated_ symbol (e.g. Control+Shift+c) * Match raw keyboard codes This was done for *each* key binding. This meant we sometimes matched a keybinding in raw mode, even though there was a translated/untranslated binding that would match it too. All depending on the internal order of the key binding list. This patch changes it, so that we first try all bindings in translated mode, then all bindings in untranslated mode, and finally all bindings in raw mode. Closes #1929
2025-01-27 10:51:03 +01:00
}
input: match unshifted key-bindings before shifted That is, try to match e.g. Control+shift+a, before trying to match Control+A. In most cases, order doesn't matter. There are however a couple of symbols where the layout consumes the shift-modifier, and the generated symbol is the same in both the shifted and unshifted form. One such example is backspace. Before this patch, key-bindings with shift-backspace would be ignored, if there were another key-binding with backspace. So, for example, if we had one key-binding with Control+Backspace, and another with Control+Shift+Backspace, the latter would never trigger, as we would always match the first one. By checking for unshifted matches first, we ensure Control+Shift+Backspace does match.
2025-01-31 09:07:42 +01:00
/* Match translated symbol */
tll_foreach(bindings->key, it) {
const struct key_binding *bind = &it->item;
if (bind->k.sym == sym &&
bind->mods == (mods & ~consumed) &&
execute_binding(seat, term, bind, serial, 1))
{
goto maybe_repeat;
}
}
key-bindings: try all bindings in translated mode before matching untranslated, and then finally raw When trying to match key bindings, we do three types of matching: * Match the _translated_ symbol (e.g. Control+C) * Match the _untranslated_ symbol (e.g. Control+Shift+c) * Match raw keyboard codes This was done for *each* key binding. This meant we sometimes matched a keybinding in raw mode, even though there was a translated/untranslated binding that would match it too. All depending on the internal order of the key binding list. This patch changes it, so that we first try all bindings in translated mode, then all bindings in untranslated mode, and finally all bindings in raw mode. Closes #1929
2025-01-27 10:51:03 +01:00
/* Match raw key code */
tll_foreach(bindings->key, it) {
const struct key_binding *bind = &it->item;
input: ignore key-bindings without modifiers when matching untranslated/raw When matching the unshifted symbol, or the raw key code, ignore all key bindings that don't have any modifiers. This fixes an issue where it was impossible to enter (some of the) numbers on the keypad, **if** there was a key-binding for e.g. KP_Page_Up, or KP_Page_Down.
2025-01-31 07:35:54 +01:00
if (bind->mods != mods || bind->mods == 0)
key-bindings: try all bindings in translated mode before matching untranslated, and then finally raw When trying to match key bindings, we do three types of matching: * Match the _translated_ symbol (e.g. Control+C) * Match the _untranslated_ symbol (e.g. Control+Shift+c) * Match raw keyboard codes This was done for *each* key binding. This meant we sometimes matched a keybinding in raw mode, even though there was a translated/untranslated binding that would match it too. All depending on the internal order of the key binding list. This patch changes it, so that we first try all bindings in translated mode, then all bindings in untranslated mode, and finally all bindings in raw mode. Closes #1929
2025-01-27 10:51:03 +01:00
continue;
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
wayland: unify key- and mouse-binding structs
2022-02-07 19:41:33 +01:00
tll_foreach(bind->k.key_codes, code) {
input/search/url: pass pointer-to key-binding struct to execute()
2022-02-08 19:43:00 +01:00
if (code->item == key &&
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
execute_binding(seat, term, bind, serial, 1))
input: don’t ignore key release events Before this, key release events stopped the repeat timer, and then returned. Now, we run through the entire function. Most things are still only done on key press events. But, the goal here is to get to the keyboard protocol functions (and the kitty protocol in particular), and call them on release events too. This is in preparation for the kitty protocol mode 0b10, report event types.
2021-11-28 16:36:14 +01:00
{
goto maybe_repeat;
}
input: bind key bindings to raw key codes too Before, when looking for a matching user key binding, we only matched *symbols*. This means that the physical keys that generate a specific key binding is layout dependent. What's worse, it may not even be possible to generate the key binding at all. Russian is one such layout, where all the "normal" (us) symbols are replaced. By using raw key codes, we can get around this - the key code has a direct mapping to the physical key. However, matching raw key codes **only** doesn't always make sense either. For now, match **both** symbols _and_ key codes. Symbols take precedence. TODO: we might have to make this configurable _per binding_. Note: 'search' mode still uses mostly hardcoded shortcuts that still have this problem (i.e. ctrl+g doesn't work with a russian layout).
2020-03-18 14:29:34 +01:00
}
}
selection: initial copy-to-clipboard functionality
2019-07-11 12:16:50 +02:00
}
input: comments
2020-01-11 18:59:46 +01:00
/*
* Keys generating escape sequences
*/
/*
* Compose, and maybe emit "normal" character
*/
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
xassert(seat->kbd.xkb_compose_state != NULL || !composed);
input: keyboard_key: don't start repeater unless we generated output I.e. what we're effectively doing is *not* repeating modifier keys. Besides being the "right" thing to do, this also works around another Sway 1.2 bug, where being in a focused foot window and then switching to a vt and back would cause us to be stuck in an endless key repeat loop that would only stop when unfocusing, focusing back and then unfocusing once again.
2019-11-22 22:02:50 +01:00
input: refactor: new function: legacy_kbd_protocol() This breaks out all handling of key escapes to-be-sent to the client, to a separate function, legacy_kbd_protocol(). That is, the key press/release handler first handles key generic handling, such as starting and stopping the repeat timer. Then it checks for foot keyboard bindings. If not bindings match, we need to pass the keyboard event to the client. This code has now been separated out into a new function.
2021-11-17 17:51:41 +01:00
if (compose_status == XKB_COMPOSE_CANCELLED)
goto maybe_repeat;
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
int count = composed
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
? xkb_compose_state_get_utf8(seat->kbd.xkb_compose_state, NULL, 0)
: xkb_state_key_get_utf8(seat->kbd.xkb_state, key, NULL, 0);
input: don’t crash if xkbcommon cannot find a compose file Handle xkb_compose_table_new_from_locale() returning NULL. When this happens, log a warning that “dead keys” will be disabled, and make sure to never de-reference the compose table pointer. Closes #170
2020-10-19 18:30:19 +02:00
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
/* Buffer for translated key. Use a static buffer in most cases,
* and use a malloc:ed buffer when necessary */
uint8_t buf[32];
uint8_t *utf8 = count < sizeof(buf) ? buf : xmalloc(count + 1);
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
uint32_t *utf32 = NULL;
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
if (composed) {
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
xkb_compose_state_get_utf8(
seat->kbd.xkb_compose_state, (char *)utf8, count + 1);
kitty: composed characters with “report associated text” The generic input handler now converts the composed character to it’s UTF-32 equivalent. This means we now provide a valid UTF-32 codepoint for both composed characters, and non-composed (plain-text) characters. Use this in the kitty protocol to simplify the logic around composed characters, by simply treating them as plain text.
2021-12-07 07:31:34 +01:00
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
if (count > 0)
utf32 = ambstoc32((const char *)utf8);
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
} else {
xkb_state_key_get_utf8(
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
seat->kbd.xkb_state, key, (char *)utf8, count + 1);
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
utf32 = xcalloc(2, sizeof(utf32[0]));
utf32[0] = xkb_state_key_get_utf32(seat->kbd.xkb_state, key);
input: wip: add support for kitty kbd protocol “Disambiguate escape codes” Most things appear to work as in kitty. There’s one known difference: tri-state keys don’t generate the same unshifted symbol while holding Shift (but e.g. Ctrl+a and Ctrl+Shift+a *does* generate the same base symbol). For example, the Swedish keyboard layout has double quote, ‘2’ and ‘@’ on the same key. ‘2’ is the base (unshifted) symbol. Double quote is Shift+2. ‘@’ is AltGr+2. Kitty generates the same base symbol for ‘2’ and double quote (the base symbol is, as expected, ‘2’). But, for ‘@’ kitty generates the base symbol ‘@’. Currently, foot generates the base symbol by calling xkb_keysym_to_lower(). I _think_ what we need to do is “consume” the shift modifier, and then re-retrieve the symbol (given the current xkb state and key pressed).
2021-11-20 19:24:00 +01:00
}
input: kitty: use base symbol instead of lowering the symbol When emitting an escape sequence for a printable character, with modifiers (e.g. ctrl+a), use the key’s base symbol instead of “lowering” it. This means we now handle e.g. ctrl+2 and ctrl+shift+2, with Swedish layout. There’s a twist however. We *only* use the base symbol if the modifiers that is used to “generate” the symbol are “significant”. Significant modifiers are, in this context, modifiers we can encode in the kitty escape sequences. In the Swedish layout, pressing AltGr+2 results in ‘@’. AltGr cannot be encoded in the kitty protocol. If we were to use the base symbol, AltGr+Alt+2 would result in exactly the same escape sequence as Alt+2.
2021-11-20 20:31:59 +01:00
struct kbd_ctx ctx = {
.layout = layout_idx,
.key = key,
.sym = sym,
.level0_syms = {
.syms = raw_syms,
.count = raw_count,
},
.mods = mods,
.consumed = consumed,
.utf8 = {
.buf = utf8,
.count = count,
},
.utf32 = utf32,
.compose_status = compose_status,
.key_state = state,
};
input: regression: reset view (and cancel selection) on “handled” input This fixes a regression, where the view (and selection) was only reset if the keyboard input resulted in plain text. That is, key presses like enter, arrows etc did not.
2021-11-29 19:31:48 +01:00
bool handled = term->grid->kitty_kbd.flags[term->grid->kitty_kbd.idx] != 0
? kitty_kbd_protocol(seat, term, &ctx)
: legacy_kbd_protocol(seat, term, &ctx);
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
input: kitty: add support for “report all keys as escape codes”
2021-11-29 21:03:33 +01:00
if (composed && released)
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
xkb_compose_state_reset(seat->kbd.xkb_compose_state);
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
if (utf8 != buf)
free(utf8);
input: don't clear text selection on modifier keypresses When kitty keyboard is enabled, pressing a modifier key will clear the text selection. This makes it difficult to copy text because the selection clears as soon as the user presses "ctrl". Tested-by: Robin Jarry <robin@jarry.cc> Signed-off-by: Tim Culverhouse <tim@timculverhouse.com>
2024-02-22 15:08:13 -06:00
if (handled && !keysym_is_modifier(sym)) {
input: regression: special keys don’t reset view and cancel selection This fixes an issue where e.g. holding down ctrl would cancel the selection, thus making it impossible to copy text to the clipboard.
2021-11-28 16:48:30 +01:00
term_reset_view(term);
selection_cancel(term);
}
input: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
input: (kitty kbd): the resulting UTF-8 string may translate to multiple UTF-32 codepoints When this happened (for example, by specifying a custom compose sequence), the kitty keyboard protocol didn’t emit any text at all. This was caused by the utf32 codepoint being -1. This in turned was caused by us trying to convert the utf8 sequence to a *single* utf32 codepoint. This patch replaces the use of mbrtoc32() with a call to ambstoc32(), and the utf32 codepoint with an utf32 string. The kitty keyboard protocol is updated: * When determining if we’re dealing with text, check *all* codepoints in the utf32 string. * Add support for multiple codepoints when reporting "associated text". The first codepoint is the actual parameter in the emitted sequence, and the remaining codepoints are sub-parameters. I.e. the codepoints are colon separated. Closes #1288
2023-03-27 16:56:10 +02:00
free(utf32);
input: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
maybe_repeat:
presentation: store input timestamp in a per-commit context This should reduce the risk of mixing up an input timestamp with the corresponding rendered frame.
2020-01-21 18:51:04 +01:00
clock_gettime(
term->wl->presentation_clock_id, &term->render.input_time);
input: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
if (should_repeat)
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
start_repeater(seat, key);
}
static void
keyboard_key(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
uint32_t time, uint32_t key, uint32_t state)
{
struct seat *seat = data;
key_press_release(seat, seat->kbd_focus, serial, key + 8, state);
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
static void
keyboard_modifiers(void *data, struct wl_keyboard *wl_keyboard, uint32_t serial,
uint32_t mods_depressed, uint32_t mods_latched,
uint32_t mods_locked, uint32_t group)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: xkb: ignore virtual modifiers Some compositors (mutter/GNOME is one) adds _virtual_ modifiers to the set of active modifiers when e.g. Alt, Meta, Super or Hyper is pressed. For example, pressing Alt+b would result in *both* the Alt *and* the Mod1 modifier being set. Since foot makes close to zero assumptions on how the modifiers should be interpreted, this causes various breakages. For example, a foot shortcut defined as Mod1+b will not match, since the Alt modifiers is also set. This has forced users to redefine/override some of the default key bindings to include the additional modifiers. It also causes issues with the kitty keyboard protocol, for some key combinations. Mainly whether or not to use unshifted key or not, resulting in incorrect escape sequences. Since all the "real" modifiers are always set as well, we can safely ignore the virtual modifiers. Closes #2009
2025-03-29 10:34:40 +01:00
mods_depressed &= ~seat->kbd.virtual_modifiers;
mods_latched &= ~seat->kbd.virtual_modifiers;
mods_locked &= ~seat->kbd.virtual_modifiers;
input: improved debug logging of key press/release * Log which it is: press or release * Include locked modifiers * Include human-readable names of the modifiers
2024-02-20 16:18:55 +01:00
#if defined(_DEBUG)
char depressed[256];
char latched[256];
char locked[256];
modifier_string(mods_depressed, sizeof(depressed), depressed, seat);
modifier_string(mods_latched, sizeof(latched), latched, seat);
modifier_string(mods_locked, sizeof(locked), locked, seat);
LOG_DBG(
"modifiers: depressed=%s (0x%x), latched=%s (0x%x), locked=%s (0x%x), "
"group=%u",
depressed, mods_depressed, latched, mods_latched, locked, mods_locked,
group);
#endif
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
if (seat->kbd.xkb_state != NULL) {
xkb_state_update_mask(
seat->kbd.xkb_state, mods_depressed, mods_latched, mods_locked, 0, 0, group);
/* Update state of modifiers we're interested in for e.g mouse events */
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
seat->kbd.shift = seat->kbd.mod_shift != XKB_MOD_INVALID
? xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_shift, XKB_STATE_MODS_EFFECTIVE)
: false;
seat->kbd.alt = seat->kbd.mod_alt != XKB_MOD_INVALID
? xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_alt, XKB_STATE_MODS_EFFECTIVE)
: false;
seat->kbd.ctrl = seat->kbd.mod_ctrl != XKB_MOD_INVALID
? xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_ctrl, XKB_STATE_MODS_EFFECTIVE)
: false;
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
seat->kbd.super = seat->kbd.mod_super != XKB_MOD_INVALID
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
? xkb_state_mod_index_is_active(
input: rename ‘meta’ to ‘super’
2021-11-21 12:01:16 +01:00
seat->kbd.xkb_state, seat->kbd.mod_super, XKB_STATE_MODS_EFFECTIVE)
input: handle “invalid” XKB modifiers A modifier may not exist in a specific layout. This is indicated by XKB returning XKB_MOD_INVALID from xkb_keymap_mod_get_index().
2021-11-21 11:53:22 +01:00
: false;
input: handle XKB errors * Don’t de-reference the xkb context/keymap/state if we failed to instantiate them. * Don’t try to send a translated utf8 key sequence if the translation failed. * Handle xkb_compose_state_get_utf8() and xkb_state_key_get_utf8() returning more than 64 bytes. This _may_ fix #171.
2020-10-20 21:01:33 +02:00
}
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->kbd_focus && seat->kbd_focus->active_surface == TERM_SURF_GRID)
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
term_xcursor_update_for_seat(seat->kbd_focus, seat);
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
input: kitty: add initial unit test Test a couple of key combos from the se and de(neo) layouts. This unit test isn't intended to test _all_ key combinations, for all kitty flag combinations, but to be more of a regression test - whenever we discover a buggy, weird combo, add it here.
2025-01-21 08:37:30 +01:00
UNITTEST
{
int chan[2];
input: unit test: check pipe2() return value Fixes compilation failures with clang, in release mode.
2025-08-30 08:18:31 +02:00
xassert(pipe2(chan, O_CLOEXEC) == 0);
input: kitty: add initial unit test Test a couple of key combos from the se and de(neo) layouts. This unit test isn't intended to test _all_ key combinations, for all kitty flag combinations, but to be more of a regression test - whenever we discover a buggy, weird combo, add it here.
2025-01-21 08:37:30 +01:00
xassert(chan[0] >= 0);
xassert(chan[1] >= 0);
struct config conf = {0};
struct grid grid = {0};
struct terminal term = {
.conf = &conf,
.grid = &grid,
.ptmx = chan[1],
.selection = {
.coords = {
.start = {-1, -1},
.end = {-1, -1},
},
.auto_scroll = {
.fd = -1,
},
},
};
struct key_binding_manager *key_binding_manager = key_binding_manager_new();
struct wayland wayl = {
.key_binding_manager = key_binding_manager,
.terms = tll_init(),
};
struct seat seat = {
.wayl = &wayl,
.name = "unittest",
};
tll_push_back(wayl.terms, &term);
term.wl = &wayl;
seat.kbd.xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
xassert(seat.kbd.xkb != NULL);
grid.kitty_kbd.flags[0] = KITTY_KBD_DISAMBIGUATE | KITTY_KBD_REPORT_ALTERNATE;
/* Swedish keymap */
{
seat.kbd.xkb_keymap = xkb_keymap_new_from_names(
seat.kbd.xkb, &(struct xkb_rule_names){.layout = "se"}, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (seat.kbd.xkb_keymap == NULL) {
/* Skip test */
goto no_keymap;
}
seat.kbd.xkb_state = xkb_state_new(seat.kbd.xkb_keymap);
xassert(seat.kbd.xkb_state != NULL);
seat.kbd.mod_shift = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_SHIFT);
seat.kbd.mod_alt = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_ALT) ;
seat.kbd.mod_ctrl = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CTRL);
seat.kbd.mod_super = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_LOGO);
seat.kbd.mod_caps = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CAPS);
seat.kbd.mod_num = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_NUM);
/* Significant modifiers in the legacy keyboard protocol */
seat.kbd.legacy_significant = 0;
if (seat.kbd.mod_shift != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_shift;
if (seat.kbd.mod_alt != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_alt;
if (seat.kbd.mod_ctrl != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_ctrl;
if (seat.kbd.mod_super != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_super;
/* Significant modifiers in the kitty keyboard protocol */
seat.kbd.kitty_significant = seat.kbd.legacy_significant;
if (seat.kbd.mod_caps != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_caps;
if (seat.kbd.mod_num != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_num;
key_binding_new_for_seat(key_binding_manager, &seat);
key_binding_load_keymap(key_binding_manager, &seat);
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_shift | 1u << seat.kbd.mod_ctrl;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_A + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key: 97 = 'a', alternate: 65 = 'A', base: N/A, mods: 6 = ctrl+shift */
const char expected_ctrl_shift_a[] = "\033[97:65;6u";
xassert(count == strlen(expected_ctrl_shift_a));
xassert(streq(escape, expected_ctrl_shift_a));
key_press_release(&seat, &term, 1337, KEY_A + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_shift | 1u << seat.kbd.mod_alt;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_2 + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key;. 50 = '2', alternate: 34 = '"', base: N/A, 4 = alt+shift */
const char expected_alt_shift_2[] = "\033[50:34;4u";
xassert(count == strlen(expected_alt_shift_2));
xassert(streq(escape, expected_alt_shift_2));
key_press_release(&seat, &term, 1337, KEY_2 + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
{
xkb_mod_index_t alt_gr = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, "Mod5");
xassert(alt_gr != XKB_MOD_INVALID);
xkb_mod_mask_t mods = 1u << seat.kbd.mod_shift | 1u << seat.kbd.mod_alt | 1u << alt_gr;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_2 + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key; 178 = '²', alternate: N/A, base: 50 = '2', 4 = alt+shift (AltGr not part of the protocol) */
const char expected_altgr_alt_shift_2[] = "\033[178::50;4u";
xassert(count == strlen(expected_altgr_alt_shift_2));
xassert(streq(escape, expected_altgr_alt_shift_2));
key_press_release(&seat, &term, 1337, KEY_2 + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
input: kitty: only set 'alternate' if the "unshifted" code is printable Fixes a regression where alt+backspace was reported as ^[[8:127;3u instead of ^[[127;3u.
2025-01-22 10:26:44 +01:00
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_alt;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_BACKSPACE + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key; 127 = <backspace>, alternate: N/A, base: N/A, 3 = alt */
const char expected_alt_backspace[] = "\033[127;3u";
xassert(count == strlen(expected_alt_backspace));
xassert(streq(escape, expected_alt_backspace));
key_press_release(&seat, &term, 1337, KEY_BACKSPACE + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
input: kitty: add more test cases
2025-01-22 12:24:06 +01:00
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_ctrl;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_ENTER + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key; 13 = <enter>, alternate: N/A, base: N/A, 5 = ctrl */
const char expected_ctrl_enter[] = "\033[13;5u";
xassert(count == strlen(expected_ctrl_enter));
xassert(streq(escape, expected_ctrl_enter));
key_press_release(&seat, &term, 1337, KEY_ENTER + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_ctrl;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_TAB + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key; 9 = <tab>, alternate: N/A, base: N/A, 5 = ctrl */
const char expected_ctrl_tab[] = "\033[9;5u";
xassert(count == strlen(expected_ctrl_tab));
xassert(streq(escape, expected_ctrl_tab));
key_press_release(&seat, &term, 1337, KEY_TAB + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
{
xkb_mod_mask_t mods = 1u << seat.kbd.mod_ctrl | 1u << seat.kbd.mod_shift;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 0);
key_press_release(&seat, &term, 1337, KEY_LEFT + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
const char expected_ctrl_shift_left[] = "\033[1;6D";
xassert(count == strlen(expected_ctrl_shift_left));
xassert(streq(escape, expected_ctrl_shift_left));
key_press_release(&seat, &term, 1337, KEY_LEFT + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
input: kitty: add initial unit test Test a couple of key combos from the se and de(neo) layouts. This unit test isn't intended to test _all_ key combinations, for all kitty flag combinations, but to be more of a regression test - whenever we discover a buggy, weird combo, add it here.
2025-01-21 08:37:30 +01:00
key_binding_unload_keymap(key_binding_manager, &seat);
key_binding_remove_seat(key_binding_manager, &seat);
xkb_state_unref(seat.kbd.xkb_state);
xkb_keymap_unref(seat.kbd.xkb_keymap);
seat.kbd.xkb_state = NULL;
seat.kbd.xkb_keymap = NULL;
}
/* de(neo) keymap */
{
seat.kbd.xkb_keymap = xkb_keymap_new_from_names(
seat.kbd.xkb, &(struct xkb_rule_names){.layout = "us,de(neo)"},
XKB_KEYMAP_COMPILE_NO_FLAGS);
if (seat.kbd.xkb_keymap == NULL) {
/* Skip test */
goto no_keymap;
}
seat.kbd.xkb_state = xkb_state_new(seat.kbd.xkb_keymap);
xassert(seat.kbd.xkb_state != NULL);
seat.kbd.mod_shift = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_SHIFT);
seat.kbd.mod_alt = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_ALT) ;
seat.kbd.mod_ctrl = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CTRL);
seat.kbd.mod_super = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_LOGO);
seat.kbd.mod_caps = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CAPS);
seat.kbd.mod_num = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_NUM);
/* Significant modifiers in the legacy keyboard protocol */
seat.kbd.legacy_significant = 0;
if (seat.kbd.mod_shift != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_shift;
if (seat.kbd.mod_alt != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_alt;
if (seat.kbd.mod_ctrl != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_ctrl;
if (seat.kbd.mod_super != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_super;
/* Significant modifiers in the kitty keyboard protocol */
seat.kbd.kitty_significant = seat.kbd.legacy_significant;
if (seat.kbd.mod_caps != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_caps;
if (seat.kbd.mod_num != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_num;
key_binding_new_for_seat(key_binding_manager, &seat);
key_binding_load_keymap(key_binding_manager, &seat);
{
/*
* In the de(neo) layout, the Y key generates 'k'. This
input: codespell: indiciates -> indicates
2025-01-22 07:51:00 +01:00
* means we should get a key+alternate that indicates 'k',
* but a base key that is 'y'.
input: kitty: add initial unit test Test a couple of key combos from the se and de(neo) layouts. This unit test isn't intended to test _all_ key combinations, for all kitty flag combinations, but to be more of a regression test - whenever we discover a buggy, weird combo, add it here.
2025-01-21 08:37:30 +01:00
*/
xkb_mod_mask_t mods = 1u << seat.kbd.mod_shift | 1u << seat.kbd.mod_alt;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 1);
key_press_release(&seat, &term, 1337, KEY_Y + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key: 107 = 'k', alternate: 75 = 'K', base: 121 = 'y', mods: 4 = alt+shift */
const char expected_alt_shift_y[] = "\033[107:75:121;4u";
xassert(count == strlen(expected_alt_shift_y));
xassert(streq(escape, expected_alt_shift_y));
key_press_release(&seat, &term, 1337, KEY_Y + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
}
key_binding_unload_keymap(key_binding_manager, &seat);
key_binding_remove_seat(key_binding_manager, &seat);
xkb_state_unref(seat.kbd.xkb_state);
xkb_keymap_unref(seat.kbd.xkb_keymap);
seat.kbd.xkb_state = NULL;
seat.kbd.xkb_keymap = NULL;
}
input: kitty: regression test for #1987
2025-03-11 08:23:23 +01:00
/* us(intl) keymap */
{
seat.kbd.xkb_keymap = xkb_keymap_new_from_names(
seat.kbd.xkb, &(struct xkb_rule_names){.layout = "us", .variant = "intl"},
XKB_KEYMAP_COMPILE_NO_FLAGS);
if (seat.kbd.xkb_keymap == NULL) {
/* Skip test */
goto no_keymap;
}
seat.kbd.xkb_state = xkb_state_new(seat.kbd.xkb_keymap);
xassert(seat.kbd.xkb_state != NULL);
seat.kbd.xkb_compose_table = xkb_compose_table_new_from_locale(
seat.kbd.xkb, setlocale(LC_CTYPE, NULL), XKB_COMPOSE_COMPILE_NO_FLAGS);
input: kitty: unittest: don't fail if system has no compose tables
2025-03-11 08:42:03 +01:00
if (seat.kbd.xkb_compose_table == NULL)
goto no_keymap;
input: kitty: regression test for #1987
2025-03-11 08:23:23 +01:00
seat.kbd.xkb_compose_state = xkb_compose_state_new(
seat.kbd.xkb_compose_table, XKB_COMPOSE_STATE_NO_FLAGS);
input: kitty: unittest: don't fail if system has no compose tables
2025-03-11 08:42:03 +01:00
if (seat.kbd.xkb_compose_state == NULL) {
xkb_compose_table_unref(seat.kbd.xkb_compose_table);
goto no_keymap;
}
input: kitty: regression test for #1987
2025-03-11 08:23:23 +01:00
seat.kbd.mod_shift = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_SHIFT);
seat.kbd.mod_alt = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_ALT) ;
seat.kbd.mod_ctrl = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CTRL);
seat.kbd.mod_super = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_LOGO);
seat.kbd.mod_caps = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_CAPS);
seat.kbd.mod_num = xkb_keymap_mod_get_index(seat.kbd.xkb_keymap, XKB_MOD_NAME_NUM);
/* Significant modifiers in the legacy keyboard protocol */
seat.kbd.legacy_significant = 0;
if (seat.kbd.mod_shift != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_shift;
if (seat.kbd.mod_alt != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_alt;
if (seat.kbd.mod_ctrl != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_ctrl;
if (seat.kbd.mod_super != XKB_MOD_INVALID)
seat.kbd.legacy_significant |= 1 << seat.kbd.mod_super;
/* Significant modifiers in the kitty keyboard protocol */
seat.kbd.kitty_significant = seat.kbd.legacy_significant;
if (seat.kbd.mod_caps != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_caps;
if (seat.kbd.mod_num != XKB_MOD_INVALID)
seat.kbd.kitty_significant |= 1 << seat.kbd.mod_num;
key_binding_new_for_seat(key_binding_manager, &seat);
key_binding_load_keymap(key_binding_manager, &seat);
{
/*
* Test the compose sequence "shift+', shift+space"
*
* Should result in a double quote, but a regression
* caused it to instead emit a space. See #1987
*
* Note: "shift+', space" also results in a double quote,
* but never regressed to a space.
*/
grid.kitty_kbd.flags[0] = KITTY_KBD_DISAMBIGUATE;
xkb_compose_state_reset(seat.kbd.xkb_compose_state);
xkb_mod_mask_t mods = 1u << seat.kbd.mod_shift;
keyboard_modifiers(&seat, NULL, 1337, mods, 0, 0, 1);
key_press_release(&seat, &term, 1337, KEY_APOSTROPHE + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
key_press_release(&seat, &term, 1337, KEY_APOSTROPHE + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
key_press_release(&seat, &term, 1337, KEY_SPACE + 8, WL_KEYBOARD_KEY_STATE_PRESSED);
char escape[64] = {0};
ssize_t count = read(chan[0], escape, sizeof(escape));
/* key: 34 = '"', alternate: N/A, base: N/A, mods: 2 = shift */
const char expected_shift_apostrophe[] = "\033[34;2u";
xassert(count == strlen(expected_shift_apostrophe));
xassert(streq(escape, expected_shift_apostrophe));
key_press_release(&seat, &term, 1337, KEY_SPACE + 8, WL_KEYBOARD_KEY_STATE_RELEASED);
grid.kitty_kbd.flags[0] = KITTY_KBD_DISAMBIGUATE | KITTY_KBD_REPORT_ALTERNATE;
}
key_binding_unload_keymap(key_binding_manager, &seat);
key_binding_remove_seat(key_binding_manager, &seat);
xkb_compose_state_unref(seat.kbd.xkb_compose_state);
xkb_compose_table_unref(seat.kbd.xkb_compose_table);
xkb_state_unref(seat.kbd.xkb_state);
xkb_keymap_unref(seat.kbd.xkb_keymap);
seat.kbd.xkb_state = NULL;
seat.kbd.xkb_keymap = NULL;
}
input: kitty: add initial unit test Test a couple of key combos from the se and de(neo) layouts. This unit test isn't intended to test _all_ key combinations, for all kitty flag combinations, but to be more of a regression test - whenever we discover a buggy, weird combo, add it here.
2025-01-21 08:37:30 +01:00
no_keymap:
xkb_context_unref(seat.kbd.xkb);
key_binding_manager_destroy(key_binding_manager);
tll_free(wayl.terms);
close(chan[0]);
close(chan[1]);
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
static void
keyboard_repeat_info(void *data, struct wl_keyboard *wl_keyboard,
int32_t rate, int32_t delay)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
wip: initial input handling
2019-06-19 10:04:47 +02:00
LOG_DBG("keyboard repeat: rate=%d, delay=%d", rate, delay);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->kbd.repeat.rate = rate;
seat->kbd.repeat.delay = delay;
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
const struct wl_keyboard_listener keyboard_listener = {
.keymap = &keyboard_keymap,
.enter = &keyboard_enter,
.leave = &keyboard_leave,
.key = &keyboard_key,
.modifiers = &keyboard_modifiers,
.repeat_info = &keyboard_repeat_info,
};
void
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
input_repeat(struct seat *seat, uint32_t key)
wip: initial input handling
2019-06-19 10:04:47 +02:00
{
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
/* Should be cleared as soon as we loose focus */
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(seat->kbd_focus != NULL);
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
struct terminal *term = seat->kbd_focus;
key_press_release(seat, term, seat->kbd.serial, key, XKB_KEY_DOWN);
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
input: mouse events
2019-07-05 10:44:57 +02:00
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
static bool
is_top_left(const struct terminal *term, int x, int y)
{
config: make CSD user configurable The user can now configure the following: * Whether to prefer CSDs or SSDs. But note that this is only a hint to the compositor - it may deny our request. Furthermore, not all compositors implement the decoration manager protocol, meaning CSDs will be used regardless of the user configuration (GNOME/mutter being the most prominent one). * Title bar size and color, including transparency * Border size and color, including transparency Also drop support for rendering the CSDs inside the main surface.
2020-03-02 18:42:49 +01:00
int csd_border_size = term->conf->csd.border_width;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
return (
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
(!term->window->is_constrained_top && !term->window->is_constrained_left) &&
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
((term->active_surface == TERM_SURF_BORDER_LEFT && y < 10 * term->scale) ||
(term->active_surface == TERM_SURF_BORDER_TOP && x < (10 + csd_border_size) * term->scale)));
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
static bool
is_top_right(const struct terminal *term, int x, int y)
{
config: make CSD user configurable The user can now configure the following: * Whether to prefer CSDs or SSDs. But note that this is only a hint to the compositor - it may deny our request. Furthermore, not all compositors implement the decoration manager protocol, meaning CSDs will be used regardless of the user configuration (GNOME/mutter being the most prominent one). * Title bar size and color, including transparency * Border size and color, including transparency Also drop support for rendering the CSDs inside the main surface.
2020-03-02 18:42:49 +01:00
int csd_border_size = term->conf->csd.border_width;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
return (
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
(!term->window->is_constrained_top && !term->window->is_constrained_right) &&
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
((term->active_surface == TERM_SURF_BORDER_RIGHT && y < 10 * term->scale) ||
(term->active_surface == TERM_SURF_BORDER_TOP && x > term->width + 1 * csd_border_size * term->scale - 10 * term->scale)));
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
static bool
is_bottom_left(const struct terminal *term, int x, int y)
{
config: make CSD user configurable The user can now configure the following: * Whether to prefer CSDs or SSDs. But note that this is only a hint to the compositor - it may deny our request. Furthermore, not all compositors implement the decoration manager protocol, meaning CSDs will be used regardless of the user configuration (GNOME/mutter being the most prominent one). * Title bar size and color, including transparency * Border size and color, including transparency Also drop support for rendering the CSDs inside the main surface.
2020-03-02 18:42:49 +01:00
int csd_title_size = term->conf->csd.title_height;
int csd_border_size = term->conf->csd.border_width;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
return (
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
(!term->window->is_constrained_bottom && !term->window->is_constrained_left) &&
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
((term->active_surface == TERM_SURF_BORDER_LEFT && y > csd_title_size * term->scale + term->height) ||
(term->active_surface == TERM_SURF_BORDER_BOTTOM && x < (10 + csd_border_size) * term->scale)));
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
static bool
is_bottom_right(const struct terminal *term, int x, int y)
{
config: make CSD user configurable The user can now configure the following: * Whether to prefer CSDs or SSDs. But note that this is only a hint to the compositor - it may deny our request. Furthermore, not all compositors implement the decoration manager protocol, meaning CSDs will be used regardless of the user configuration (GNOME/mutter being the most prominent one). * Title bar size and color, including transparency * Border size and color, including transparency Also drop support for rendering the CSDs inside the main surface.
2020-03-02 18:42:49 +01:00
int csd_title_size = term->conf->csd.title_height;
int csd_border_size = term->conf->csd.border_width;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
return (
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
(!term->window->is_constrained_bottom && !term->window->is_constrained_right) &&
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
((term->active_surface == TERM_SURF_BORDER_RIGHT && y > csd_title_size * term->scale + term->height) ||
(term->active_surface == TERM_SURF_BORDER_BOTTOM && x > term->width + 1 * csd_border_size * term->scale - 10 * term->scale)));
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
refactor: track current xcursor using an enum, instead of a char pointer
2023-06-27 16:57:33 +02:00
enum cursor_shape
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
xcursor_for_csd_border(struct terminal *term, int x, int y)
{
refactor: track current xcursor using an enum, instead of a char pointer
2023-06-27 16:57:33 +02:00
if (is_top_left(term, x, y)) return CURSOR_SHAPE_TOP_LEFT_CORNER;
else if (is_top_right(term, x, y)) return CURSOR_SHAPE_TOP_RIGHT_CORNER;
else if (is_bottom_left(term, x, y)) return CURSOR_SHAPE_BOTTOM_LEFT_CORNER;
else if (is_bottom_right(term, x, y)) return CURSOR_SHAPE_BOTTOM_RIGHT_CORNER;
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
else if (term->active_surface == TERM_SURF_BORDER_LEFT)
return !term->window->is_constrained_left
? CURSOR_SHAPE_LEFT_SIDE : CURSOR_SHAPE_LEFT_PTR;
else if (term->active_surface == TERM_SURF_BORDER_RIGHT)
return !term->window->is_constrained_right
? CURSOR_SHAPE_RIGHT_SIDE : CURSOR_SHAPE_LEFT_PTR;
else if (term->active_surface == TERM_SURF_BORDER_TOP)
return !term->window->is_constrained_top
? CURSOR_SHAPE_TOP_SIDE : CURSOR_SHAPE_LEFT_PTR;
else if (term->active_surface == TERM_SURF_BORDER_BOTTOM)
return !term->window->is_constrained_bottom
? CURSOR_SHAPE_BOTTOM_SIDE : CURSOR_SHAPE_LEFT_PTR;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
else {
Convert some more uses of xassert(false) to BUG("...")
2021-02-09 15:16:19 +00:00
BUG("Unreachable");
refactor: track current xcursor using an enum, instead of a char pointer
2023-06-27 16:57:33 +02:00
return CURSOR_SHAPE_NONE;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
}
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
static void
mouse_button_state_reset(struct seat *seat)
{
tll_free(seat->mouse.buttons);
seat->mouse.count = 0;
seat->mouse.last_released_button = 0;
memset(&seat->mouse.last_time, 0, sizeof(seat->mouse.last_time));
}
static void
mouse_coord_pixel_to_cell(struct seat *seat, const struct terminal *term,
int x, int y)
{
/*
* Translate x,y pixel coordinate to a cell coordinate, or -1
* if the cursor is outside the grid. I.e. if it is inside the
* margins.
*/
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
if (x < term->margins.left)
seat->mouse.col = 0;
else if (x >= term->width - term->margins.right)
seat->mouse.col = term->cols - 1;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
else
seat->mouse.col = (x - term->margins.left) / term->cell_width;
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
if (y < term->margins.top)
seat->mouse.row = 0;
else if (y >= term->height - term->margins.bottom)
seat->mouse.row = term->rows - 1;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
else
seat->mouse.row = (y - term->margins.top) / term->cell_height;
}
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
static bool
touch_is_active(const struct seat *seat)
{
if (seat->wl_touch == NULL) {
return false;
}
switch (seat->touch.state) {
case TOUCH_STATE_IDLE:
case TOUCH_STATE_INHIBITED:
return false;
case TOUCH_STATE_HELD:
case TOUCH_STATE_DRAGGING:
case TOUCH_STATE_SCROLLING:
return true;
}
BUG("Bad touch state: %d", seat->touch.state);
return false;
}
input: mouse events
2019-07-05 10:44:57 +02:00
static void
wl_pointer_enter(void *data, struct wl_pointer *wl_pointer,
uint32_t serial, struct wl_surface *surface,
wl_fixed_t surface_x, wl_fixed_t surface_y)
{
input: ignore pointer motion events on unknown surfaces In some cases, the compositor sends a pointer enter event with a NULL surface. It’s unclear if this is a compositor bug, or a race (where the compositor sends an enter event on a CSD surface at the same time foot unmaps the CSDs). Regardless, this causes seat->mouse_focus to be unset, which triggers a crash in foot on the next pointer motion event. This patch does two things: a) log a warning when we receive a pointer event with a NULL surface b) ignore motion events where seat->mouse_focus is NULL
2022-08-12 16:13:25 +02:00
if (unlikely(surface == NULL)) {
input: mutter has been seen sending NULL surfaces in pointer enter
2021-03-04 08:57:31 +01:00
/* Seen on mutter-3.38 */
input: ignore pointer motion events on unknown surfaces In some cases, the compositor sends a pointer enter event with a NULL surface. It’s unclear if this is a compositor bug, or a race (where the compositor sends an enter event on a CSD surface at the same time foot unmaps the CSDs). Regardless, this causes seat->mouse_focus to be unset, which triggers a crash in foot on the next pointer motion event. This patch does two things: a) log a warning when we receive a pointer event with a NULL surface b) ignore motion events where seat->mouse_focus is NULL
2022-08-12 16:13:25 +02:00
LOG_WARN("compositor sent pointer_enter event with a NULL surface");
input: mutter has been seen sending NULL surfaces in pointer enter
2021-03-04 08:57:31 +01:00
return;
}
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
wayland: store pointer to window instance in all surfaces
2020-02-29 12:09:28 +01:00
struct wl_window *win = wl_surface_get_user_data(surface);
struct terminal *term = win->term;
wayland: change all wayland callbacks to take a wayland pointer Instead of passing the terminal to the wayland callbacks, pass a 'struct wayland' pointer.
2019-10-27 18:43:07 +01:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
seat->mouse_focus = term;
term->active_surface = term_surface_kind(term, surface);
if (touch_is_active(seat))
return;
input: Update mouse x/y coordinates on wl_pointer_enter Otherwise if you don't receive motion event before e.g. button pressed, the coordinates will be incorrect. This happens when e.g. you get alt-tabbed so that the mouse cursor ends up on top of the terminal window, but the mouse never actually moved.
2021-11-19 15:04:51 +01:00
int x = wl_fixed_to_int(surface_x) * term->scale;
int y = wl_fixed_to_int(surface_y) * term->scale;
seat: use separate 'enter' serials for keyboard and mouse
2020-07-09 11:20:46 +02:00
seat->pointer.serial = serial;
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
seat->pointer.hidden = false;
input: Update mouse x/y coordinates on wl_pointer_enter Otherwise if you don't receive motion event before e.g. button pressed, the coordinates will be incorrect. This happens when e.g. you get alt-tabbed so that the mouse cursor ends up on top of the terminal window, but the mouse never actually moved.
2021-11-19 15:04:51 +01:00
seat->mouse.x = x;
seat->mouse.y = y;
seat: use separate 'enter' serials for keyboard and mouse
2020-07-09 11:20:46 +02:00
input: Update mouse x/y coordinates on wl_pointer_enter Otherwise if you don't receive motion event before e.g. button pressed, the coordinates will be incorrect. This happens when e.g. you get alt-tabbed so that the mouse cursor ends up on top of the terminal window, but the mouse never actually moved.
2021-11-19 15:04:51 +01:00
LOG_DBG("pointer-enter: pointer=%p, serial=%u, surface = %p, new-moused = %p, "
"x=%d, y=%d",
(void *)wl_pointer, serial, (void *)surface, (void *)term,
x, y);
input: pointer-enter: add debug log
2019-11-29 22:12:54 +01:00
input: workaround GNOME messing up pointer leave/enter after moving window GNOME doesn’t send pointer enter after finishing a window move. In subsequent move operations, it is also possible to make it skip sending pointer leave when starting the move operations. This caused foot to assert in debug builds, and add the same button multiple times to the list of buttons currently being pressed.
2021-08-04 17:27:34 +02:00
xassert(tll_length(seat->mouse.buttons) == 0);
input: always update the xcursor shape in pointer enter/motion events Now that term_xcursor_update_for_seat() takes the current surface into account (i.e. doesn’t assume the cursor is over the main grid), there’s no longer any need to call render_xcursor_set() directly. Thus, we can simply call term_xcursor_update_for_seat() on **all** pointer enter and motion events. As long as we take care to update the internal state to reflect the, possibly new, current surface before doing so. Also make sure to **always** reset the seat’s “current” xcursor pointer on pointer leave events. This is done without actually sending anything to the compositor, but is necessary to ensure that we *do* send a request to update the xcursor on the next pointer enter event.
2021-12-01 20:04:01 +01:00
wayl_reload_xcursor_theme(seat, term->scale); /* Scale may have changed */
term_xcursor_update_for_seat(term, seat);
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
input: always update the xcursor shape in pointer enter/motion events Now that term_xcursor_update_for_seat() takes the current surface into account (i.e. doesn’t assume the cursor is over the main grid), there’s no longer any need to call render_xcursor_set() directly. Thus, we can simply call term_xcursor_update_for_seat() on **all** pointer enter and motion events. As long as we take care to update the internal state to reflect the, possibly new, current surface before doing so. Also make sure to **always** reset the seat’s “current” xcursor pointer on pointer leave events. This is done without actually sending anything to the compositor, but is necessary to ensure that we *do* send a request to update the xcursor on the next pointer enter event.
2021-12-01 20:04:01 +01:00
switch (term->active_surface) {
input: margins are not selectable * Fix col/row calculation in pointer-enter event; we did not take the margins into account. * seat->mouse.col,row are now set to -1 if the cursor is inside the margins. That is, col/row are only ever valid when the mouse is actually over the grid, and not in the margins. * Use regular 'left-ptr' mouse cursor when mouse is inside the margins, to not make the user think he/she can start a selection. Besides making things clearer, this also fixes a crash that occurred if you started a selection in e.g. the right margin.
2020-07-26 12:31:13 +02:00
case TERM_SURF_GRID: {
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
mouse_coord_pixel_to_cell(seat, term, x, y);
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
break;
input: margins are not selectable * Fix col/row calculation in pointer-enter event; we did not take the margins into account. * seat->mouse.col,row are now set to -1 if the cursor is inside the margins. That is, col/row are only ever valid when the mouse is actually over the grid, and not in the margins. * Use regular 'left-ptr' mouse cursor when mouse is inside the margins, to not make the user think he/she can start a selection. Besides making things clearer, this also fixes a crash that occurred if you started a selection in e.g. the right margin.
2020-07-26 12:31:13 +02:00
}
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_TITLE:
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
case TERM_SURF_BORDER_LEFT:
case TERM_SURF_BORDER_RIGHT:
case TERM_SURF_BORDER_TOP:
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
case TERM_SURF_BORDER_BOTTOM:
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
break;
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_BUTTON_MINIMIZE:
case TERM_SURF_BUTTON_MAXIMIZE:
input: do a full CSD repaint on pointer motion over CSD buttons This fixes repainting issues on mutter.
2020-03-03 18:22:32 +01:00
case TERM_SURF_BUTTON_CLOSE:
render: never render CSD and/or search box "immediately" Handle the CSDs and the search box the same way we handle the main grid; when we need to redraw them, call render_refresh_{csd,search}(). This sets a flag that is checked after each FDM iteration. All actual rendering is done here. This also ties the commits of the Wayland sub-surfaces to the commit of the main surface.
2020-03-06 19:16:54 +01:00
render_refresh_csd(term);
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
break;
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_NONE:
Convert all but 2 remaining uses of xassert(false) to BUG("...")
2021-02-10 09:01:51 +00:00
BUG("Invalid surface type");
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
break;
}
input: mouse events
2019-07-05 10:44:57 +02:00
}
static void
wl_pointer_leave(void *data, struct wl_pointer *wl_pointer,
uint32_t serial, struct wl_surface *surface)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
if (seat->wl_touch != NULL) {
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
switch (seat->touch.state) {
case TOUCH_STATE_IDLE:
break;
case TOUCH_STATE_INHIBITED:
seat->touch.state = TOUCH_STATE_IDLE;
break;
case TOUCH_STATE_HELD:
case TOUCH_STATE_DRAGGING:
case TOUCH_STATE_SCROLLING:
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
}
}
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct terminal *old_moused = seat->mouse_focus;
input: pointer-leave: reset moused *before* doing anything else And update xcursor. This is currently not necessary, but doesn't hurt.
2019-11-29 22:13:19 +01:00
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
LOG_DBG(
input: include seat name in debug log output
2020-07-11 11:13:45 +02:00
"%s: pointer-leave: pointer=%p, serial=%u, surface = %p, old-moused = %p",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
seat->name, (void *)wl_pointer, serial, (void *)surface,
(void *)old_moused);
input: pointer-leave: reset moused *before* doing anything else And update xcursor. This is currently not necessary, but doesn't hurt.
2019-11-29 22:13:19 +01:00
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
seat->pointer.hidden = false;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->pointer.xcursor_callback != NULL) {
input: fix xcursor getting stuck Apparently, a frame callback for the cursor surface is *never* triggered if we get a pointer-leave event *before* the callback is triggered. At least on Sway 1.4. This caused the cursor being stuck, and never updating once this state was reached. Fix by destroying the cursor frame callback on pointer-leave.
2020-02-15 19:02:43 +01:00
/* A cursor frame callback may never be called if the pointer leaves our surface */
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
wl_callback_destroy(seat->pointer.xcursor_callback);
seat->pointer.xcursor_callback = NULL;
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
seat->pointer.xcursor_pending = false;
input: fix xcursor getting stuck Apparently, a frame callback for the cursor surface is *never* triggered if we get a pointer-leave event *before* the callback is triggered. At least on Sway 1.4. This caused the cursor being stuck, and never updating once this state was reached. Fix by destroying the cursor frame callback on pointer-leave.
2020-02-15 19:02:43 +01:00
}
input: always update the xcursor shape in pointer enter/motion events Now that term_xcursor_update_for_seat() takes the current surface into account (i.e. doesn’t assume the cursor is over the main grid), there’s no longer any need to call render_xcursor_set() directly. Thus, we can simply call term_xcursor_update_for_seat() on **all** pointer enter and motion events. As long as we take care to update the internal state to reflect the, possibly new, current surface before doing so. Also make sure to **always** reset the seat’s “current” xcursor pointer on pointer leave events. This is done without actually sending anything to the compositor, but is necessary to ensure that we *do* send a request to update the xcursor on the next pointer enter event.
2021-12-01 20:04:01 +01:00
/* Reset last-set-xcursor, to ensure we update it on a pointer-enter event */
refactor: track current xcursor using an enum, instead of a char pointer
2023-06-27 16:57:33 +02:00
seat->pointer.shape = CURSOR_SHAPE_NONE;
input: always update the xcursor shape in pointer enter/motion events Now that term_xcursor_update_for_seat() takes the current surface into account (i.e. doesn’t assume the cursor is over the main grid), there’s no longer any need to call render_xcursor_set() directly. Thus, we can simply call term_xcursor_update_for_seat() on **all** pointer enter and motion events. As long as we take care to update the internal state to reflect the, possibly new, current surface before doing so. Also make sure to **always** reset the seat’s “current” xcursor pointer on pointer leave events. This is done without actually sending anything to the compositor, but is necessary to ensure that we *do* send a request to update the xcursor on the next pointer enter event.
2021-12-01 20:04:01 +01:00
input: reset mouse state on pointer leave
2020-02-29 12:08:59 +01:00
/* Reset mouse state */
input: pointer-leave: don't reset mouse properties with memset() Using memset() also clears the mouse bindings. This is both incorrect, and leaked memory.
2020-08-10 18:59:03 +02:00
seat->mouse.x = seat->mouse.y = 0;
seat->mouse.col = seat->mouse.row = 0;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
mouse_button_state_reset(seat);
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
for (size_t i = 0; i < ALEN(seat->mouse.aggregated); i++)
seat->mouse.aggregated[i] = 0.0;
input: pointer-leave: don't reset mouse properties with memset() Using memset() also clears the mouse bindings. This is both incorrect, and leaked memory.
2020-08-10 18:59:03 +02:00
seat->mouse.have_discrete = false;
input: reset mouse state on pointer leave
2020-02-29 12:08:59 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse_focus = NULL;
input: pointer-leave: reset moused *before* doing anything else And update xcursor. This is currently not necessary, but doesn't hurt.
2019-11-29 22:13:19 +01:00
if (old_moused == NULL) {
input: keyboard/pointer_leave: warn if we didn't see corresponding enter event
2019-11-28 19:47:00 +01:00
LOG_WARN(
"compositor sent pointer_leave event without a pointer_enter "
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
"event: surface=%p", (void *)surface);
input: pointer-leave: reset 'active-surface' in terminal
2020-02-24 22:41:46 +01:00
} else {
wayland: store pointer to window instance in all surfaces
2020-02-29 12:09:28 +01:00
if (surface != NULL) {
/* Sway 1.4 sends this event with a NULL surface when we destroy the window */
Replace GCC "unused" and "format" attributes with portable macros
2020-08-07 20:42:34 +01:00
const struct wl_window UNUSED *win = wl_surface_get_user_data(surface);
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(old_moused == win->term);
wayland: store pointer to window instance in all surfaces
2020-02-29 12:09:28 +01:00
}
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
enum term_surface active_surface = old_moused->active_surface;
input: pointer-leave: reset 'active-surface' in terminal
2020-02-24 22:41:46 +01:00
old_moused->active_surface = TERM_SURF_NONE;
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
switch (active_surface) {
case TERM_SURF_BUTTON_MINIMIZE:
case TERM_SURF_BUTTON_MAXIMIZE:
input: do a full CSD repaint on pointer motion over CSD buttons This fixes repainting issues on mutter.
2020-03-03 18:22:32 +01:00
case TERM_SURF_BUTTON_CLOSE:
term: consolidate shutdown related state into an anonymous struct
2021-07-31 19:08:51 +02:00
if (old_moused->shutdown.in_progress)
input: do a full CSD repaint on pointer motion over CSD buttons This fixes repainting issues on mutter.
2020-03-03 18:22:32 +01:00
break;
render: never render CSD and/or search box "immediately" Handle the CSDs and the search box the same way we handle the main grid; when we need to redraw them, call render_refresh_{csd,search}(). This sets a flag that is checked after each FDM iteration. All actual rendering is done here. This also ties the commits of the Wayland sub-surfaces to the commit of the main surface.
2020-03-06 19:16:54 +01:00
render_refresh_csd(old_moused);
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
break;
case TERM_SURF_GRID:
input: finalize mouse selection on a pointer-leave event on the GRID surface If a mouse selection was ongoing, and the user switched workspace (probably using the keyboard...), and then back, the selection was still treated as ongoing, while all other mouse state has been reset. This meant the user had to tap at least once to stop the selection.
2021-11-25 15:21:53 +01:00
selection_finalize(seat, old_moused, seat->pointer.serial);
break;
case TERM_SURF_NONE:
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_TITLE:
case TERM_SURF_BORDER_LEFT:
case TERM_SURF_BORDER_RIGHT:
case TERM_SURF_BORDER_TOP:
case TERM_SURF_BORDER_BOTTOM:
break;
}
input: pointer-leave: reset 'active-surface' in terminal
2020-02-24 22:41:46 +01:00
}
input: mouse events
2019-07-05 10:44:57 +02:00
}
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
static bool
pointer_is_on_button(const struct terminal *term, const struct seat *seat,
enum csd_surface csd_surface)
{
if (seat->mouse.x < 0)
return false;
if (seat->mouse.y < 0)
return false;
struct csd_data info = get_csd_data(term, csd_surface);
if (seat->mouse.x > info.width)
return false;
if (seat->mouse.y > info.height)
return false;
return true;
}
input: mouse events
2019-07-05 10:44:57 +02:00
static void
wl_pointer_motion(void *data, struct wl_pointer *wl_pointer,
uint32_t time, wl_fixed_t surface_x, wl_fixed_t surface_y)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
/* Touch-emulated pointer events have wl_pointer == NULL. */
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (wl_pointer != NULL && touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct wayland *wayl = seat->wayl;
struct terminal *term = seat->mouse_focus;
input: ignore pointer motion events on unknown surfaces In some cases, the compositor sends a pointer enter event with a NULL surface. It’s unclear if this is a compositor bug, or a race (where the compositor sends an enter event on a CSD surface at the same time foot unmaps the CSDs). Regardless, this causes seat->mouse_focus to be unset, which triggers a crash in foot on the next pointer motion event. This patch does two things: a) log a warning when we receive a pointer event with a NULL surface b) ignore motion events where seat->mouse_focus is NULL
2022-08-12 16:13:25 +02:00
if (unlikely(term == NULL)) {
/* Typically happens when the compositor sent a pointer enter
* event with a NULL surface - see wl_pointer_enter().
*
* In this case, we never set seat->mouse_focus (since we
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* can't map the enter event to a specific window). */
input: ignore pointer motion events on unknown surfaces In some cases, the compositor sends a pointer enter event with a NULL surface. It’s unclear if this is a compositor bug, or a race (where the compositor sends an enter event on a CSD surface at the same time foot unmaps the CSDs). Regardless, this causes seat->mouse_focus to be unset, which triggers a crash in foot on the next pointer motion event. This patch does two things: a) log a warning when we receive a pointer event with a NULL surface b) ignore motion events where seat->mouse_focus is NULL
2022-08-12 16:13:25 +02:00
return;
}
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
struct wl_window *win = term->window;
keyboard repeat: pass current input serial to keyboard_key() This fixes an assertion when holding in ctrl+shift+c (copy to clipboard); subsequent "presses" would set the clipboard serial to 0, which we would then assert on in the next iteration when we tried to cancel the previous copy.
2019-11-22 21:49:50 +01:00
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
LOG_DBG("pointer_motion: pointer=%p, x=%d, y=%d", (void *)wl_pointer,
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
wl_fixed_to_int(surface_x), wl_fixed_to_int(surface_y));
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(term != NULL);
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
main: initialize scale to '1' This ensures we always have a valid (but possibly incorrect) scaling value. This allows us to simplify code that uses the scale - it doesn't have to verify the scale if valid. Furthermore, since render_resize() is the function that actually updates term->scale, make sure to call it *before* updating the cursor (otherwise, the cursor will use the old scaling value).
2019-09-26 18:39:49 +02:00
int x = wl_fixed_to_int(surface_x) * term->scale;
int y = wl_fixed_to_int(surface_y) * term->scale;
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
enum term_surface surf_kind = term->active_surface;
int button = 0;
bool send_to_client = false;
bool is_on_button = false;
/* If current surface is a button, check if pointer was on it
*before* the motion event */
switch (surf_kind) {
case TERM_SURF_BUTTON_MINIMIZE:
is_on_button = pointer_is_on_button(term, seat, CSD_SURF_MINIMIZE);
break;
case TERM_SURF_BUTTON_MAXIMIZE:
is_on_button = pointer_is_on_button(term, seat, CSD_SURF_MAXIMIZE);
break;
case TERM_SURF_BUTTON_CLOSE:
is_on_button = pointer_is_on_button(term, seat, CSD_SURF_CLOSE);
break;
case TERM_SURF_NONE:
case TERM_SURF_GRID:
case TERM_SURF_TITLE:
case TERM_SURF_BORDER_LEFT:
case TERM_SURF_BORDER_RIGHT:
case TERM_SURF_BORDER_TOP:
case TERM_SURF_BORDER_BOTTOM:
break;
}
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
seat->pointer.hidden = false;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.x = x;
seat->mouse.y = y;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
input: always update the xcursor shape in pointer enter/motion events Now that term_xcursor_update_for_seat() takes the current surface into account (i.e. doesn’t assume the cursor is over the main grid), there’s no longer any need to call render_xcursor_set() directly. Thus, we can simply call term_xcursor_update_for_seat() on **all** pointer enter and motion events. As long as we take care to update the internal state to reflect the, possibly new, current surface before doing so. Also make sure to **always** reset the seat’s “current” xcursor pointer on pointer leave events. This is done without actually sending anything to the compositor, but is necessary to ensure that we *do* send a request to update the xcursor on the next pointer enter event.
2021-12-01 20:04:01 +01:00
term_xcursor_update_for_seat(term, seat);
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
if (tll_length(seat->mouse.buttons) > 0) {
const struct button_tracker *tracker = &tll_front(seat->mouse.buttons);
surf_kind = tracker->surf_kind;
button = tracker->button;
send_to_client = tracker->send_to_client;
}
switch (surf_kind) {
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
case TERM_SURF_NONE:
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
break;
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_BUTTON_MINIMIZE:
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
if (pointer_is_on_button(term, seat, CSD_SURF_MINIMIZE) != is_on_button)
render_refresh_csd(term);
break;
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_BUTTON_MAXIMIZE:
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
if (pointer_is_on_button(term, seat, CSD_SURF_MAXIMIZE) != is_on_button)
render_refresh_csd(term);
break;
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_BUTTON_CLOSE:
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
if (pointer_is_on_button(term, seat, CSD_SURF_CLOSE) != is_on_button)
render_refresh_csd(term);
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
break;
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
case TERM_SURF_TITLE:
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
/* We've started a 'move' timer, but user started dragging
* right away - abort the timer and initiate the actual move
* right away */
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
if (button == BTN_LEFT && win->csd.move_timeout_fd != -1) {
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
fdm_del(wayl->fdm, win->csd.move_timeout_fd);
win->csd.move_timeout_fd = -1;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
xdg_toplevel_move(win->xdg_toplevel, seat->wl_seat, win->csd.serial);
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
}
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
break;
case TERM_SURF_BORDER_LEFT:
case TERM_SURF_BORDER_RIGHT:
case TERM_SURF_BORDER_TOP:
case TERM_SURF_BORDER_BOTTOM:
break;
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_GRID: {
input: margins are not selectable * Fix col/row calculation in pointer-enter event; we did not take the margins into account. * seat->mouse.col,row are now set to -1 if the cursor is inside the margins. That is, col/row are only ever valid when the mouse is actually over the grid, and not in the margins. * Use regular 'left-ptr' mouse cursor when mouse is inside the margins, to not make the user think he/she can start a selection. Besides making things clearer, this also fixes a crash that occurred if you started a selection in e.g. the right margin.
2020-07-26 12:31:13 +02:00
int old_col = seat->mouse.col;
int old_row = seat->mouse.row;
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
mouse_coord_pixel_to_cell(seat, term, seat->mouse.x, seat->mouse.y);
input: report mouse drag events also when the pointer is outside the grid As long as the mouse button was *pressed* while the pointer was inside the grid, we want to keep reporting motion events until the button is released. Even when the pointer moves outside the grid (but in this case, the reported coordinates are bounded by the grid size). This patch also tries to improve multi-button handling (i.e. multiple buttons pressed at the same time), and the events we report to the client for these, in the following ways: * Motion events now report the *initial* button. That is, if you start a drag operation with the LEFT button, then press RIGHT (before releasing LEFT), keep reporting LEFT in the motion events. * Mouse release events are reported for *any* button, as long as the pointer is *inside* the grid, *or*, the button released was the button used to start a drag operation. The last point is important; if we have reported a button press followed by motion events (i.e. a drag operation), we need to report the button release, *even* if the pointer is outside the grid. Note that the client may receive unbalanced button press/release events in the following ways if the user pressed one, and then a second button *inside* the grid, then releases the *first* button (possibly outside the grid), and finally releases the *second* button *outside* the grid. In this case, both buttons will report press events. The first button will report a release event since it is the initial button in the drag operation. However, we don’t track the fact that the second button is being pressed, and thus if it is released outside the grid, it wont generate a release event.
2020-12-11 20:48:43 +01:00
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
xassert(seat->mouse.col >= 0 && seat->mouse.col < term->cols);
xassert(seat->mouse.row >= 0 && seat->mouse.row < term->rows);
input: ignore mouse motion outside our window
2019-07-11 11:09:34 +02:00
input: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
/* Cursor has moved to a different cell since last time */
bool cursor_is_on_new_cell
= old_col != seat->mouse.col || old_row != seat->mouse.row;
selection: add a selection API
2019-07-11 09:51:51 +02:00
input: reset mouse button click counter when mouse moves As described in #883, creating a block selection (with ctrl+BTN_LEFT), then *quickly* (within 300ms from) creating a new one, will, in fact, _not_ create a new block selection, but a ‘select-word-whitespace’ selection (ctrl+BTN_LEFT-2). A similar effect can be seen with plain selections (BTN_LEFT). Click and drag to make a selection, but *release*, and make a new selection within 300ms from the initial button press, and the new selection is suddenly a word-based selection. This happens because triggering a binding does *not* reset the button click counter. So, shouldn’t we just do that? No, because we rely on this behavior to handle single-, double- and triple-click actions. If we were to reset the button click handler, then we’d have to instead delay triggering the first action with 300ms, which would make things appear laggy. If we don’t do this, it would be impossible to double- and triple-click, since the single-click action would keep resetting the click counter. This patch takes a slightly different approach; we reset the click counter when the mouse has moved “too much”. For now, “too much” is when the cursor has moved to a different cell. This way, single-, double- and triple-clicks continue to work as before. But, creating actual selections, and then quickly releasing and starting a new selection produces the expected results. Closes #883
2022-01-12 15:38:32 +01:00
if (cursor_is_on_new_cell) {
/* Prevent multiple/different mouse bindings from
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* triggering if the mouse has moved "too much" (to
input: reset mouse button click counter when mouse moves As described in #883, creating a block selection (with ctrl+BTN_LEFT), then *quickly* (within 300ms from) creating a new one, will, in fact, _not_ create a new block selection, but a ‘select-word-whitespace’ selection (ctrl+BTN_LEFT-2). A similar effect can be seen with plain selections (BTN_LEFT). Click and drag to make a selection, but *release*, and make a new selection within 300ms from the initial button press, and the new selection is suddenly a word-based selection. This happens because triggering a binding does *not* reset the button click counter. So, shouldn’t we just do that? No, because we rely on this behavior to handle single-, double- and triple-click actions. If we were to reset the button click handler, then we’d have to instead delay triggering the first action with 300ms, which would make things appear laggy. If we don’t do this, it would be impossible to double- and triple-click, since the single-click action would keep resetting the click counter. This patch takes a slightly different approach; we reset the click counter when the mouse has moved “too much”. For now, “too much” is when the cursor has moved to a different cell. This way, single-, double- and triple-clicks continue to work as before. But, creating actual selections, and then quickly releasing and starting a new selection produces the expected results. Closes #883
2022-01-12 15:38:32 +01:00
* another cell) */
seat->mouse.count = 0;
}
input: motion: improve comment
2020-08-08 10:08:47 +02:00
/* Cursor is inside the grid, i.e. *not* in the margins */
input: motion: scroll up/down while selecting If the cursor moves above the grid top, or below the grid bottom, while selecting text, scroll up/down the scrollback before updating the selection. TODO: this only scrolls when the mouse is *moved*. I.e. you can’t move the cursor outside the grid once and for all, and then let foot auto-scroll.
2020-10-11 12:03:20 +02:00
const bool cursor_is_on_grid = seat->mouse.col >= 0 && seat->mouse.row >= 0;
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
enum selection_scroll_direction auto_scroll_direction
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
= term->selection.coords.end.row < 0
? SELECTION_SCROLL_NOT
: y < term->margins.top
? SELECTION_SCROLL_UP
: y > term->height - term->margins.bottom
? SELECTION_SCROLL_DOWN
: SELECTION_SCROLL_NOT;
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
if (auto_scroll_direction == SELECTION_SCROLL_NOT)
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
selection_stop_scroll_timer(term);
input: motion: regression: check for RMB when updating selection While refactoring this code, the check for LMB or RMB got changed to LMB or "any button". This fixes that. It also adds a boolean 'cursor_is_on_grid', which should make the code easier to read and understand.
2020-08-08 10:00:18 +02:00
input: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
/* Update selection */
input: mouse motion: don't update selection while scrollback searching When we are doing a scrollback search, the selection *is* ongoing. We still don't want to update the selection when the mouse moves.
2020-08-11 16:36:42 +02:00
if (!term->is_searching) {
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
if (auto_scroll_direction != SELECTION_SCROLL_NOT) {
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Start 'selection auto-scrolling'
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
*
* The speed of the scrolling is proportional to the
* distance between the mouse and the grid; the
input: comment: ‘fast’ -> ‘faster’
2020-10-11 18:22:29 +02:00
* further away the mouse is, the faster we scroll.
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Note that the speed is measured in 'intervals (in
* ns) between each timed scroll of a single line'.
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
*
* Thus, the further away the mouse is, the smaller
* interval value we use.
*/
int distance = auto_scroll_direction == SELECTION_SCROLL_UP
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
? term->margins.top - y
: y - (term->height - term->margins.bottom);
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(distance > 0);
input: auto-scroll: apply scrollback.multiplier to the interval divisor
2020-10-11 18:09:30 +02:00
int divisor
= distance * term->conf->scrollback.multiplier / term->scale;
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
selection_start_scroll_timer(
input: auto-scroll: apply scrollback.multiplier to the interval divisor
2020-10-11 18:09:30 +02:00
term, 400000000 / (divisor > 0 ? divisor : 1),
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
auto_scroll_direction, seat->mouse.col);
input: motion: scroll up/down while selecting If the cursor moves above the grid top, or below the grid bottom, while selecting text, scroll up/down the scrollback before updating the selection. TODO: this only scrolls when the mouse is *moved*. I.e. you can’t move the cursor outside the grid once and for all, and then let foot auto-scroll.
2020-10-11 12:03:20 +02:00
}
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
if (term->selection.ongoing &&
(cursor_is_on_new_cell ||
(term->selection.coords.end.row < 0 &&
seat->mouse.x >= term->margins.left &&
seat->mouse.x < term->width - term->margins.right &&
seat->mouse.y >= term->margins.top &&
seat->mouse.y < term->height - term->margins.bottom)))
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
{
input: allow mouse selections to start inside the margins Before this, margins were special cased: * The mouse cursor was always a pointer, and never an I-beam (thus signaling selections cannot be made). * The internal mouse coords where set to -1 when the cursor was inside the margins, causing: - text selections from being made - mouse events being passed to mouse grabbing applications In particular, even with a one-pixel margin, making selections was unnecessarily hard in e.g. fullscreen mode, where you'd expect to be able to throw the cursor into the corner of the screen and then start a selection. With this patch, the cursor is treated as if it was in the first/last column/row, when inside the margin(s). An unintended side-effect of this, initially, was that auto-scrolling selections where way too easy to trigger, since part of its logic is checking if the cursor is inside the margins. That problem has been reduced by two things: * auto-scrolling does not occur unless a selection has been started. That is, just holding down the mouse in the margins and moving up/down doesn't cause scrolling. You have to first select at least one cell in the visible viewport. * A selection isn't fully started (i.e. a cell is actually selected) unless the cursor is inside the actual grid, and *not* in the margins. What does the last point mean? We now allow a selection to be _started_ when clicking in the margin. What this means internally is we set a start coordinate for a selection, but *not* and end coordinate. At this point, we don't have an actual selection. Nothing is selected, and no cells are highlighted, graphically. This happens when we set an end coordinate. Without the last bullet point, that would happen as soon as the cursor was _moved_, even if still inside the margins. Now, we require the cursor to leave the margins and touch an actual cell before we set an end coordinate. Closes #1702
2024-07-18 08:08:44 +02:00
selection_update(term, seat->mouse.col, seat->mouse.row);
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
}
input: mouse motion: don't update selection while scrollback searching When we are doing a scrollback search, the selection *is* ongoing. We still don't want to update the selection when the mouse moves.
2020-08-11 16:36:42 +02:00
}
selection: add a selection API
2019-07-11 09:51:51 +02:00
input: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
/* Send mouse event to client application */
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
if (!term_mouse_grabbed(term, seat) &&
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
(cursor_is_on_new_cell ||
term->mouse_reporting == MOUSE_SGR_PIXELS) &&
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
((button == 0 && cursor_is_on_grid) ||
(button != 0 && send_to_client)))
input: motion: do selection update even if cursor is outside the grid Previously, the selection was only updated when the mouse cursor was inside the grid. This makes it difficult to e.g. do large selections fast, since you often end up moving the cursor outside the grid, or outside the terminal window even. Now, we update the selection regardless of *where* the cursor is. This is done by bounding the row/col we pass to 'selection_update()' to the grid, while still setting the seat's row/col to -1 when the cursor is outside the grid, to ensure the xcursor etc are set correctly. Care must also be taken to *not* pass any motion events to a mouse grabbing client, when the cursor is outside the grid. Closes #70.
2020-08-07 19:55:02 +02:00
{
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(seat->mouse.col < term->cols);
xassert(seat->mouse.row < term->rows);
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
term_mouse_motion(
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
term, button,
input: report mouse drag events also when the pointer is outside the grid As long as the mouse button was *pressed* while the pointer was inside the grid, we want to keep reporting motion events until the button is released. Even when the pointer moves outside the grid (but in this case, the reported coordinates are bounded by the grid size). This patch also tries to improve multi-button handling (i.e. multiple buttons pressed at the same time), and the events we report to the client for these, in the following ways: * Motion events now report the *initial* button. That is, if you start a drag operation with the LEFT button, then press RIGHT (before releasing LEFT), keep reporting LEFT in the motion events. * Mouse release events are reported for *any* button, as long as the pointer is *inside* the grid, *or*, the button released was the button used to start a drag operation. The last point is important; if we have reported a button press followed by motion events (i.e. a drag operation), we need to report the button release, *even* if the pointer is outside the grid. Note that the client may receive unbalanced button press/release events in the following ways if the user pressed one, and then a second button *inside* the grid, then releases the *first* button (possibly outside the grid), and finally releases the *second* button *outside* the grid. In this case, both buttons will report press events. The first button will report a release event since it is the initial button in the drag operation. However, we don’t track the fact that the second button is being pressed, and thus if it is released outside the grid, it wont generate a release event.
2020-12-11 20:48:43 +01:00
seat->mouse.row, seat->mouse.col,
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
seat->mouse.y - term->margins.top,
seat->mouse.x - term->margins.left,
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
seat->kbd.shift, seat->kbd.alt, seat->kbd.ctrl);
}
input: cleanup
2020-02-29 15:29:00 +01:00
break;
}
}
input: mouse events
2019-07-05 10:44:57 +02:00
}
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
static bool
fdm_csd_move(struct fdm *fdm, int fd, int events, void *data)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
fdm_del(fdm, fd);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->mouse_focus == NULL) {
LOG_WARN(
"%s: CSD move timeout triggered, but seat's has no mouse focused terminal",
seat->name);
return true;
}
struct wl_window *win = seat->mouse_focus->window;
win->csd.move_timeout_fd = -1;
xdg_toplevel_move(win->xdg_toplevel, seat->wl_seat, win->csd.serial);
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
return true;
}
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
static const struct key_binding *
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
match_mouse_binding(const struct seat *seat, const struct terminal *term,
int button)
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
{
if (seat->wl_keyboard != NULL && seat->kbd.xkb_state != NULL) {
/* Seat has keyboard - use mouse bindings *with* modifiers */
const struct key_binding_set *bindings =
key_binding_for(term->wl->key_binding_manager, term->conf, seat);
xassert(bindings != NULL);
xkb_mod_mask_t mods;
input: remove the concept of "significant" modifiers For the purpose of matching key bindings, "significant" modifiers are no more. We're really only interested in filtering out "locked" modifiers. We're already doing this, so there's no need to *also* match against a set of "significant" modifiers. Furthermore, we *never* want to consider locked keys (e.g. when emitting escapes to the client application), thus we can filter those out already when retrieving the set of active modifiers. The exception is the kitty keyboard protocol, which has support for CapsLock and NumLock. Since we're already re-retrieving the "consumed" modifiers (using the GTK style, rather than normal "XKB" style, to better match the kitty terminal), we might as well re-retrieve the effective modifiers as well.
2024-02-06 10:41:01 +01:00
get_current_modifiers(seat, &mods, NULL, 0, true);
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
/* Ignore selection override modifiers when
* matching modifiers */
mods &= ~bindings->selection_overrides;
const struct key_binding *match = NULL;
tll_foreach(bindings->mouse, it) {
const struct key_binding *binding = &it->item;
if (binding->m.button != button) {
/* Wrong button */
continue;
}
if (binding->mods != mods) {
/* Modifier mismatch */
continue;
}
if (binding->m.count > seat->mouse.count) {
/* Not correct click count */
continue;
}
if (match == NULL || binding->m.count > match->m.count)
match = binding;
}
return match;
}
else {
/* Seat does NOT have a keyboard - use mouse bindings *without*
* modifiers */
const struct config_key_binding *match = NULL;
const struct config *conf = term->conf;
for (size_t i = 0; i < conf->bindings.mouse.count; i++) {
const struct config_key_binding *binding =
&conf->bindings.mouse.arr[i];
if (binding->m.button != button) {
/* Wrong button */
continue;
}
if (binding->m.count > seat->mouse.count) {
/* Incorrect click count */
continue;
}
input/config: support *all* modifier names That is, allow custom modifiers (i.e. other than ctrl/shift/alt etc) in key bindings. This is done by no longer validating/translating modifier names to booleans for a pre-configured set of modifiers (ctrl, shift, alt, super). Instead, we keep the modifier *names* in a list, in the key binding struct. When a keymap is loaded, and we "convert" the key binding, _then_ we do modifier translation. For invalid modifier names, we print an error, and then ignore it. I.e. we no longer fail to load a config due to invalid modifier names. We also need to update how we determine the set of significant modifiers. Any modifier not in this list will be ignored when matching key bindings. Before this patch, we hardcoded this to shift/alt/ctrl/super. Now, to handle custom modifiers as well, we simply treat *all* modifiers defined by the current layout as significant. Typically, the only unwanted modifiers are "locked" modifiers. We are already filtering these out.
2023-05-06 11:39:38 +02:00
if (tll_length(binding->modifiers) > 0) {
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
/* Binding has modifiers */
continue;
}
if (match == NULL || binding->m.count > match->m.count)
match = binding;
}
if (match != NULL) {
static struct key_binding bind;
bind.action = match->action;
bind.aux = &match->aux;
return &bind;
}
return NULL;
}
BUG("should not get here");
}
input: mouse events
2019-07-05 10:44:57 +02:00
static void
wl_pointer_button(void *data, struct wl_pointer *wl_pointer,
uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
LOG_DBG("BUTTON: pointer=%p, serial=%u, button=%x, state=%u",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
(void *)wl_pointer, serial, button, state);
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
input: assert serial received from compositor is non-zero
2022-04-23 15:54:37 +02:00
xassert(serial != 0);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
/* Touch-emulated pointer events have wl_pointer == NULL. */
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (wl_pointer != NULL && touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct wayland *wayl = seat->wayl;
struct terminal *term = seat->mouse_focus;
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
input: update serial on each key press/release and mouse button The serial is used when copying/pasting data from the clipboard. Up until now, we’ve used the serial from the keyboard/mouse enter events. This works in most cases, but breaks in the following example: $ wl-copy WLCOPY /* Ctrl+Shift+v works fine (pastes "WLCOPY") */ $ printf "\033]52;c;eHl6\a" /* Ctrl+Shift+v pastes "WLCOPY" instead of "xyz" */ Shifting focus away and then back to the foot window, and re-executing the printf works, suggesting the “enter” serial is no longer valid after another process(?) has copied something to the clipboard. Updating the serial on key press/release (and the corresponding mouse serial on mouse button events) seems to fix this. I’ve also tested that “normal” copy/paste operations, within the same foot instance, and between foot and other applications, are still working. In at least river (wlroots based), and GNOME/mutter. Closes #753
2021-10-20 18:47:36 +02:00
seat->pointer.serial = serial;
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
seat->pointer.hidden = false;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(term != NULL);
input: pointer-motion/button: ignore actions in non-main surfaces
2020-02-24 22:42:04 +01:00
input: make sure ‘surf_kind’ is not uninitialized
2020-12-12 21:10:28 +01:00
enum term_surface surf_kind = TERM_SURF_NONE;
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
bool send_to_client = false;
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (seat->wl_touch != NULL && seat->touch.state == TOUCH_STATE_IDLE) {
seat->touch.state = TOUCH_STATE_INHIBITED;
}
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
/* Time since last click */
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
struct timespec now, since_last;
clock_gettime(CLOCK_MONOTONIC, &now);
timespec_sub(&now, &seat->mouse.last_time, &since_last);
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
if (seat->mouse.last_released_button == button &&
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
since_last.tv_sec == 0 && since_last.tv_nsec <= 300 * 1000 * 1000)
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.count++;
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
} else
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.count = 1;
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
/*
* Workaround GNOME bug
*
* Dragging the window, then stopping the drag (releasing the
* mouse button), *without* moving the mouse, and then
* clicking twice, waiting for the CSD timer, and finally
* clicking once more, results in the following sequence
* (keyboard and other irrelevant events filtered out, unless
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* they're needed to prove a point):
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
*
* dbg: input.c:1551: cancelling drag timer, moving window
* dbg: input.c:759: keyboard_leave: keyboard=0x607000003580, serial=873, surface=0x6070000036d0
* dbg: input.c:1432: seat0: pointer-leave: pointer=0x607000003660, serial=874, surface = 0x6070000396e0, old-moused = 0x622000006100
*
* --> drag stopped here
*
* --> LMB clicked first time after the drag (generates the
* enter event on *release*, but no button events)
* dbg: input.c:1360: pointer-enter: pointer=0x607000003660, serial=876, surface = 0x6070000396e0, new-moused = 0x622000006100
*
* --> LMB clicked, and held until the timer times out, second
* time after the drag
* dbg: input.c:1712: BUTTON: pointer=0x607000003660, serial=877, button=110, state=1
* dbg: input.c:1806: starting move timer
* dbg: input.c:1692: move timer timed out
* dbg: input.c:759: keyboard_leave: keyboard=0x607000003580, serial=878, surface=0x6070000036d0
*
* --> NOTE: ^^ no pointer leave event this time, only the
* keyboard leave
*
* --> LMB clicked one last time
* dbg: input.c:697: seat0: keyboard_enter: keyboard=0x607000003580, serial=879, surface=0x6070000036d0
* dbg: input.c:1712: BUTTON: pointer=0x607000003660, serial=880, button=110, state=1
* err: input.c:1741: BUG in wl_pointer_button(): assertion failed: 'it->item.button != button'
*
* What are we seeing?
*
* - GNOME does *not* send a pointer *enter* event after the drag
* has stopped
* - The second drag does *not* generate a pointer *leave* event
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* - The missing leave event means we're still tracking LMB as
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
* being held down in our seat struct.
* - This leads to an assert (debug builds) when LMB is clicked
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* again (seat's button list already contains LMB).
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Note: I've also observed variants of the above
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
*/
tll_foreach(seat->mouse.buttons, it) {
if (it->item.button == button) {
LOG_WARN("multiple button press events for button %d "
"(compositor bug?)", button);
tll_remove(seat->mouse.buttons, it);
break;
}
}
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
#if defined(_DEBUG)
tll_foreach(seat->mouse.buttons, it)
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(it->item.button != button);
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
#endif
input: don’t assert when receiving a button release without a press event
2021-01-04 18:32:00 +01:00
/*
* Remember which surface "owns" this button, so that we can
* send motion and button release events to that surface, even
* if the pointer is no longer over it.
*/
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
tll_push_back(
seat->mouse.buttons,
((struct button_tracker){
.button = button,
.surf_kind = term->active_surface,
.send_to_client = false}));
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.last_time = now;
input: handle double/triple click state regardless of surface
2020-02-29 11:55:43 +01:00
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
surf_kind = term->active_surface;
send_to_client = false; /* For now, may be set to true if a binding consumes the button */
} else {
bool UNUSED have_button = false;
tll_foreach(seat->mouse.buttons, it) {
if (it->item.button == button) {
have_button = true;
surf_kind = it->item.surf_kind;
send_to_client = it->item.send_to_client;
tll_remove(seat->mouse.buttons, it);
break;
}
}
input: don’t assert when receiving a button release without a press event
2021-01-04 18:32:00 +01:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (seat->wl_touch != NULL && seat->touch.state == TOUCH_STATE_INHIBITED) {
if (tll_length(seat->mouse.buttons) == 0) {
seat->touch.state = TOUCH_STATE_IDLE;
}
}
input: don’t assert when receiving a button release without a press event
2021-01-04 18:32:00 +01:00
if (!have_button) {
/*
* Seen on Sway with slurp
*
* 1. Run slurp
* 2. Press, and hold left mouse button
* 3. Press escape, to cancel slurp
* 4. Release mouse button
* 5. BAM!
*/
input: workaround GNOME issue with pointer button events Under certain circumstances, GNOME will send multiple pointer button press events, without any release or leave events in between. This trips up our button tracking. Workaround, by replacing the existing state for the pressed button with the new state. Previously, debug builds would assert (and thus crash), while release builds would have multiple states for the same button, causing (probably) issues like the title bar not being usable (as in, cannot be dragged, buttons not working etc). Hopefully closes #709
2021-09-06 18:12:45 +02:00
LOG_WARN("stray button release event (compositor bug?)");
input: don’t assert when receiving a button release without a press event
2021-01-04 18:32:00 +01:00
return;
}
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
seat->mouse.last_released_button = button;
}
switch (surf_kind) {
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
case TERM_SURF_TITLE:
input: toggle maximized state when double-clicking the title bar
2020-02-29 11:56:16 +01:00
if (state == WL_POINTER_BUTTON_STATE_PRESSED) {
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
struct wl_window *win = term->window;
input: toggle maximized state when double-clicking the title bar
2020-02-29 11:56:16 +01:00
/* Toggle maximized state on double-click */
config: add csd.double-click-to-maximize=no|yes option When enabled, double-clicking the CSD titlebar will (un)maximize the window. Defaults to ‘yes’ (since this is the old hard-coded behavior). Closes #1293
2023-07-14 12:03:35 +02:00
if (term->conf->csd.double_click_to_maximize &&
button == BTN_LEFT &&
seat->mouse.count == 2)
{
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
if (win->is_maximized)
xdg_toplevel_unset_maximized(win->xdg_toplevel);
input: toggle maximized state when double-clicking the title bar
2020-02-29 11:56:16 +01:00
else
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
xdg_toplevel_set_maximized(win->xdg_toplevel);
input: temporary code to trigger maximize/minimize
2020-02-26 13:23:11 +01:00
}
input: toggle maximized state when double-clicking the title bar
2020-02-29 11:56:16 +01:00
input: don’t try to close an invalid FD
2021-01-04 18:32:22 +01:00
else if (button == BTN_LEFT && win->csd.move_timeout_fd < 0) {
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
const struct itimerspec timeout = {
input: raise window 'move' timeout to 200ms 100ms was a bit low and prevented double-tap on touchpads from working.
2020-03-01 13:20:07 +01:00
.it_value = {.tv_nsec = 200000000},
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
};
int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
if (fd >= 0 &&
timerfd_settime(fd, 0, &timeout, NULL) == 0 &&
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
fdm_add(wayl->fdm, fd, EPOLLIN, &fdm_csd_move, seat))
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
{
win->csd.move_timeout_fd = fd;
win->csd.serial = serial;
} else {
LOG_ERRNO("failed to configure XDG toplevel move timer FD");
input: don’t try to close an invalid FD
2021-01-04 18:32:22 +01:00
if (fd >= 0)
close(fd);
input: csd: add a small delay before initiating a move This ensures the user has time to double-click to toggle the maximized state.
2020-02-29 12:52:55 +01:00
}
}
input: Add support for xdg_toplevl.show_window_menu() This makes, if the compositor supports it, the window menu appear when right clicking on the title bar.
2021-11-19 15:08:46 +01:00
if (button == BTN_RIGHT && tll_length(seat->mouse.buttons) == 1) {
input: make csd_data variable ‘const’
2021-11-30 22:15:13 +01:00
const struct csd_data info = get_csd_data(term, CSD_SURF_TITLE);
input: Add support for xdg_toplevl.show_window_menu() This makes, if the compositor supports it, the window menu appear when right clicking on the title bar.
2021-11-19 15:08:46 +01:00
xdg_toplevel_show_window_menu(
win->xdg_toplevel,
seat->wl_seat,
seat->pointer.serial,
seat->mouse.x + info.x, seat->mouse.y + info.y);
}
input: temporary code to trigger maximize/minimize
2020-02-26 13:23:11 +01:00
}
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
else if (state == WL_POINTER_BUTTON_STATE_RELEASED) {
struct wl_window *win = term->window;
input: don’t try to close an invalid FD
2021-01-04 18:32:22 +01:00
if (win->csd.move_timeout_fd >= 0) {
input: start window move right away if user starts dragging the window When the user left-clicks the title-bar, we start a timer. When the timer has elapsed, we initiate a 'move' operation. However, if the user clicked, and then started dragging right away, there was a very visible lag since we waited for the timeout before starting the move. Now, on a pointer motion event we detect a running 'move' timer, and abort it and instead start the 'move' operation right away.
2020-02-29 15:38:04 +01:00
fdm_del(wayl->fdm, win->csd.move_timeout_fd);
win->csd.move_timeout_fd = -1;
}
}
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
return;
case TERM_SURF_BORDER_LEFT:
case TERM_SURF_BORDER_RIGHT:
case TERM_SURF_BORDER_TOP:
case TERM_SURF_BORDER_BOTTOM: {
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
enum xdg_toplevel_resize_edge resize_type = XDG_TOPLEVEL_RESIZE_EDGE_NONE;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
int x = seat->mouse.x;
int y = seat->mouse.y;
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
if (is_top_left(term, x, y))
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT;
else if (is_top_right(term, x, y))
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT;
else if (is_bottom_left(term, x, y))
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT;
else if (is_bottom_right(term, x, y))
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT;
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
else {
if (term->active_surface == TERM_SURF_BORDER_LEFT &&
!term->window->is_constrained_left)
{
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_LEFT;
}
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
wayland+input: add support for toplevel edge constraints Edge constraints are new (not yet available in a wayland-protocols release) toplevel states, acting as a complement to the existing tiled states. Tiled tells us we shouldn't draw shadows etc *outside our window geometry*. Constrained tells us the window cannot be resized in the constrained direction. This patch does a couple of things: * Recognize the new states when debug logging * Change is_top_left() etc to look at the new constrained state instead of the tiled state. These functions are used when both choosing cursor shape, and when determining if/how to resize a window on a CSD edge click-and-drag. * Update cursor shape selection to use the default (left_ptr) shape when on a constrained edge (or corner). * Update CSD resize triggering, to not trigger a resize when attempted on a constrained edge (or corner). See https://gitlab.freedesktop.org/wayland/wayland-protocols/-/commit/86750c99ed062c306e837f11bb9492df572ad677: An edge constraint is an complementery state to the tiled state, meaning that it's not only tiled, but constrained in a way that it can't resize in that direction. This typically means that the constrained edge is tiled against a monitor edge. An example configuration is two windows tiled next to each other on a single monitor. Together they cover the whole work area. The left window would have the following tiled and edge constraint state: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_left ] while the right window would have the following: [ tiled_top, tiled_right, tiled_bottom, tiled_left, constrained_top, constrained_bottom, constrained_right ] This aims to replace and deprecate the `gtk_surface1.configure_edges` event and the `gtk_surface1.edge_constraint` enum.
2025-04-07 13:32:30 +02:00
else if (term->active_surface == TERM_SURF_BORDER_RIGHT &&
!term->window->is_constrained_right)
{
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT;
}
else if (term->active_surface == TERM_SURF_BORDER_TOP &&
!term->window->is_constrained_top)
{
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_TOP;
}
else if (term->active_surface == TERM_SURF_BORDER_BOTTOM &&
!term->window->is_constrained_bottom)
{
resize_type = XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM;
}
}
if (resize_type != XDG_TOPLEVEL_RESIZE_EDGE_NONE) {
xdg_toplevel_resize(
term->window->xdg_toplevel, seat->wl_seat, serial, resize_type);
}
input: handle CSD border corners correctly That is, change to correct cursor, and do resize correctly.
2020-02-29 09:32:22 +01:00
}
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
return;
}
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
case TERM_SURF_BUTTON_MINIMIZE:
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
if (button == BTN_LEFT &&
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
pointer_is_on_button(term, seat, CSD_SURF_MINIMIZE) &&
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
state == WL_POINTER_BUTTON_STATE_RELEASED)
{
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
xdg_toplevel_set_minimized(term->window->xdg_toplevel);
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
}
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
break;
case TERM_SURF_BUTTON_MAXIMIZE:
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
if (button == BTN_LEFT &&
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
pointer_is_on_button(term, seat, CSD_SURF_MAXIMIZE) &&
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
state == WL_POINTER_BUTTON_STATE_RELEASED)
{
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
if (term->window->is_maximized)
xdg_toplevel_unset_maximized(term->window->xdg_toplevel);
else
xdg_toplevel_set_maximized(term->window->xdg_toplevel);
}
break;
case TERM_SURF_BUTTON_CLOSE:
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
if (button == BTN_LEFT &&
csd: track pointer when rendering and handling CSD button clicks * Render button as highlighted only when pointer is above them * Releasing the mouse button while *not* on the button does *not* activate the button When pressing, and holding, a mouse button, the compositor keeps sending motion events for the surface where the button was pressed, even if the mouse has moved outside it. We also don't get any surface leave/enter events. This meant that the button was rendered as highlighted, and a click registered, if the user pressed the mouse button while on the button, and then moved the cursor away from the button before releasing the button. This patch fixes it, by checking if the current cursor coordinates fall within the button surface.
2024-08-09 08:20:59 +02:00
pointer_is_on_button(term, seat, CSD_SURF_CLOSE) &&
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
state == WL_POINTER_BUTTON_STATE_RELEASED)
{
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
term_shutdown(term);
input: CSD buttons are now triggered when releasing the mouse button This is how most UIs work. Note that we (at least on River) don't get any surface enter/leave events while a button is held. This means we can't detect if the user pressed the mouse button while on a CSD button, but then moves the mouse outside. Releasing the mouse button will still activate the CSD button. Closes #1787
2024-08-02 17:12:12 +02:00
}
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
break;
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_GRID: {
search_cancel(term);
input: exit URLs mode on mouse button events This makes URLs mode behave like scrollback search mode.
2021-03-04 08:57:03 +01:00
urls_reset(term);
input: cleanup
2020-02-29 15:29:00 +01:00
input: button: button events aren't passed to clients, when cursor is outside grid Don't send mouse button escapes to a mouse grabbing client when the cursor is outside the grid (i.e. when it is inside the margins). Also don't do *any* kind of selection when the cursor is outside the grid. Previously, we only checked this for selection_start(), but e.g. double clicking would run selection_extend(), or selection_mark_word() etc.
2020-08-07 19:59:03 +02:00
bool cursor_is_on_grid = seat->mouse.col >= 0 && seat->mouse.row >= 0;
input: cleanup
2020-02-29 15:29:00 +01:00
switch (state) {
case WL_POINTER_BUTTON_STATE_PRESSED: {
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
bool consumed = false;
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +02:00
input: don’t execute mouse bindings when the application is grabbing the mouse When the application is grabbing the mouse, we require ‘shift’ to be pressed to be able to use foot’s mouse bindings. Otherwise the mouse event is sent to the application. This wasn’t being enforced consistently; each and every mouse **only** action was checking the mouse grab state, but e.g. *primary paste* (which can be used as both a key binding and a mouse binding) was not. The fix is actually quite simple: don’t even try to execute *any* mouse bindings when the application is grabbing the mouse (unless shift is pressed). This fixes an issue where e.g. middle mouse button events (using the default mouse bindings) were never seen by any mouse grabbing client applications.
2021-02-02 09:52:05 +01:00
if (cursor_is_on_grid && term_mouse_grabbed(term, seat)) {
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
const struct key_binding *match =
match_mouse_binding(seat, term, button);
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +02:00
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
if (match != NULL)
consumed = execute_binding(seat, term, match, serial, 1);
input: regression: don’t pass on mouse click to application if we consumed it When we ‘consume’ a mouse button event (i.e. when we have a shortcut mapped to it), the event should *not* be passed on to the client application. In 5f64c5c33590a41afd3f621870c6abd89b859073, button handling was refactored and unfortunately introduced a regression where we once again started passing consumed button presses to the client application. Fixes #168
2020-10-13 08:02:09 +02:00
}
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
send_to_client = !consumed && cursor_is_on_grid;
if (send_to_client)
tll_back(seat->mouse.buttons).send_to_client = true;
if (send_to_client &&
input: regression: don’t pass on mouse click to application if we consumed it When we ‘consume’ a mouse button event (i.e. when we have a shortcut mapped to it), the event should *not* be passed on to the client application. In 5f64c5c33590a41afd3f621870c6abd89b859073, button handling was refactored and unfortunately introduced a regression where we once again started passing consumed button presses to the client application. Fixes #168
2020-10-13 08:02:09 +02:00
!term_mouse_grabbed(term, seat) &&
cursor_is_on_grid)
{
term_mouse_down(
term, button, seat->mouse.row, seat->mouse.col,
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
seat->mouse.y - term->margins.top,
seat->mouse.x - term->margins.left,
input: regression: don’t pass on mouse click to application if we consumed it When we ‘consume’ a mouse button event (i.e. when we have a shortcut mapped to it), the event should *not* be passed on to the client application. In 5f64c5c33590a41afd3f621870c6abd89b859073, button handling was refactored and unfortunately introduced a regression where we once again started passing consumed button presses to the client application. Fixes #168
2020-10-13 08:02:09 +02:00
seat->kbd.shift, seat->kbd.alt, seat->kbd.ctrl);
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
}
input: cleanup
2020-02-29 15:29:00 +01:00
break;
}
selection/input: triple click selects an entire row
2019-08-06 19:32:06 +02:00
input: cleanup
2020-02-29 15:29:00 +01:00
case WL_POINTER_BUTTON_STATE_RELEASED:
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
selection_finalize(seat, term, serial);
selection/input: triple click selects an entire row
2019-08-06 19:32:06 +02:00
input: rework mouse button/motion handling Store a list of currently pressed buttons, and which surface they belong to (i.e. which surface that received the press). Then, in motion events (with a button pressed, aka drag operations), send the event to the “original” surface (that received the press). Also send release events to the originating surface. This means a surface receiving a press will always receive a corresponding release. And no one will receive a release event without a corresponding press event. Motion events with a button pressed will *always* use the *first* button that was pressed. I.e. if you press a button, start dragging, and then press another button, we keep generating motion events for the *first* button.
2020-12-12 19:05:24 +01:00
if (send_to_client && !term_mouse_grabbed(term, seat)) {
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
term_mouse_up(
term, button, seat->mouse.row, seat->mouse.col,
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
seat->mouse.y - term->margins.top,
seat->mouse.x - term->margins.left,
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
seat->kbd.shift, seat->kbd.alt, seat->kbd.ctrl);
}
input: cleanup
2020-02-29 15:29:00 +01:00
break;
selection: add selection_from_primary() API (stub for now)
2019-07-11 16:42:59 +02:00
}
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
break;
selection: implement double-click-to-select-word
2019-07-17 21:30:57 +02:00
}
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_NONE:
Convert all but 2 remaining uses of xassert(false) to BUG("...")
2021-02-10 09:01:51 +00:00
BUG("Invalid surface type");
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
break;
input: cleanup
2020-02-29 15:29:00 +01:00
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
}
input: mouse events
2019-07-05 10:44:57 +02:00
}
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
static void
alternate_scroll(struct seat *seat, int amount, int button)
{
if (seat->wl_keyboard == NULL)
return;
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
/* Should be cleared in leave event */
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(seat->mouse_focus != NULL);
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
struct terminal *term = seat->mouse_focus;
input: clean up mouse scroll handling * Allow scrolling on the normal (non-alt) screen, when application is grabbing the mouse (when user presses Shift). * Use term_mouse_grabbed() instead of explicitly checking for MOUSE_NONE tracking. * Remove mouse tracking check from cmd_scrollback_{up,down}. Caller is expected to have done the check. * Don’t scroll down on mouse wheel tilt events.
2021-10-25 19:39:46 +02:00
assert(button == BTN_BACK || button == BTN_FORWARD);
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
xkb_keycode_t key = button == BTN_BACK
? seat->kbd.key_arrow_up : seat->kbd.key_arrow_down;
for (int i = 0; i < amount; i++)
input: don’t use seat->kbd_focus as terminal when processing a key press When converting mouse scroll events to keyboard input (in alternate scroll mode), we need to use seat->mouse_focus, not seat->kbd_focus. To enable this, break out key press/release handling code to a separate function that takes an explicit term argument. Call this function from keyboard_key(), input_repeat() and in alternate scroll mode. Closes #179
2020-11-03 19:44:51 +01:00
key_press_release(seat, term, seat->kbd.serial, key, XKB_KEY_DOWN);
key_press_release(seat, term, seat->kbd.serial, key, XKB_KEY_UP);
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
}
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
static void
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
mouse_scroll(struct seat *seat, int amount, enum wl_pointer_axis axis)
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct terminal *term = seat->mouse_focus;
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(term != NULL);
wayland: change all wayland callbacks to take a wayland pointer Instead of passing the terminal to the wayland callbacks, pass a 'struct wayland' pointer.
2019-10-27 18:43:07 +01:00
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
int button = axis == WL_POINTER_AXIS_VERTICAL_SCROLL
input: don't map wheel events to BTN_{BACK,FORWARD} BTN_BACK and BTN_FORWARD are separate buttons. The scroll wheel don't have any button mappings in libinput/wayland, so make up our own defines. This allows us to map them in mouse bindings. Also expose BTN_WHEEL_{LEFT,RIGHT}. These were already defined, and used, internally, to handle wheel tilt events. With this, they can also be used in mouse bindings. Finally, fix encoding used for BTN_{BACK,FORWARD} when sending mouse button events to the client application. Before this, they were mapped to buttons 4/5. But, button 4/5 are for the scroll wheel, and as mentioned above, BTN_{BACK,FORWARD} are not the same as scroll wheel "buttons". Closes #1763
2024-07-13 10:24:11 +02:00
? amount < 0 ? BTN_WHEEL_BACK : BTN_WHEEL_FORWARD
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
: amount < 0 ? BTN_WHEEL_LEFT : BTN_WHEEL_RIGHT;
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
amount = abs(amount);
input: clean up mouse scroll handling * Allow scrolling on the normal (non-alt) screen, when application is grabbing the mouse (when user presses Shift). * Use term_mouse_grabbed() instead of explicitly checking for MOUSE_NONE tracking. * Remove mouse tracking check from cmd_scrollback_{up,down}. Caller is expected to have done the check. * Don’t scroll down on mouse wheel tilt events.
2021-10-25 19:39:46 +02:00
if (term_mouse_grabbed(term, seat)) {
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
seat->mouse.count = 1;
input: clean up mouse scroll handling * Allow scrolling on the normal (non-alt) screen, when application is grabbing the mouse (when user presses Shift). * Use term_mouse_grabbed() instead of explicitly checking for MOUSE_NONE tracking. * Remove mouse tracking check from cmd_scrollback_{up,down}. Caller is expected to have done the check. * Don’t scroll down on mouse wheel tilt events.
2021-10-25 19:39:46 +02:00
input: make wheel events mappable Un-grabbed wheel events are now passed through the mouse binding matching logic, instead of being hardcoded to scrolling the terminal contents. They are mappable through the BTN_BACK and BTN_FORWARD buttons. Since they're not actually button *presses*, they never generate a click count other than 1. This limitation is documented, but not checked in the config. This means it's possible to create bindings like "BTN_BACK+3" (i.e. triple "click"). They will however never trigger. The old, hardcoded logic is now accessible through the new scrollback-up-mouse and scrollback-down-mouse mouse bindings. They (obiously) default to BTN_BACK and BTN_FORWARD, respectively. Example usage: keep the default of scrolling terminal contents with the wheel, when used without modifiers, but map Control+wheel to font zoom in/out: [mouse-bindings] font-increase=Control+BTN_FORWARD font-decrease=Control+BTN_BACK (this also keeps the default key bindings to zoom in/out; ctrl-+ and ctrl+-) Closes #1077
2023-09-18 16:36:39 +02:00
const struct key_binding *match =
match_mouse_binding(seat, term, button);
if (match != NULL)
execute_binding(seat, term, match, seat->pointer.serial, amount);
seat->mouse.last_released_button = button;
input: clean up mouse scroll handling * Allow scrolling on the normal (non-alt) screen, when application is grabbing the mouse (when user presses Shift). * Use term_mouse_grabbed() instead of explicitly checking for MOUSE_NONE tracking. * Remove mouse tracking check from cmd_scrollback_{up,down}. Caller is expected to have done the check. * Don’t scroll down on mouse wheel tilt events.
2021-10-25 19:39:46 +02:00
}
else if (seat->mouse.col >= 0 && seat->mouse.row >= 0) {
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(seat->mouse.col < term->cols);
xassert(seat->mouse.row < term->rows);
input: scrolling: don't send events to client if cursor is outside grid
2020-08-07 22:07:16 +02:00
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
for (int i = 0; i < amount; i++) {
term_mouse_down(
multi-seat: re-enable mouse button+motion reporting support
2020-07-08 18:16:43 +02:00
term, button, seat->mouse.row, seat->mouse.col,
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
seat->mouse.y - term->margins.top,
seat->mouse.x - term->margins.left,
multi-seat: re-enable mouse button+motion reporting support
2020-07-08 18:16:43 +02:00
seat->kbd.shift, seat->kbd.alt, seat->kbd.ctrl);
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
}
term_mouse_up(
term, button, seat->mouse.row, seat->mouse.col,
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
seat->mouse.y - term->margins.top,
seat->mouse.x - term->margins.left,
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
seat->kbd.shift, seat->kbd.alt, seat->kbd.ctrl);
csi: implement CSI ? 1007 h/l - alternateScroll When enabled, mouse scrolls in the alternate screen are converted to up/down key presses.
2019-08-19 21:16:47 +02:00
}
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
}
input: implement wl_pointer::axis_value120() This implements high resolution mouse wheel scroll events. A "normal" scroll step corresponds to the value 120. Anything less than that is a partial scroll step. This event replaces axis_discrete(), when we bind wl_seat v8 (which we now do, when available). We calculate the number of degrees that is required to scroll a single line, based off of the scrollback.multiplier value. Each high-res event accumulates, until we have at least the number of degress required to scroll one, or more lines. The remaining degrees are kept, and added to in the next scroll event. Closes #1738
2024-06-15 10:17:01 +02:00
static double
input: apply scrollback.multplier in alterate scroll mode Before this patch, foot only applied [scrollback].multiplier on the normal screen, never the alt screen. However, scrolling can be done in two ways on the alt screen: If the application has enabled mouse support, we simply pass on the mouse scroll events to the application. Here, it makes sense to not apply the multiplier, and instead let the application choose how much to scroll for each scroll event. But, if the application has not enabled mouse support, we can still scroll by simulating the arrow keys being pressed - alternate scrolling (private mode 1007). This is enabled by default in foot (but can be disabled in foot.ini with the [mouse].alternate-scroll-mode setting). In this mode, it makes more sense to apply the multiplier. And that’s what this patch changes - the multiplier is now applied, on the alt screen, when the application has not enabled mouse support, and alternate scrolling has been enabled in foot. Closes #859
2021-12-24 15:22:14 +01:00
mouse_scroll_multiplier(const struct terminal *term, const struct seat *seat)
input: don’t apply [scrollback].multiplier when alt screen is in use Closes #787
2021-11-08 18:41:42 +01:00
{
input: apply scrollback.multplier in alterate scroll mode Before this patch, foot only applied [scrollback].multiplier on the normal screen, never the alt screen. However, scrolling can be done in two ways on the alt screen: If the application has enabled mouse support, we simply pass on the mouse scroll events to the application. Here, it makes sense to not apply the multiplier, and instead let the application choose how much to scroll for each scroll event. But, if the application has not enabled mouse support, we can still scroll by simulating the arrow keys being pressed - alternate scrolling (private mode 1007). This is enabled by default in foot (but can be disabled in foot.ini with the [mouse].alternate-scroll-mode setting). In this mode, it makes more sense to apply the multiplier. And that’s what this patch changes - the multiplier is now applied, on the alt screen, when the application has not enabled mouse support, and alternate scrolling has been enabled in foot. Closes #859
2021-12-24 15:22:14 +01:00
return (term->grid == &term->normal ||
(term_mouse_grabbed(term, seat) && term->alt_scrolling))
input: don’t apply [scrollback].multiplier when alt screen is in use Closes #787
2021-11-08 18:41:42 +01:00
? term->conf->scrollback.multiplier
: 1.0;
}
input: mouse events
2019-07-05 10:44:57 +02:00
static void
wl_pointer_axis(void *data, struct wl_pointer *wl_pointer,
uint32_t time, uint32_t axis, wl_fixed_t value)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
wayland: change all wayland callbacks to take a wayland pointer Instead of passing the terminal to the wayland callbacks, pass a 'struct wayland' pointer.
2019-10-27 18:43:07 +01:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
if (seat->mouse.have_discrete)
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
return;
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(seat->mouse_focus != NULL);
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
xassert(axis < ALEN(seat->mouse.aggregated));
input: trackpad scroll: correctly convert pixel movements to line movements Trackpad scroll movements are in pixels. Foot previously “translated” these directly to line movements (i.e. a one pixel scroll event was translated into a one line scroll). Now we use the line height of the terminal and correctly convert pixels to lines. This makes the trackpad scroll speed in foot consistent with the scroll speed in e.g. Alacritty and Kitty.
2020-09-27 11:11:45 +02:00
input: apply scrollback.multplier in alterate scroll mode Before this patch, foot only applied [scrollback].multiplier on the normal screen, never the alt screen. However, scrolling can be done in two ways on the alt screen: If the application has enabled mouse support, we simply pass on the mouse scroll events to the application. Here, it makes sense to not apply the multiplier, and instead let the application choose how much to scroll for each scroll event. But, if the application has not enabled mouse support, we can still scroll by simulating the arrow keys being pressed - alternate scrolling (private mode 1007). This is enabled by default in foot (but can be disabled in foot.ini with the [mouse].alternate-scroll-mode setting). In this mode, it makes more sense to apply the multiplier. And that’s what this patch changes - the multiplier is now applied, on the alt screen, when the application has not enabled mouse support, and alternate scrolling has been enabled in foot. Closes #859
2021-12-24 15:22:14 +01:00
const struct terminal *term = seat->mouse_focus;
input: slow trackpad scrolling now eventually scroll a line Before, we converted each axis event's scroll amount to an integer and scrolled that many lines. However, axis events are speed sensitive - very slow scrolling will result in events with a scroll amount that is < 1.0. For us, this meant we never scrolled a single line. You could slow scroll all day if you wanted, and still we would never scroll a single line. Fix this by aggregating the scroll amount from axis events until the scroll amount is > 1.0, and then scroll.
2020-04-10 18:43:29 +02:00
/*
* Aggregate scrolled amount until we get at least 1.0
*
* Without this, very slow scrolling will never actually scroll
* anything.
*/
input: don’t apply [scrollback].multiplier when alt screen is in use Closes #787
2021-11-08 18:41:42 +01:00
seat->mouse.aggregated[axis] +=
input: apply scrollback.multplier in alterate scroll mode Before this patch, foot only applied [scrollback].multiplier on the normal screen, never the alt screen. However, scrolling can be done in two ways on the alt screen: If the application has enabled mouse support, we simply pass on the mouse scroll events to the application. Here, it makes sense to not apply the multiplier, and instead let the application choose how much to scroll for each scroll event. But, if the application has not enabled mouse support, we can still scroll by simulating the arrow keys being pressed - alternate scrolling (private mode 1007). This is enabled by default in foot (but can be disabled in foot.ini with the [mouse].alternate-scroll-mode setting). In this mode, it makes more sense to apply the multiplier. And that’s what this patch changes - the multiplier is now applied, on the alt screen, when the application has not enabled mouse support, and alternate scrolling has been enabled in foot. Closes #859
2021-12-24 15:22:14 +01:00
mouse_scroll_multiplier(term, seat) * wl_fixed_to_double(value);
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
if (fabs(seat->mouse.aggregated[axis]) < seat->mouse_focus->cell_height)
input: trackpad scroll: correctly convert pixel movements to line movements Trackpad scroll movements are in pixels. Foot previously “translated” these directly to line movements (i.e. a one pixel scroll event was translated into a one line scroll). Now we use the line height of the terminal and correctly convert pixels to lines. This makes the trackpad scroll speed in foot consistent with the scroll speed in e.g. Alacritty and Kitty.
2020-09-27 11:11:45 +02:00
return;
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
int lines = seat->mouse.aggregated[axis] / seat->mouse_focus->cell_height;
mouse_scroll(seat, lines, axis);
seat->mouse.aggregated[axis] -= (double)lines * seat->mouse_focus->cell_height;
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
}
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
static void
wl_pointer_axis_discrete(void *data, struct wl_pointer *wl_pointer,
input: implement wl_pointer::axis_value120() This implements high resolution mouse wheel scroll events. A "normal" scroll step corresponds to the value 120. Anything less than that is a partial scroll step. This event replaces axis_discrete(), when we bind wl_seat v8 (which we now do, when available). We calculate the number of degrees that is required to scroll a single line, based off of the scrollback.multiplier value. Each high-res event accumulates, until we have at least the number of degress required to scroll one, or more lines. The remaining degrees are kept, and added to in the next scroll event. Closes #1738
2024-06-15 10:17:01 +02:00
enum wl_pointer_axis axis, int32_t discrete)
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
{
input: implement wl_pointer::axis_value120() This implements high resolution mouse wheel scroll events. A "normal" scroll step corresponds to the value 120. Anything less than that is a partial scroll step. This event replaces axis_discrete(), when we bind wl_seat v8 (which we now do, when available). We calculate the number of degrees that is required to scroll a single line, based off of the scrollback.multiplier value. Each high-res event accumulates, until we have at least the number of degress required to scroll one, or more lines. The remaining degrees are kept, and added to in the next scroll event. Closes #1738
2024-06-15 10:17:01 +02:00
LOG_DBG("axis_discrete: %d", discrete);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.have_discrete = true;
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
int amount = discrete;
if (axis == WL_POINTER_AXIS_HORIZONTAL_SCROLL) {
/* Treat mouse wheel left/right as regular buttons */
} else
input: apply scrollback.multplier in alterate scroll mode Before this patch, foot only applied [scrollback].multiplier on the normal screen, never the alt screen. However, scrolling can be done in two ways on the alt screen: If the application has enabled mouse support, we simply pass on the mouse scroll events to the application. Here, it makes sense to not apply the multiplier, and instead let the application choose how much to scroll for each scroll event. But, if the application has not enabled mouse support, we can still scroll by simulating the arrow keys being pressed - alternate scrolling (private mode 1007). This is enabled by default in foot (but can be disabled in foot.ini with the [mouse].alternate-scroll-mode setting). In this mode, it makes more sense to apply the multiplier. And that’s what this patch changes - the multiplier is now applied, on the alt screen, when the application has not enabled mouse support, and alternate scrolling has been enabled in foot. Closes #859
2021-12-24 15:22:14 +01:00
amount *= mouse_scroll_multiplier(seat->mouse_focus, seat);
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
mouse_scroll(seat, amount, axis);
input: mouse events
2019-07-05 10:44:57 +02:00
}
input: implement wl_pointer::axis_value120() This implements high resolution mouse wheel scroll events. A "normal" scroll step corresponds to the value 120. Anything less than that is a partial scroll step. This event replaces axis_discrete(), when we bind wl_seat v8 (which we now do, when available). We calculate the number of degrees that is required to scroll a single line, based off of the scrollback.multiplier value. Each high-res event accumulates, until we have at least the number of degress required to scroll one, or more lines. The remaining degrees are kept, and added to in the next scroll event. Closes #1738
2024-06-15 10:17:01 +02:00
#if defined(WL_POINTER_AXIS_VALUE120_SINCE_VERSION)
static void
wl_pointer_axis_value120(void *data, struct wl_pointer *wl_pointer,
enum wl_pointer_axis axis, int32_t value120)
{
LOG_DBG("axis_value120: %d -> %.2f", value120, (float)value120 / 120.);
struct seat *seat = data;
if (touch_is_active(seat))
return;
seat->mouse.have_discrete = true;
/*
* 120 corresponds to a single "low-res" scroll step.
*
* When doing high-res scrolling, take the scrollback.multiplier,
* and calculate how many degrees there are per line.
*
* For example, with scrollback.multiplier = 3, we have 120 / 3 == 40.
*
* Then, accumulate high-res scroll events, until we have *at
* least* that much. Translate the accumulated value to number of
* lines, and scroll.
*
* Subtract the "used" degrees from the accumulated value, and
* keep what's left (this value will always be less than the
* per-line value).
*/
const double multiplier = mouse_scroll_multiplier(seat->mouse_focus, seat);
const double per_line = 120. / multiplier;
seat->mouse.aggregated_120[axis] += (double)value120;
if (fabs(seat->mouse.aggregated_120[axis]) < per_line)
return;
int lines = (int)(seat->mouse.aggregated_120[axis] / per_line);
mouse_scroll(seat, lines, axis);
seat->mouse.aggregated_120[axis] -= (double)lines * per_line;
}
#endif
input: mouse events
2019-07-05 10:44:57 +02:00
static void
wl_pointer_frame(void *data, struct wl_pointer *wl_pointer)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
seat->mouse.have_discrete = false;
input: mouse events
2019-07-05 10:44:57 +02:00
}
static void
wl_pointer_axis_source(void *data, struct wl_pointer *wl_pointer,
uint32_t axis_source)
{
}
static void
wl_pointer_axis_stop(void *data, struct wl_pointer *wl_pointer,
uint32_t time, uint32_t axis)
{
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
struct seat *seat = data;
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
if (touch_is_active(seat))
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
return;
input: implement support for mouse wheel left/right We now emit button 6/7 events (when the client application grabs the mouse). This buttons map to mouse wheel horizontal scroll events. Or, left/right tilting, if you like. Wayland report these as ‘axis’ events (just like regular scroll wheel events), and thus we need to translate those scroll events to button events. libinput does not define any mouse buttons for wheel tilts, so we add our own defitions. These are added last in the BTN_* range, just before the BTN_JOYSTICK events.
2021-08-05 18:34:09 +02:00
xassert(axis < ALEN(seat->mouse.aggregated));
seat->mouse.aggregated[axis] = 0.;
input: mouse events
2019-07-05 10:44:57 +02:00
}
const struct wl_pointer_listener pointer_listener = {
input: implement wl_pointer::axis_value120() This implements high resolution mouse wheel scroll events. A "normal" scroll step corresponds to the value 120. Anything less than that is a partial scroll step. This event replaces axis_discrete(), when we bind wl_seat v8 (which we now do, when available). We calculate the number of degrees that is required to scroll a single line, based off of the scrollback.multiplier value. Each high-res event accumulates, until we have at least the number of degress required to scroll one, or more lines. The remaining degrees are kept, and added to in the next scroll event. Closes #1738
2024-06-15 10:17:01 +02:00
.enter = &wl_pointer_enter,
.leave = &wl_pointer_leave,
.motion = &wl_pointer_motion,
.button = &wl_pointer_button,
.axis = &wl_pointer_axis,
.frame = &wl_pointer_frame,
.axis_source = &wl_pointer_axis_source,
.axis_stop = &wl_pointer_axis_stop,
.axis_discrete = &wl_pointer_axis_discrete,
#if defined(WL_POINTER_AXIS_VALUE120_SINCE_VERSION)
.axis_value120 = &wl_pointer_axis_value120,
#endif
input: mouse events
2019-07-05 10:44:57 +02:00
};
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
static bool
touch_to_scroll(struct seat *seat, struct terminal *term,
wl_fixed_t surface_x, wl_fixed_t surface_y)
{
bool coord_updated = false;
int y = wl_fixed_to_int(surface_y) * term->scale;
int rows = (y - seat->mouse.y) / term->cell_height;
if (rows != 0) {
mouse_scroll(seat, -rows, WL_POINTER_AXIS_VERTICAL_SCROLL);
seat->mouse.y += rows * term->cell_height;
coord_updated = true;
}
int x = wl_fixed_to_int(surface_x) * term->scale;
int cols = (x - seat->mouse.x) / term->cell_width;
if (cols != 0) {
mouse_scroll(seat, -cols, WL_POINTER_AXIS_HORIZONTAL_SCROLL);
seat->mouse.x += cols * term->cell_width;
coord_updated = true;
}
return coord_updated;
}
static void
wl_touch_down(void *data, struct wl_touch *wl_touch, uint32_t serial,
uint32_t time, struct wl_surface *surface, int32_t id,
wl_fixed_t surface_x, wl_fixed_t surface_y)
{
struct seat *seat = data;
if (seat->touch.state != TOUCH_STATE_IDLE)
return;
struct wl_window *win = wl_surface_get_user_data(surface);
struct terminal *term = win->term;
LOG_DBG("touch_down: touch=%p, x=%d, y=%d", (void *)wl_touch,
wl_fixed_to_int(surface_x), wl_fixed_to_int(surface_y));
int x = wl_fixed_to_int(surface_x) * term->scale;
int y = wl_fixed_to_int(surface_y) * term->scale;
seat->mouse.x = x;
seat->mouse.y = y;
mouse_coord_pixel_to_cell(seat, term, x, y);
seat->touch.state = TOUCH_STATE_HELD;
seat->touch.serial = serial;
seat->touch.time = time + term->conf->touch.long_press_delay;
seat->touch.surface = surface;
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
seat->touch.surface_kind = term_surface_kind(term, surface);
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
seat->touch.id = id;
}
static void
wl_touch_up(void *data, struct wl_touch *wl_touch, uint32_t serial,
uint32_t time, int32_t id)
{
struct seat *seat = data;
if (seat->touch.state <= TOUCH_STATE_IDLE || id != seat->touch.id)
return;
LOG_DBG("touch_up: touch=%p", (void *)wl_touch);
struct wl_window *win = wl_surface_get_user_data(seat->touch.surface);
struct terminal *term = win->term;
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
struct terminal *old_term = seat->mouse_focus;
enum term_surface old_active_surface = term->active_surface;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
seat->mouse_focus = term;
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
term->active_surface = seat->touch.surface_kind;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
switch (seat->touch.state) {
case TOUCH_STATE_HELD:
wl_pointer_button(seat, NULL, seat->touch.serial, time, BTN_LEFT,
WL_POINTER_BUTTON_STATE_PRESSED);
/* fallthrough */
case TOUCH_STATE_DRAGGING:
wl_pointer_button(seat, NULL, serial, time, BTN_LEFT,
WL_POINTER_BUTTON_STATE_RELEASED);
/* fallthrough */
case TOUCH_STATE_SCROLLING:
input: do not ignore touch events on the CSDs
2023-07-16 17:24:55 +08:00
term->active_surface = TERM_SURF_NONE;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
seat->touch.state = TOUCH_STATE_IDLE;
break;
case TOUCH_STATE_INHIBITED:
case TOUCH_STATE_IDLE:
BUG("Bad touch state: %d", seat->touch.state);
break;
}
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
seat->mouse_focus = old_term;
term->active_surface = old_active_surface;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
}
static void
wl_touch_motion(void *data, struct wl_touch *wl_touch, uint32_t time,
int32_t id, wl_fixed_t surface_x, wl_fixed_t surface_y)
{
struct seat *seat = data;
if (seat->touch.state <= TOUCH_STATE_IDLE || id != seat->touch.id)
return;
LOG_DBG("touch_motion: touch=%p, x=%d, y=%d", (void *)wl_touch,
wl_fixed_to_int(surface_x), wl_fixed_to_int(surface_y));
struct wl_window *win = wl_surface_get_user_data(seat->touch.surface);
struct terminal *term = win->term;
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
struct terminal *old_term = seat->mouse_focus;
enum term_surface old_active_surface = term->active_surface;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
seat->mouse_focus = term;
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
term->active_surface = seat->touch.surface_kind;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
switch (seat->touch.state) {
case TOUCH_STATE_HELD:
input: do not ignore touch events on the CSDs
2023-07-16 17:24:55 +08:00
if (time <= seat->touch.time && term->active_surface == TERM_SURF_GRID) {
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
if (touch_to_scroll(seat, term, surface_x, surface_y))
seat->touch.state = TOUCH_STATE_SCROLLING;
break;
} else {
wl_pointer_button(seat, NULL, seat->touch.serial, time, BTN_LEFT,
WL_POINTER_BUTTON_STATE_PRESSED);
seat->touch.state = TOUCH_STATE_DRAGGING;
/* fallthrough */
}
case TOUCH_STATE_DRAGGING:
wl_pointer_motion(seat, NULL, time, surface_x, surface_y);
break;
case TOUCH_STATE_SCROLLING:
touch_to_scroll(seat, term, surface_x, surface_y);
break;
case TOUCH_STATE_INHIBITED:
case TOUCH_STATE_IDLE:
BUG("Bad touch state: %d", seat->touch.state);
break;
}
input: improve touch handling on pointer presense No longer inhibits touch event handling when terminal window has pointer focus. Instead, inhibit touch event when at least one pointer button is held down. This change improves user experience when using foot with both a mouse and a touchscreen. Closes #1428.
2023-08-19 23:01:53 +08:00
seat->mouse_focus = old_term;
term->active_surface = old_active_surface;
input: add basic support for touchscreen input Closes #517
2023-07-05 00:19:21 +08:00
}
static void
wl_touch_frame(void *data, struct wl_touch *wl_touch)
{
}
static void
wl_touch_cancel(void *data, struct wl_touch *wl_touch)
{
struct seat *seat = data;
if (seat->touch.state == TOUCH_STATE_INHIBITED)
return;
seat->touch.state = TOUCH_STATE_IDLE;
}
const struct wl_touch_listener touch_listener = {
.down = wl_touch_down,
.up = wl_touch_up,
.motion = wl_touch_motion,
.frame = wl_touch_frame,
.cancel = wl_touch_cancel,
};
Reference in a new issue Copy permalink