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

1918 lines
64 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>
wip: initial input handling
2019-06-19 10:04:47 +02:00
#include <sys/mman.h>
selection: implement double-click-to-select-word
2019-07-17 21:30:57 +02:00
#include <sys/time.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"
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
#include "config.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"
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"
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"
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"
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
#include "xmalloc.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;
assert(events & EPOLLOUT);
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;
}
assert(written <= ctx->left);
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: 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,
config: tokenize key bindings' pipe command when loading the configuration This allows us to detect syntax errors early on, and is also more efficient since we don't have to re-tokenize the command line every time the binding is executed.
2020-07-30 18:53:51 +02:00
enum bind_action_normal action, char *const *pipe_argv,
input: wip: initial support for piping scrollback/view to external tools
2020-07-15 13:34:32 +02:00
uint32_t 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
{
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
const bool cursor_is_on_grid = seat->mouse.col >= 0 && seat->mouse.row >= 0;
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
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: 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
cmd_scrollback_up(term, term->rows);
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
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:
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
cmd_scrollback_up(term, max(term->rows / 2, 1));
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_LINE:
cmd_scrollback_up(term, 1);
return true;
case BIND_ACTION_SCROLLBACK_DOWN_PAGE:
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
cmd_scrollback_down(term, term->rows);
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
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:
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
cmd_scrollback_down(term, max(term->rows / 2, 1));
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_DOWN_LINE:
cmd_scrollback_down(term, 1);
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_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: 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:
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:
case BIND_ACTION_PIPE_SELECTED: {
config: tokenize key bindings' pipe command when loading the configuration This allows us to detect syntax errors early on, and is also more efficient since we don't have to re-tokenize the command line every time the binding is executed.
2020-07-30 18:53:51 +02:00
if (pipe_argv == 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;
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;
default:
assert(false);
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;
}
}
config: tokenize key bindings' pipe command when loading the configuration This allows us to detect syntax errors early on, and is also more efficient since we don't have to re-tokenize the command line every time the binding is executed.
2020-07-30 18:53:51 +02:00
if (!spawn(term->reaper, NULL, pipe_argv, pipe_fd[0], stdout_fd, stderr_fd))
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
}
input: bindings: calculate 'cursor_is_on_grid' once only
2020-08-11 10:53:21 +02:00
case BIND_ACTION_SELECT_BEGIN:
input: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +02:00
if (selection_enabled(term, seat) && cursor_is_on_grid) {
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_NORMAL);
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: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +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: 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: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +02:00
if (selection_enabled(term, seat) && cursor_is_on_grid) {
selection_start(
term, seat->mouse.col, seat->mouse.row, SELECTION_BLOCK);
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: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +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_EXTEND:
config: mouse bindings: add select-begin-block and select-row
2020-08-11 10:17:19 +02:00
if (selection_enabled(term, seat) && cursor_is_on_grid) {
selection_extend(
seat, term, seat->mouse.col, seat->mouse.row, 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;
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: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +02:00
if (selection_enabled(term, seat) && cursor_is_on_grid) {
selection_mark_word(
seat, term, seat->mouse.col, seat->mouse.row, false, 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;
input: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +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: 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: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +02:00
if (selection_enabled(term, seat) && cursor_is_on_grid) {
selection_mark_word(
seat, term, seat->mouse.col, seat->mouse.row, true, 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;
input: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +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: 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_ROW:
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
if (selection_enabled(term, seat) && cursor_is_on_grid) {
input: mouse-bindings: check selection is enabled/possible and that pointer is on grid We shouldn't start or modify a selection if selection isn't possible (i.e. client application is grabbing the mouse, and user isn't holding Shift). We also shouldn't start or modify a selection if the pointer is outside the grid (updating an ongoing selection on motion events is an exception to this).
2020-08-11 10:42:23 +02:00
selection_mark_row(seat, term, seat->mouse.row, 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;
}
return false;
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:
assert(false);
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
}
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static xkb_mod_mask_t
conf_modifiers_to_mask(const struct seat *seat,
const struct config_key_modifiers *modifiers)
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
{
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
xkb_mod_mask_t mods = 0;
mods |= modifiers->shift << seat->kbd.mod_shift;
mods |= modifiers->ctrl << seat->kbd.mod_ctrl;
mods |= modifiers->alt << seat->kbd.mod_alt;
mods |= modifiers->meta << seat->kbd.mod_meta;
return mods;
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static xkb_keycode_list_t
key_codes_for_xkb_sym(struct xkb_keymap *keymap, xkb_keysym_t sym)
{
xkb_keycode_list_t key_codes = tll_init();
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
/*
* Find all key codes that map to the lower case
* version of the symbol.
*
* This allows us to match bindings in other layouts
* too.
*/
xkb_keysym_t lower_sym = xkb_keysym_to_lower(sym);
struct xkb_state *state = xkb_state_new(keymap);
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
for (xkb_keycode_t code = xkb_keymap_min_keycode(keymap);
code <= xkb_keymap_max_keycode(keymap);
code++)
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
{
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
if (xkb_state_key_get_one_sym(state, code) == lower_sym)
tll_push_back(key_codes, code);
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
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
xkb_state_unref(state);
return key_codes;
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
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_key_binding(struct seat *seat,
const struct config_key_binding_normal *conf_binding)
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
{
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
struct key_binding_normal binding = {
.action = conf_binding->action,
.bind = {
.mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
.sym = conf_binding->sym,
.key_codes = key_codes_for_xkb_sym(
seat->kbd.xkb_keymap, conf_binding->sym),
},
.pipe_argv = conf_binding->pipe.argv,
};
tll_push_back(seat->kbd.bindings.key, binding);
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_key_bindings(const struct config *conf, struct seat *seat)
{
tll_foreach(conf->bindings.key, it)
convert_key_binding(seat, &it->item);
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_search_binding(struct seat *seat,
const struct config_key_binding_search *conf_binding)
{
struct key_binding_search binding = {
.action = conf_binding->action,
.bind = {
.mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
.sym = conf_binding->sym,
.key_codes = key_codes_for_xkb_sym(
seat->kbd.xkb_keymap, conf_binding->sym),
},
};
tll_push_back(seat->kbd.bindings.search, binding);
}
input: key-binding: log error when we fail to translate to XKB symbol
2020-03-18 10:48:42 +01:00
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_search_bindings(const struct config *conf, struct seat *seat)
{
tll_foreach(conf->bindings.search, it)
convert_search_binding(seat, &it->item);
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_mouse_binding(struct seat *seat,
const struct config_mouse_binding *conf_binding)
{
struct mouse_binding binding = {
.action = conf_binding->action,
.mods = conf_modifiers_to_mask(seat, &conf_binding->modifiers),
.button = conf_binding->button,
.count = conf_binding->count,
config: add support for pipe-* actions in mouse bindings Closes #183
2020-11-06 19:29:23 +01:00
.pipe_argv = conf_binding->pipe.argv,
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
};
tll_push_back(seat->mouse.bindings, binding);
}
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
static void
convert_mouse_bindings(const struct config *conf, struct seat *seat)
{
tll_foreach(conf->bindings.mouse, it)
convert_mouse_binding(seat, &it->item);
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
}
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_compose_state != NULL) {
xkb_compose_state_unref(seat->kbd.xkb_compose_state);
seat->kbd.xkb_compose_state = 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_compose_table != NULL) {
xkb_compose_table_unref(seat->kbd.xkb_compose_table);
seat->kbd.xkb_compose_table = 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_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
}
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 != NULL) {
xkb_context_unref(seat->kbd.xkb);
seat->kbd.xkb = 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
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
tll_foreach(seat->kbd.bindings.key, it)
search: replace hard-coded key bindings with "user configurable" ones They aren't really user configurable. At least not yet. However, with this, we now handle raw key codes just like the normal key bindings. Meaning, e.g. ctrl+g, ctrl+a, ctrl+e etc now works while searching with e.g. a russian layout.
2020-03-18 15:30:14 +01:00
tll_free(it->item.bind.key_codes);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
tll_free(seat->kbd.bindings.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
tll_foreach(seat->kbd.bindings.search, it)
search: replace hard-coded key bindings with "user configurable" ones They aren't really user configurable. At least not yet. However, with this, we now handle raw key codes just like the normal key bindings. Meaning, e.g. ctrl+g, ctrl+a, ctrl+e etc now works while searching with e.g. a russian layout.
2020-03-18 15:30:14 +01:00
tll_free(it->item.bind.key_codes);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
tll_free(seat->kbd.bindings.search);
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
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
tll_free(seat->mouse.bindings);
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:
return;
case WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1:
break;
default:
LOG_WARN("unrecognized keymap format: %u", format);
return;
}
char *map_str = mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
if (map_str == MAP_FAILED) {
LOG_ERRNO("failed to mmap keyboard keymap");
close(fd);
return;
}
while (map_str[size - 1] == '\0')
size--;
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.xkb = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
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 != 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);
/* Compose (dead keys) */
seat->kbd.xkb_compose_table = xkb_compose_table_new_from_locale(
seat->kbd.xkb, setlocale(LC_CTYPE, NULL), XKB_COMPOSE_COMPILE_NO_FLAGS);
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_compose_table == NULL) {
LOG_WARN("failed to instantiate compose table; dead keys will not work");
} else {
seat->kbd.xkb_compose_state = xkb_compose_state_new(
seat->kbd.xkb_compose_table, XKB_COMPOSE_STATE_NO_FLAGS);
}
}
vt: add support for mouse motion reports
2019-07-05 15:13:06 +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_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);
seat->kbd.mod_meta = xkb_keymap_mod_get_index(seat->kbd.xkb_keymap, XKB_MOD_NAME_LOGO);
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
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
wip: initial input handling
2019-06-19 10:04:47 +02:00
munmap(map_str, size);
close(fd);
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
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +02:00
convert_key_bindings(wayl->conf, seat);
convert_search_bindings(wayl->conf, seat);
convert_mouse_bindings(wayl->conf, seat);
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)
{
input: keyboard/pointer_enter: assert surface != NULL
2019-11-28 19:46:27 +01:00
assert(surface != NULL);
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
input: keyboard: detect failure to mmap keymap
2020-07-14 08:52:11 +02:00
if (seat->kbd.xkb == NULL)
return;
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;
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
input: keyboard: detect failure to mmap keymap
2020-07-14 08:52:11 +02:00
if (seat->kbd.xkb == NULL)
return;
input: sway 1.2 bug: keyboard_leave() called with surface == NULL
2019-11-28 19:24:16 +01:00
assert(
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;
seat->kbd.meta = false;
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
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: use same lookup table for Tab and ISO_Left_Tab With XKB, Shift+Tab maps to XKB_KEY_ISO_Left_Tab, not XKB_Key_Tab. Previously, we had two different lookup tables for the two. The tab table was correctly populated, while the ISO-left tab wasn’t. As a result, all Shift+Tab combos (except Shift+Tab itself) was wrong, and resulted in the same escape sequence as Shift+Tab. Fix by using the same table for both tab and ISO-left tab. Closes #210
2020-11-19 19:15:13 +01:00
case XKB_KEY_Tab: /* FALLTHROUGH */
case XKB_KEY_ISO_Left_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: 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
keymap_lookup(struct seat *seat, 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
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
LOG_DBG("keypad mode: %d, num-lock=%d", keypad_keys_mode, seat->kbd.num);
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++) {
if (info[j].modifiers != MOD_ANY && info[j].modifiers != mods)
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
}
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: 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
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 xkb_mod_mask_t ctrl = 1 << seat->kbd.mod_ctrl;
const xkb_mod_mask_t alt = 1 << seat->kbd.mod_alt;
const xkb_mod_mask_t shift = 1 << seat->kbd.mod_shift;
const xkb_mod_mask_t meta = 1 << seat->kbd.mod_meta;
wip: initial input handling
2019-06-19 10:04:47 +02:00
if (state == XKB_KEY_UP) {
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
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
bool should_repeat = xkb_keymap_key_repeats(seat->kbd.xkb_keymap, key);
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
config: move cursor.hide-when-typing to mouse.hide-when-typing
2020-08-04 07:33:15 +02:00
if (state == XKB_KEY_DOWN && term->conf->mouse.hide_when_typing &&
Fix some spelling mistakes
2020-08-15 19:39:00 +01:00
/* TODO: better way to detect modifiers */
input: hide-when-typing: ignore modifiers
2020-08-03 18:19:43 +02:00
sym != XKB_KEY_Shift_L && sym != XKB_KEY_Shift_R &&
sym != XKB_KEY_Control_L && sym != XKB_KEY_Control_R &&
sym != XKB_KEY_Alt_L && sym != XKB_KEY_Alt_R &&
input: ignore ISO Level 3 Shift (AltGr) when hiding the mouse cursor
2020-08-04 07:38:21 +02:00
sym != XKB_KEY_ISO_Level3_Shift &&
input: hide-when-typing: ignore modifiers
2020-08-03 18:19:43 +02:00
sym != XKB_KEY_Super_L && sym != XKB_KEY_Super_R &&
sym != XKB_KEY_Meta_L && sym != XKB_KEY_Meta_R &&
sym != XKB_KEY_Menu)
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) {
xkb_compose_state_feed(seat->kbd.xkb_compose_state, sym);
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: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
if (compose_status == XKB_COMPOSE_COMPOSING) {
/* TODO: goto maybe_repeat? */
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
return;
input: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
}
input: add support for dead keys (composing)
2019-07-09 10:00:54 +02:00
wip: initial input handling
2019-06-19 10:04:47 +02:00
xkb_mod_mask_t mods = xkb_state_serialize_mods(
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.xkb_state, XKB_STATE_MODS_DEPRESSED);
//xkb_mod_mask_t consumed = xkb_state_key_get_consumed_mods(seat->kbd.xkb_state, key);
input: add a key mapping table, mapping key syms to escape sequences At the same time, also add support for the shift modifier.
2019-06-22 20:31:53 +02:00
xkb_mod_mask_t consumed = 0x0;
input: track meta modifier
2019-08-15 19:38:28 +02:00
xkb_mod_mask_t significant = ctrl | alt | shift | meta;
wip: initial input handling
2019-06-19 10:04:47 +02:00
xkb_mod_mask_t effective_mods = mods & ~consumed & significant;
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
if (term->is_searching) {
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);
multi-seat: re-enable scrollback search support
2020-07-08 18:20:34 +02:00
search_input(seat, term, key, sym, effective_mods, serial);
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
return;
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
#if 0
for (size_t i = 0; i < 32; i++) {
if (mods & (1 << i)) {
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_INFO("%s", xkb_keymap_mod_get_name(seat->kbd.xkb_keymap, i));
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
}
#endif
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));
#endif
LOG_DBG("%s (%u/0x%x): seat=%s, term=%p, serial=%u, "
"mod=0x%08x, consumed=0x%08x, significant=0x%08x, "
input: use xkb_keymap_key_repeats() to determine if we should start repeat timer
2019-11-22 22:19:00 +01:00
"effective=0x%08x, repeats=%d",
input: improved debug logging of pressed keys
2020-11-30 20:01:46 +01:00
sym_name, sym, sym, seat->name, (void *)term, serial,
mods, consumed, significant, effective_mods, should_repeat);
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
*/
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
tll_foreach(seat->kbd.bindings.key, it) {
search: replace hard-coded key bindings with "user configurable" ones They aren't really user configurable. At least not yet. However, with this, we now handle raw key codes just like the normal key bindings. Meaning, e.g. ctrl+g, ctrl+a, ctrl+e etc now works while searching with e.g. a russian layout.
2020-03-18 15:30:14 +01:00
if (it->item.bind.mods != effective_mods)
input: bindings: don't match raw key code alone - mods must also match
2020-03-18 14:52:39 +01:00
continue;
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
/* Match symbol */
search: replace hard-coded key bindings with "user configurable" ones They aren't really user configurable. At least not yet. However, with this, we now handle raw key codes just like the normal key bindings. Meaning, e.g. ctrl+g, ctrl+a, ctrl+e etc now works while searching with e.g. a russian layout.
2020-03-18 15:30:14 +01:00
if (it->item.bind.sym == sym) {
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
if (execute_binding(seat, term, it->item.action, it->item.pipe_argv, serial))
goto maybe_repeat;
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: 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
/* Match raw key code */
search: replace hard-coded key bindings with "user configurable" ones They aren't really user configurable. At least not yet. However, with this, we now handle raw key codes just like the normal key bindings. Meaning, e.g. ctrl+g, ctrl+a, ctrl+e etc now works while searching with e.g. a russian layout.
2020-03-18 15:30:14 +01:00
tll_foreach(it->item.bind.key_codes, code) {
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
if (code->item == key) {
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
if (execute_binding(seat, term, it->item.action, it->item.pipe_argv, serial))
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
*/
enum modifier keymap_mods = MOD_NONE;
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
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;
keymap_mods |= seat->kbd.meta ? MOD_META : MOD_NONE;
input: comments
2020-01-11 18:59:46 +01:00
csi: add new private mode that makes the Escape key emit "\E[27;1;27~" This mode can be set by client programs with the DECSET, DECRST, XTSAVE and XTRESTORE sequences by using 27127 as the parameter. The sequence "\E[27;1;27~" is encoded in the same way as is done by xterm's "modifyOtherKeys" mode. Even though xterm itself never emits such a sequence for the Escape key, many programs already have support for parsing this style of key sequence.
2020-11-29 04:04:57 +00:00
const struct key_data *keymap;
if (sym == XKB_KEY_Escape && keymap_mods == MOD_NONE && term->modify_escape_key) {
static const struct key_data esc = {.seq = "\033[27;1;27~"};
keymap = &esc;
} else
keymap = keymap_lookup(seat, term, sym, keymap_mods);
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
if (keymap != NULL) {
term_to_slave(term, keymap->seq, strlen(keymap->seq));
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: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
term_reset_view(term);
selection_cancel(term);
input: break out keymap lookup to a separate function
2020-01-11 17:55:45 +01:00
goto maybe_repeat;
input: keymap_lookup: only do lookup, don't sent to client
2020-01-11 18:40:27 +01:00
}
input: reduce utf8 buffer size
2019-06-22 20:40:28 +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 (compose_status == XKB_COMPOSE_CANCELLED)
goto maybe_repeat;
input: comments
2020-01-11 18:59:46 +01:00
/*
* Compose, and maybe emit "normal" character
*/
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
assert(seat->kbd.xkb_compose_state != NULL ||
compose_status != XKB_COMPOSE_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: 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
int count = compose_status == XKB_COMPOSE_COMPOSED
? 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
if (count <= 0)
input: discard canceled compose sequences
2019-12-02 21:32:09 +01:00
goto maybe_repeat;
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);
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
compose_status == XKB_COMPOSE_COMPOSED
? xkb_compose_state_get_utf8(
seat->kbd.xkb_compose_state, (char *)utf8, count + 1)
: xkb_state_key_get_utf8(
seat->kbd.xkb_state, key, (char *)utf8, count + 1);
if (seat->kbd.xkb_compose_state != NULL)
xkb_compose_state_reset(seat->kbd.xkb_compose_state);
wip: initial input handling
2019-06-19 10:04:47 +02:00
input: generate escape sequences for "other" keys This corresponds to xterm's modifyOtherKeys option, though the code needs more testing and cleanup.
2019-07-26 18:49:09 +02:00
#define is_control_key(x) ((x) >= 0x40 && (x) <= 0x7f)
#define IS_CTRL(x) ((x) < 0x20 || ((x) >= 0x7f && (x) <= 0x9f))
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
if ((keymap_mods & MOD_CTRL) &&
!is_control_key(sym) &&
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
(count == 1 && !IS_CTRL(utf8[0])) &&
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
sym < 256)
{
static const int mod_param_map[32] = {
[MOD_SHIFT] = 2,
[MOD_ALT] = 3,
[MOD_SHIFT | MOD_ALT] = 4,
[MOD_CTRL] = 5,
[MOD_SHIFT | MOD_CTRL] = 6,
[MOD_ALT | MOD_CTRL] = 7,
[MOD_SHIFT | MOD_ALT | MOD_CTRL] = 8,
[MOD_META] = 9,
[MOD_META | MOD_SHIFT] = 10,
[MOD_META | MOD_ALT] = 11,
[MOD_META | MOD_SHIFT | MOD_ALT] = 12,
[MOD_META | MOD_CTRL] = 13,
[MOD_META | MOD_SHIFT | MOD_CTRL] = 14,
[MOD_META | MOD_ALT | MOD_CTRL] = 15,
[MOD_META | MOD_SHIFT | MOD_ALT | MOD_CTRL] = 16,
};
assert(keymap_mods < sizeof(mod_param_map) / sizeof(mod_param_map[0]));
int modify_param = mod_param_map[keymap_mods];
assert(modify_param != 0);
char reply[1024];
snprintf(reply, sizeof(reply), "\x1b[27;%d;%d~", modify_param, sym);
term_to_slave(term, reply, strlen(reply));
}
else {
if (effective_mods & alt) {
/*
* 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
*
* If #1 has been disabled, we use #2, *if* it's a single
* byte we're emitting. Since this is an UTF-8 terminal,
* we then UTF8-encode the 8-bit character. #2 is
* configured with \E[?1034, and is on by default.
*
* 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);
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
term_to_slave(term, utf8, count);
input: comments
2020-01-11 18:59:46 +01:00
}
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
else if (term->meta.eight_bit && count == 1) {
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
const wchar_t wc = 0x80 | utf8[0];
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
char utf8[8];
don't use empty struct initializers
2020-08-23 07:42:20 +02:00
mbstate_t ps = {0};
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
size_t chars = wcrtomb(utf8, wc, &ps);
input: comments
2020-01-11 18:59:46 +01:00
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
if (chars != (size_t)-1)
term_to_slave(term, utf8, chars);
else
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
term_to_slave(term, utf8, count);
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
}
else {
/* Alt ignored */
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
term_to_slave(term, utf8, count);
input: comments
2020-01-11 18:59:46 +01:00
}
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
} else
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
term_to_slave(term, utf8, count);
input: implement metaSendsEscape and eightBitMeta
2020-01-20 18:38:50 +01:00
}
input: comments
2020-01-11 18:59:46 +01: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: comments
2020-01-11 18:59:46 +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
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
LOG_DBG("modifiers: depressed=0x%x, latched=0x%x, locked=0x%x, group=%u",
mods_depressed, mods_latched, mods_locked, group);
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 */
seat->kbd.shift = xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_shift, XKB_STATE_MODS_DEPRESSED);
seat->kbd.alt = xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_alt, XKB_STATE_MODS_DEPRESSED);
seat->kbd.ctrl = xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_ctrl, XKB_STATE_MODS_DEPRESSED);
seat->kbd.meta = xkb_state_mod_index_is_active(
seat->kbd.xkb_state, seat->kbd.mod_meta, XKB_STATE_MODS_DEPRESSED);
}
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
}
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 */
assert(seat->kbd_focus != NULL);
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 (
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
(!term->window->is_tiled_top && !term->window->is_tiled_left) &&
((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 (
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
(!term->window->is_tiled_top && !term->window->is_tiled_right) &&
((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 (
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
(!term->window->is_tiled_bottom && !term->window->is_tiled_left) &&
((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 (
input: don’t allow diagonal resize when tiled
2020-10-20 21:00:19 +02:00
(!term->window->is_tiled_bottom && !term->window->is_tiled_right) &&
((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
}
static const char *
xcursor_for_csd_border(struct terminal *term, int x, int y)
{
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
if (is_top_left(term, x, y)) return XCURSOR_TOP_LEFT_CORNER;
else if (is_top_right(term, x, y)) return XCURSOR_TOP_RIGHT_CORNER;
else if (is_bottom_left(term, x, y)) return XCURSOR_BOTTOM_LEFT_CORNER;
else if (is_bottom_right(term, x, y)) return XCURSOR_BOTTOM_RIGHT_CORNER;
else if (term->active_surface == TERM_SURF_BORDER_LEFT) return XCURSOR_LEFT_SIDE;
else if (term->active_surface == TERM_SURF_BORDER_RIGHT) return XCURSOR_RIGHT_SIDE;
else if (term->active_surface == TERM_SURF_BORDER_TOP) return XCURSOR_TOP_SIDE;
else if (term->active_surface == TERM_SURF_BORDER_BOTTOM) return XCURSOR_BOTTOM_SIDE;
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 {
assert(false);
return NULL;
}
}
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: keyboard/pointer_enter: assert surface != NULL
2019-11-28 19:46:27 +01:00
assert(surface != NULL);
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: 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
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;
seat: use separate 'enter' serials for keyboard and mouse
2020-07-09 11:20:46 +02:00
input: add debug logs to all keyboard/pointer enter/leave/action events
2020-03-14 11:51:47 +01:00
LOG_DBG("pointer-enter: pointer=%p, serial=%u, surface = %p, new-moused = %p",
Cast printf formatter %p arguments to void*
2020-08-23 07:50:27 +02:00
(void *)wl_pointer, serial, (void *)surface, (void *)term);
input: pointer-enter: add debug log
2019-11-29 22:12:54 +01:00
xcursor: trigger theme reload in pointer-enter event Previously, we triggered a theme reload on output changes. This is completely wrong. We may get a new output with a scale different from the output the pointer is actually on. Now, we store the current scale along with the theme. We then trigger a call to reload the xcursor theme *every* time the pointer enters a surface. When it does, we use the current scale factor of the terminal that owns that surface. If the terminal covers multiple outputs, with different scale factors, we'll use the largest scale factor. This may not be 100% correct. But to fix that, we'd need to track which regions of a surface are mapped on which outputs. Too complicated I say.
2020-07-08 19:52:17 +02:00
/* Scale may have changed */
wayl_reload_xcursor_theme(seat, term->scale);
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 = term;
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
input: scale coordinates in wl_pointer_enter()
2019-09-26 18:41:26 +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
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
switch ((term->active_surface = term_surface_kind(term, 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: pointer-enter: add comment describing what we're doing
2020-08-08 10:07:25 +02:00
/*
* 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: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
if (x < term->margins.left || x >= term->width - term->margins.right)
seat->mouse.col = -1;
else
seat->mouse.col = (x - term->margins.left) / term->cell_width;
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: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
if (y < term->margins.top || y >= term->height - term->margins.bottom)
seat->mouse.row = -1;
else
seat->mouse.row = (y - term->margins.top) / term->cell_height;
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
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(term, seat);
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
case TERM_SURF_SEARCH:
input: handle the scrollback indicator surface in pointer events
2020-07-26 12:37:35 +02:00
case TERM_SURF_SCROLLBACK_INDICATOR:
input: don't crash on mouse motion events on the render timer surface
2020-08-14 07:35:01 +02:00
case TERM_SURF_RENDER_TIMER:
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_TITLE:
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
render_xcursor_set(seat, term, XCURSOR_LEFT_PTR);
input: pointer-enter: differentiate between the surfaces
2020-02-24 22:40:24 +01:00
break;
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:
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
render_xcursor_set(seat, term, xcursor_for_csd_border(term, x, y));
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:
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
render_xcursor_set(seat, term, XCURSOR_LEFT_PTR);
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:
assert(false);
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;
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;
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->pointer.xcursor = 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
}
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: 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_free(seat->mouse.buttons);
seat->mouse.count = 0;
seat->mouse.last_released_button = 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
memset(&seat->mouse.last_time, 0, sizeof(seat->mouse.last_time));
seat->mouse.axis_aggregated = 0.0;
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);
wayland: store pointer to window instance in all surfaces
2020-02-29 12:09:28 +01:00
assert(old_moused == win->term);
}
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;
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(old_moused, seat);
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:
if (old_moused->is_shutting_down)
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_NONE:
case TERM_SURF_GRID:
case TERM_SURF_SEARCH:
input: handle the scrollback indicator surface in pointer events
2020-07-26 12:37:35 +02:00
case TERM_SURF_SCROLLBACK_INDICATOR:
input: don't crash on mouse motion events on the render timer surface
2020-08-14 07:35:01 +02:00
case TERM_SURF_RENDER_TIMER:
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
}
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;
struct wayland *wayl = seat->wayl;
struct terminal *term = seat->mouse_focus;
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));
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
assert(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
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: 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
enum term_surface surf_kind = term->active_surface;
int button = 0;
bool send_to_client = false;
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:
case TERM_SURF_SEARCH:
input: handle the scrollback indicator surface in pointer events
2020-07-26 12:37:35 +02:00
case TERM_SURF_SCROLLBACK_INDICATOR:
input: don't crash on mouse motion events on the render timer surface
2020-08-14 07:35:01 +02:00
case TERM_SURF_RENDER_TIMER:
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:
case TERM_SURF_BUTTON_CLOSE:
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:
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
render_xcursor_set(seat, term, xcursor_for_csd_border(term, x, y));
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
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: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
/*
* While the seat's mouse coordinates must always be on the
* grid, or -1, we allow updating the selection even when the
* mouse is outside the grid (could also be outside the
* terminal window).
*/
int selection_col;
int selection_row;
if (x < term->margins.left) {
seat->mouse.col = -1;
selection_col = 0;
} else if (x >= term->width - term->margins.right) {
seat->mouse.col = -1;
selection_col = term->cols - 1;
} else {
seat->mouse.col = (x - term->margins.left) / term->cell_width;
selection_col = seat->mouse.col;
}
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: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
if (y < term->margins.top) {
seat->mouse.row = -1;
selection_row = 0;
} else if (y >= term->height - term->margins.bottom) {
seat->mouse.row = -1;
selection_row = term->rows - 1;
} else {
seat->mouse.row = (y - term->margins.top) / term->cell_height;
selection_row = seat->mouse.row;
}
vt: add support for mouse motion reports
2019-07-05 15:13:06 +02:00
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
/*
* If client is receiving events (because the button was
* pressed while the cursor was inside the grid area), then
* make sure it receives valid coordinates.
*/
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) {
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.col = selection_col;
seat->mouse.row = selection_row;
}
input: mouse: motion/enter: cleanup inside/outside grid handling
2020-08-07 22:04:37 +02:00
assert(seat->mouse.col == -1 || (seat->mouse.col >= 0 && seat->mouse.col < term->cols));
assert(seat->mouse.row == -1 || (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
term_xcursor_update_for_seat(term, seat);
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
/* 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: 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
= 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) {
/*
* Start ‘selection auto-scrolling’
*
* 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
*
input: comment: ‘measures’ -> ‘measured’
2020-10-11 18:23:01 +02:00
* Note that the speed is measured in ‘intervals (in
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
* ns) between each timed scroll of a single line’.
*
* 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);
assert(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),
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
auto_scroll_direction, selection_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: 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->selection.ongoing && (cursor_is_on_new_cell ||
term->selection.end.row < 0))
{
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_update(term, selection_col, selection_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) &&
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
cursor_is_on_new_cell &&
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
{
assert(seat->mouse.col < term->cols);
assert(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,
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: 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
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;
struct terminal *term = seat->mouse_focus;
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02: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;
input: pointer_button: apply same workaround as in pointer_motion Sway 1.2 has been seen to send pointer_button events without first having sent pointer_enter.
2019-11-28 19:26:52 +01:00
assert(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) {
/* Time since last click */
struct timeval now, since_last;
gettimeofday(&now, NULL);
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
timersub(&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 &&
since_last.tv_sec == 0 && since_last.tv_usec <= 300 * 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: 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)
assert(it->item.button != button);
#endif
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;
}
}
assert(have_button);
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 */
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 (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: 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
else if (button == BTN_LEFT && win->csd.move_timeout_fd == -1) {
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");
close(fd);
}
}
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;
if (win->csd.move_timeout_fd != -1) {
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: use xdg_toplevel_resize_edge enum type
2020-03-01 11:43:58 +01:00
static const enum xdg_toplevel_resize_edge map[] = {
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
[TERM_SURF_BORDER_LEFT] = XDG_TOPLEVEL_RESIZE_EDGE_LEFT,
[TERM_SURF_BORDER_RIGHT] = XDG_TOPLEVEL_RESIZE_EDGE_RIGHT,
[TERM_SURF_BORDER_TOP] = XDG_TOPLEVEL_RESIZE_EDGE_TOP,
[TERM_SURF_BORDER_BOTTOM] = XDG_TOPLEVEL_RESIZE_EDGE_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) {
input: use xdg_toplevel_resize_edge enum type
2020-03-01 11:43:58 +01:00
enum xdg_toplevel_resize_edge 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
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;
else
resize_type = map[term->active_surface];
xdg_toplevel_resize(
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
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:
if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED)
xdg_toplevel_set_minimized(term->window->xdg_toplevel);
break;
case TERM_SURF_BUTTON_MAXIMIZE:
if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
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:
if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED)
term_shutdown(term);
break;
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
case TERM_SURF_SEARCH:
input: handle the scrollback indicator surface in pointer events
2020-07-26 12:37:35 +02:00
case TERM_SURF_SCROLLBACK_INDICATOR:
input: don't crash on mouse motion events on the render timer surface
2020-08-14 07:35:01 +02:00
case TERM_SURF_RENDER_TIMER:
input: wip: trigger move/resize when left-clicking CSD
2020-02-25 20:31:13 +01:00
break;
input: pointer-motion/button: ignore actions in non-main surfaces
2020-02-24 22:42:04 +01:00
input: cleanup
2020-02-29 15:29:00 +01:00
case TERM_SURF_GRID: {
search_cancel(term);
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: 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->wl_keyboard != NULL && seat->kbd.xkb_state != NULL) {
/* Seat has keyboard - use mouse bindings *with* modifiers */
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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
xkb_mod_mask_t mods = xkb_state_serialize_mods(
seat->kbd.xkb_state, XKB_STATE_MODS_DEPRESSED);
input: mouse: match binding if binding’s click count is *less* Allow a mouse binding to match even if its click count is less than the actual click count. If there are multiple bindings that match, use the one with the highest click count (that less than, or equal to the actual click count). Closes #146
2020-09-27 14:31:39 +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
/* Ignore Shift when matching modifiers, since it is
* used to enable selection in mouse grabbing client
* applications */
mods &= ~(1 << seat->kbd.mod_shift);
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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
const struct mouse_binding *match = NULL;
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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
tll_foreach(seat->mouse.bindings, it) {
const struct mouse_binding *binding = &it->item;
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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 (binding->button != button) {
/* Wrong button */
continue;
}
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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 (binding->mods != mods) {
/* Modifier mismatch */
continue;
input: mouse: match binding if binding’s click count is *less* Allow a mouse binding to match even if its click count is less than the actual click count. If there are multiple bindings that match, use the one with the highest click count (that less than, or equal to the actual click count). Closes #146
2020-09-27 14:31:39 +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 (binding->count > seat->mouse.count) {
/* Not correct click count */
continue;
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
}
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +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 (match == NULL || binding->count > match->count)
match = binding;
}
input: mouse: match binding if binding’s click count is *less* Allow a mouse binding to match even if its click count is less than the actual click count. If there are multiple bindings that match, use the one with the highest click count (that less than, or equal to the actual click count). Closes #146
2020-09-27 14:31:39 +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 (match != NULL) {
consumed = execute_binding(
seat, term, match->action, match->pipe_argv, serial);
}
}
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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
else {
/* Seat does NOT have a keyboard - use mouse bindings *without* modifiers */
const struct config_mouse_binding *match = NULL;
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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
tll_foreach(seat->wayl->conf->bindings.mouse, it) {
const struct config_mouse_binding *binding = &it->item;
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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 (binding->button != button) {
/* Wrong button */
continue;
}
input: fix assertion when pressing first one mouse button, then another
2020-09-07 19:35:25 +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 (binding->count > seat->mouse.count) {
/* Incorrect click count */
continue;
input: mouse: match binding if binding’s click count is *less* Allow a mouse binding to match even if its click count is less than the actual click count. If there are multiple bindings that match, use the one with the highest click count (that less than, or equal to the actual click count). Closes #146
2020-09-27 14:31:39 +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
const struct config_key_modifiers no_mods = {0};
if (memcmp(&binding->modifiers, &no_mods, sizeof(no_mods)) != 0) {
/* Binding has modifiers */
continue;
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +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 (match == NULL || binding->count > match->count)
match = binding;
config: key/mouse bindings: refactor: less parsing in keyboard_enter() This simplifies the handling of mouse and keyboard bindings. Before, the bindings where parsed *both* when loading the configuration, and then on every keyboard enter event. This was done since keys require a keymap to be decoded. Something we don't have at configuration time. The idea was that at config time, we used a default keymap just to verify the key combo strings were valid. The following has changed: * The bindings in the config struct is now *one* key combo per entry. Previously, it was one *action* per entry, and each entry had one or more key combos. Doing it this way makes it easier when converting the binding in the keyboard enter event (which previously had to expand the combos anyway). * The bindings in the config struct no longer contains any unparsed strings. A key binding contains a decoded 'modifier' struct (which specifies whether e.g. ctrl, or shift, or ctrl+shift must be pressed for the binding to be used). It also contains a decoded XKB keysym. * A mouse binding in the config struct is similar to a key binding, except it contains the button, and click count instead of the XKB key sym. * The modifiers in the user-specified key combo is decoded at config time, by using the pre-defined XKB constants XKB_MOD_NAME_<modifier>. The result is stored in a 'modifiers' struct, which is just a collection of booleans; one for each supported modifier. The supported modifiers are: shift, ctrl, alt and meta/super. * The key sym is decoded at config time using xkb_keysym_from_name(). This call does *not* depend on a keymap. * The mouse button is decoded at config time using a hardcoded mapping table (just like before). * The click count is currently hard-coded to 1. * In the keyboard enter event, all we need to do is pre-compute the xkb_mod_mask_t variable for each key/mouse binding, and find all the *key codes* that map to the (already decoded) symbol. For mouse bindings, the modifiers are the *only* reason we convert the mouse bindings at all. In fact, on button events, we check if the seat has a keyboard. If not, we use the mouse bindings from the configuration directly, and simply filter out those with a non-empty set of modifiers.
2020-08-10 19:00:03 +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 (match != NULL) {
consumed = execute_binding(
seat, term, match->action, match->pipe.argv, serial);
}
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,
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,
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:
assert(false);
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 */
assert(seat->mouse_focus != NULL);
struct terminal *term = seat->mouse_focus;
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
wip: multi-seat support Compiles and runs, but mouse, clipboard and other things have been disabled.
2020-07-08 16:45:26 +02:00
mouse_scroll(struct seat *seat, int amount)
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;
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
assert(term != NULL);
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
int button = amount < 0 ? BTN_BACK : BTN_FORWARD;
amount = abs(amount);
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
if (term->mouse_tracking == MOUSE_NONE) {
if (term->grid == &term->alt) {
if (term->alt_scrolling)
alternate_scroll(seat, amount, button);
} else {
if (button == BTN_BACK)
cmd_scrollback_up(term, amount);
else
cmd_scrollback_down(term, amount);
input: mouse_scroll: cache XKB_KEY_Up and XKB_KEY_Down
2019-11-30 16:48:58 +01:00
}
input: mouse_scroll(): refactor
2020-09-15 18:56:22 +02:00
} else if (!term_mouse_grabbed(term, seat) &&
seat->mouse.col >= 0 && seat->mouse.row >= 0)
{
assert(seat->mouse.col < term->cols);
assert(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,
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,
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: 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)
{
mouse: use discrete axis event if available This improves the scroll experience with certain devices
2019-07-26 18:47:56 +02:00
if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
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;
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
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
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
assert(seat->mouse_focus != NULL);
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.
*/
config: add scrollback.multiplier option This option is used to multiply the mouse scroll amount for mouse and trackpad based scrollback scrolling. Closes #54.
2020-08-03 19:43:06 +02:00
seat->mouse.axis_aggregated
+= seat->wayl->conf->scrollback.multiplier * wl_fixed_to_double(value);
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
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
if (fabs(seat->mouse.axis_aggregated) < seat->mouse_focus->cell_height)
return;
int lines = seat->mouse.axis_aggregated / seat->mouse_focus->cell_height;
mouse_scroll(seat, lines);
seat->mouse.axis_aggregated -= (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,
uint32_t axis, int32_t discrete)
{
scrollback: initial support for mouse scrolling
2019-07-10 09:15:37 +02:00
if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
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;
seat->mouse.have_discrete = true;
config: add scrollback.multiplier option This option is used to multiply the mouse scroll amount for mouse and trackpad based scrollback scrolling. Closes #54.
2020-08-03 19:43:06 +02:00
mouse_scroll(seat, seat->wayl->conf->scrollback.multiplier * discrete);
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;
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)
{
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
if (axis != WL_POINTER_AXIS_VERTICAL_SCROLL)
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;
seat->mouse.axis_aggregated = 0.;
input: mouse events
2019-07-05 10:44:57 +02:00
}
const struct wl_pointer_listener pointer_listener = {
.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,
};
Reference in a new issue Copy permalink