itycodes
/
convince
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '06fade1c8b'
${ noResults }
convince/sway/input/keyboard.c

488 lines
16 KiB
Raw Normal View History Unescape

binding release
7 years ago
#include <assert.h>
Make key repeat configurable This creates two input commands for configuring the repeat delay and rate. Example config: input "myidentifier" { repeat_delay 250 repeat_rate 25 }
7 years ago
#include <limits.h>
compositor bindings
7 years ago
#include <wlr/backend/multi.h>
#include <wlr/backend/session.h>
Idle handling for dpms/lockscreen et al Swayidle handles idle events and allows for dpms and lockscreen handling. It also handles systemd sleep events, and can raise a lockscreen on sleep Fixes #541
7 years ago
#include <wlr/types/wlr_idle.h>
Implement setting NumLock and CapsLock status After setting the keymap, try to enable NumLock and disable CapsLock. This only works if sway has the xkb master state and controls the keyboard. Prepare configuration settings for later use as well.
7 years ago
#include <wlr/interfaces/wlr_keyboard.h>
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
#include "sway/commands.h"
Make focus part of transactions Rather than maintain copies of the entire focus stack, this PR transactionises the focus by introducing two new properties to the container state and using those when rendering. * `bool focused` means this container has actual focus. Only one container should have this equalling true in its current state. * `struct sway_container *focus_inactive_child` points to the immediate child that was most recently focused (eg. for tabbed and stacked containers).
7 years ago
#include "sway/desktop/transaction.h"
xkb config
7 years ago
#include "sway/input/input-manager.h"
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
#include "sway/input/keyboard.h"
#include "sway/input/seat.h"
basic keyboard
7 years ago
#include "log.h"
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
/**
* Remove all key ids associated to a keycode from the list of pressed keys
*/
static void state_erase_key(struct sway_shortcut_state *state,
uint32_t keycode) {
size_t j = 0;
for (size_t i = 0; i < state->npressed; ++i) {
if (i > j) {
state->pressed_keys[j] = state->pressed_keys[i];
state->pressed_keycodes[j] = state->pressed_keycodes[i];
}
if (state->pressed_keycodes[i] != keycode) {
++j;
}
}
while(state->npressed > j) {
--state->npressed;
state->pressed_keys[state->npressed] = 0;
state->pressed_keycodes[state->npressed] = 0;
}
}
/**
* Add a key id (with associated keycode) to the list of pressed keys,
* if the list is not full.
*/
static void state_add_key(struct sway_shortcut_state *state,
uint32_t keycode, uint32_t key_id) {
if (state->npressed >= SWAY_KEYBOARD_PRESSED_KEYS_CAP) {
return;
}
size_t i = 0;
while (i < state->npressed && state->pressed_keys[i] < key_id) {
++i;
}
size_t j = state->npressed;
while (j > i) {
state->pressed_keys[j] = state->pressed_keys[j - 1];
state->pressed_keycodes[j] = state->pressed_keycodes[j - 1];
--j;
}
state->pressed_keys[i] = key_id;
state->pressed_keycodes[i] = keycode;
state->npressed++;
}
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
/**
* Update the shortcut model state in response to new input
*/
Rename update_shortcut_model to update_shortcut_state
7 years ago
static void update_shortcut_state(struct sway_shortcut_state *state,
Style fixed for keyboard.c
7 years ago
struct wlr_event_keyboard_key *event, uint32_t new_key,
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
uint32_t raw_modifiers) {
bool last_key_was_a_modifier = raw_modifiers != state->last_raw_modifiers;
state->last_raw_modifiers = raw_modifiers;
fix handling key modifiers if not pressed at first fixes #2169
7 years ago
if (last_key_was_a_modifier && state->last_keycode) {
// Last pressed key before this one was a modifier
state_erase_key(state, state->last_keycode);
}
match user bindsym
7 years ago
fix handling key modifiers if not pressed at first fixes #2169
7 years ago
if (event->state == WLR_KEY_PRESSED) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
// Add current key to set; there may be duplicates
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
state_add_key(state, event->keycode, new_key);
state->last_keycode = event->keycode;
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
} else {
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
state_erase_key(state, event->keycode);
cleanup bindings
7 years ago
}
}
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
/**
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
* If one exists, finds a binding which matches the shortcut model state,
* current modifiers, release state, and locked state.
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
*/
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
static void get_active_binding(const struct sway_shortcut_state *state,
list_t *bindings, struct sway_binding **current_binding,
uint32_t modifiers, bool release, bool locked) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
for (int i = 0; i < bindings->length; ++i) {
struct sway_binding *binding = bindings->items[i];
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
bool binding_locked = binding->flags & BINDING_LOCKED;
bool binding_release = binding->flags & BINDING_RELEASE;
cleanup bindings
7 years ago
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
if (modifiers ^ binding->modifiers ||
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
state->npressed != (size_t)binding->keys->length ||
Parse mouse binding options First, the existing sway_binding structure is given an enumerated type code. As all flags to bindsym/bindcode are boolean, a single uint32 is used to hold all flags. The _BORDER, _CONTENTS, _TITLEBAR flags, when active, indicate in which part of a container the binding can trigger; to localize complexity, they do not overlap with the command line arguments, which center around _TITLEBAR being set by default. The keyboard handling code is adjusted for this change, as is binding_key_compare; note that BINDING_LOCKED is *not* part of the key portion of the binding. Next, list of mouse bindings is introduced and cleaned up. Finally, the binding command parsing code is extended to handle the case where bindsym is used to describe a mouse binding rather than a keysym binding; the difference between the two may be detected as late as when the first key/button is parsed, or as early as the first flag. As bindings can have multiple keycodes/keysyms/buttons, mixed keysym/button sequences are prohibited.
7 years ago
release != binding_release ||
locked > binding_locked) {
cleanup bindings
7 years ago
continue;
}
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
bool match = true;
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
for (size_t j = 0; j < state->npressed; j++) {
Style fixed for keyboard.c
7 years ago
uint32_t key = *(uint32_t *)binding->keys->items[j];
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (key != state->pressed_keys[j]) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
match = false;
break;
}
cleanup bindings
7 years ago
}
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (!match) {
continue;
}
cleanup bindings
7 years ago
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (*current_binding && *current_binding != binding) {
Update for swaywm/wlroots#1126
7 years ago
wlr_log(WLR_DEBUG, "encountered duplicate bindings %d and %d",
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
(*current_binding)->order, binding->order);
} else {
*current_binding = binding;
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
}
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
return;
cleanup bindings
7 years ago
}
}
compositor bindings
7 years ago
/**
* Execute a built-in, hardcoded compositor binding. These are triggered from a
* single keysym.
*
* Returns true if the keysym was handled by a binding and false if the event
* should be propagated to clients.
*/
run compositor bindings last
7 years ago
static bool keyboard_execute_compositor_binding(struct sway_keyboard *keyboard,
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
const xkb_keysym_t *pressed_keysyms, uint32_t modifiers, size_t keysyms_len) {
run compositor bindings last
7 years ago
for (size_t i = 0; i < keysyms_len; ++i) {
xkb_keysym_t keysym = pressed_keysyms[i];
if (keysym >= XKB_KEY_XF86Switch_VT_1 &&
keysym <= XKB_KEY_XF86Switch_VT_12) {
if (wlr_backend_is_multi(server.backend)) {
struct wlr_session *session =
Fix #2763
6 years ago
wlr_backend_get_session(server.backend);
run compositor bindings last
7 years ago
if (session) {
unsigned vt = keysym - XKB_KEY_XF86Switch_VT_1 + 1;
wlr_session_change_vt(session, vt);
}
compositor bindings
7 years ago
}
run compositor bindings last
7 years ago
return true;
compositor bindings
7 years ago
}
}
return false;
}
bindcode
7 years ago
/**
keyboard translate keysyms
7 years ago
* Get keysyms and modifiers from the keyboard as xkb sees them.
*
* This uses the xkb keysyms translation based on pressed modifiers and clears
* the consumed modifiers from the list of modifiers passed to keybind
* detection.
*
* On US layout, pressing Alt+Shift+2 will trigger Alt+@.
*/
static size_t keyboard_keysyms_translated(struct sway_keyboard *keyboard,
xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
uint32_t *modifiers) {
struct wlr_input_device *device =
keyboard->seat_device->input_device->wlr_device;
*modifiers = wlr_keyboard_get_modifiers(device->keyboard);
xkb_mod_mask_t consumed = xkb_state_key_get_consumed_mods2(
device->keyboard->xkb_state, keycode, XKB_CONSUMED_MODE_XKB);
*modifiers = *modifiers & ~consumed;
return xkb_state_key_get_syms(device->keyboard->xkb_state,
keycode, keysyms);
}
bindcode
7 years ago
/**
keyboard translate keysyms
7 years ago
* Get keysyms and modifiers from the keyboard as if modifiers didn't change
* keysyms.
*
* This avoids the xkb keysym translation based on modifiers considered pressed
* in the state.
*
* This will trigger keybinds such as Alt+Shift+2.
*/
static size_t keyboard_keysyms_raw(struct sway_keyboard *keyboard,
xkb_keycode_t keycode, const xkb_keysym_t **keysyms,
uint32_t *modifiers) {
struct wlr_input_device *device =
keyboard->seat_device->input_device->wlr_device;
*modifiers = wlr_keyboard_get_modifiers(device->keyboard);
xkb_layout_index_t layout_index = xkb_state_key_get_layout(
device->keyboard->xkb_state, keycode);
return xkb_keymap_key_get_syms_by_level(device->keyboard->keymap,
keycode, layout_index, 0, keysyms);
}
basic keyboard
7 years ago
static void handle_keyboard_key(struct wl_listener *listener, void *data) {
struct sway_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_key);
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
struct sway_seat* seat = keyboard->seat_device->sway_seat;
struct wlr_seat *wlr_seat = seat->wlr_seat;
basic configuration
7 years ago
struct wlr_input_device *wlr_device =
keyboard->seat_device->input_device->wlr_device;
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
wlr_idle_notify_activity(seat->input->server->idle, wlr_seat);
basic keyboard
7 years ago
struct wlr_event_keyboard_key *event = data;
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
bool input_inhibited = seat->exclusive_client != NULL;
keyboard translate keysyms
7 years ago
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
// Identify new keycode, raw keysym(s), and translated keysym(s)
keyboard translate keysyms
7 years ago
xkb_keycode_t keycode = event->keycode + 8;
run compositor bindings last
7 years ago
overwrite old bindings
7 years ago
const xkb_keysym_t *translated_keysyms;
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
uint32_t translated_modifiers;
run compositor bindings last
7 years ago
size_t translated_keysyms_len =
overwrite old bindings
7 years ago
keyboard_keysyms_translated(keyboard, keycode, &translated_keysyms,
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
&translated_modifiers);
keyboard translate keysyms
7 years ago
overwrite old bindings
7 years ago
const xkb_keysym_t *raw_keysyms;
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
uint32_t raw_modifiers;
fix nitpicks
7 years ago
size_t raw_keysyms_len =
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
keyboard_keysyms_raw(keyboard, keycode, &raw_keysyms, &raw_modifiers);
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
uint32_t code_modifiers = wlr_keyboard_get_modifiers(wlr_device->keyboard);
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
Rename update_shortcut_model to update_shortcut_state
7 years ago
// Update shortcut model state
update_shortcut_state(&keyboard->state_keycodes, event,
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
(uint32_t)keycode, code_modifiers);
Style fixed for keyboard.c
7 years ago
for (size_t i = 0; i < translated_keysyms_len; ++i) {
Rename update_shortcut_model to update_shortcut_state
7 years ago
update_shortcut_state(&keyboard->state_keysyms_translated,
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
event, (uint32_t)translated_keysyms[i],
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
code_modifiers);
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
}
Style fixed for keyboard.c
7 years ago
for (size_t i = 0; i < raw_keysyms_len; ++i) {
Rename update_shortcut_model to update_shortcut_state
7 years ago
update_shortcut_state(&keyboard->state_keysyms_raw,
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
event, (uint32_t)raw_keysyms[i],
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
code_modifiers);
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
}
bool handled = false;
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
// Identify active release binding
struct sway_binding *binding_released = NULL;
get_active_binding(&keyboard->state_keycodes,
config->current_mode->keycode_bindings, &binding_released,
code_modifiers, true, input_inhibited);
get_active_binding(&keyboard->state_keysyms_translated,
config->current_mode->keysym_bindings, &binding_released,
translated_modifiers, true, input_inhibited);
get_active_binding(&keyboard->state_keysyms_raw,
config->current_mode->keysym_bindings, &binding_released,
raw_modifiers, true, input_inhibited);
// Execute stored release binding once no longer active
if (keyboard->held_binding && binding_released != keyboard->held_binding &&
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
event->state == WLR_KEY_RELEASED) {
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
seat_execute_command(seat, keyboard->held_binding);
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
handled = true;
}
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (binding_released != keyboard->held_binding) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
keyboard->held_binding = NULL;
}
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (binding_released && event->state == WLR_KEY_PRESSED) {
keyboard->held_binding = binding_released;
}
// Identify and execute active pressed binding
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
struct sway_binding *next_repeat_binding = NULL;
Fix keyboard shortcut handling inconsistencies * Ensure that modifier keys are identified even when the next key does not produce a keysym. This requires that modifier change tracking be done for each sway_shortcut_state. * Permit regular and --release shortcuts on the same key combination. Distinct bindings are identified for press and release cases; note that the release binding needs to be identified for both key press and key release events. * Maintain ascending sort order for the shortcut state list, and keep track of the number of pressed key ids, for simpler (and hence faster) searching of the list of key bindings. * Move binding duplicate detection into get_active_binding to avoid duplicating error messages.
7 years ago
if (event->state == WLR_KEY_PRESSED) {
struct sway_binding *binding_pressed = NULL;
get_active_binding(&keyboard->state_keycodes,
config->current_mode->keycode_bindings, &binding_pressed,
code_modifiers, false, input_inhibited);
get_active_binding(&keyboard->state_keysyms_translated,
config->current_mode->keysym_bindings, &binding_pressed,
translated_modifiers, false, input_inhibited);
get_active_binding(&keyboard->state_keysyms_raw,
config->current_mode->keysym_bindings, &binding_pressed,
raw_modifiers, false, input_inhibited);
if (binding_pressed) {
Deny repeating reload by holding key Fixes #2568 The binding that gets stored in the keyboard's `repeat_binding` would get freed on reload, leaving a dangling pointer. Rather than attempt to unset the keyboard's `repeat_binding` along with the other bindings, I opted to just not set it for the reload command because there's no point in reloading repeatedly by holding the binding. This disables repeat bindings for the reload command. As we now need to detect whether it's a reload command in two places, I've added a binding flag to track whether it's a reload or not.
6 years ago
if ((binding_pressed->flags & BINDING_RELOAD) == 0) {
next_repeat_binding = binding_pressed;
}
Fix management of bindings during reload seat_execute_command needs to check the flags on `binding_copy`, as `binding` will be a dangling pointer after a reload command. handle_keyboard_key needs to set the next_repeat_binding for non-reloads prior to executing the command in case the binding is freed by the reload command.
6 years ago
seat_execute_command(seat, binding_pressed);
handled = true;
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
}
}
// Set up (or clear) keyboard repeat for a pressed binding
Bindings use advised keyboard repeat parameters Now 'repeat_delay' and 'repeat_rate' control the initial delay and rate (per second) of repeated binding invocations. If the repeat delay is zero, binding repetition is disabled. When the repeat rate is zero, the binding is repeated exactly once, assuming no other key events intervene.
7 years ago
if (next_repeat_binding && wlr_device->keyboard->repeat_info.delay > 0) {
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
keyboard->repeat_binding = next_repeat_binding;
if (wl_event_source_timer_update(keyboard->key_repeat_source,
Bindings use advised keyboard repeat parameters Now 'repeat_delay' and 'repeat_rate' control the initial delay and rate (per second) of repeated binding invocations. If the repeat delay is zero, binding repetition is disabled. When the repeat rate is zero, the binding is repeated exactly once, assuming no other key events intervene.
7 years ago
wlr_device->keyboard->repeat_info.delay) < 0) {
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
wlr_log(WLR_DEBUG, "failed to set key repeat timer");
}
} else if (keyboard->repeat_binding) {
keyboard->repeat_binding = NULL;
if (wl_event_source_timer_update(keyboard->key_repeat_source, 0) < 0) {
wlr_log(WLR_DEBUG, "failed to disarm key repeat timer");
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
}
run compositor bindings last
7 years ago
}
// Compositor bindings
binding release
7 years ago
if (!handled && event->state == WLR_KEY_PRESSED) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
handled = keyboard_execute_compositor_binding(
keyboard, translated_keysyms, translated_modifiers,
run compositor bindings last
7 years ago
translated_keysyms_len);
}
binding release
7 years ago
if (!handled && event->state == WLR_KEY_PRESSED) {
Rewrite shortcut handling code to avoid hardcoded values The same shortcut algorithm is now used for keycodes, raw keysyms, and translated keysyms. Pressed keysyms are now stored in association with the keycodes that generated them. Modifier keycodes (and associated keysyms) are identified retroactively by the subsequent change to the modifier flags.
7 years ago
handled = keyboard_execute_compositor_binding(
keyboard, raw_keysyms, raw_modifiers,
run compositor bindings last
7 years ago
raw_keysyms_len);
keyboard translate keysyms
7 years ago
}
binding release
7 years ago
if (!handled || event->state == WLR_KEY_RELEASED) {
keyboard translate keysyms
7 years ago
wlr_seat_set_keyboard(wlr_seat, wlr_device);
wlr_seat_keyboard_notify_key(wlr_seat, event->time_msec,
event->keycode, event->state);
}
Invoke mouse bindings The mouse binding logic is inspired/copied from the keyboard binding logic; we store a sorted list of the currently pressed buttons, and trigger a binding when the currently pressed (or just recently pressed, in the case of a release binding) buttons, as well as modifiers/container region, match those of a given binding. As the code to execute a binding is not very keyboard specific, keyboard_execute_command is renamed to seat_execute_command and moved to where the other binding handling functions are. The call to transaction_commit_dirty has been lifted out.
7 years ago
transaction_commit_dirty();
basic keyboard
7 years ago
}
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
static int handle_keyboard_repeat(void *data) {
struct sway_keyboard *keyboard = (struct sway_keyboard *)data;
Bindings use advised keyboard repeat parameters Now 'repeat_delay' and 'repeat_rate' control the initial delay and rate (per second) of repeated binding invocations. If the repeat delay is zero, binding repetition is disabled. When the repeat rate is zero, the binding is repeated exactly once, assuming no other key events intervene.
7 years ago
struct wlr_keyboard *wlr_device =
keyboard->seat_device->input_device->wlr_device->keyboard;
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
if (keyboard->repeat_binding) {
Bindings use advised keyboard repeat parameters Now 'repeat_delay' and 'repeat_rate' control the initial delay and rate (per second) of repeated binding invocations. If the repeat delay is zero, binding repetition is disabled. When the repeat rate is zero, the binding is repeated exactly once, assuming no other key events intervene.
7 years ago
if (wlr_device->repeat_info.rate > 0) {
// We queue the next event first, as the command might cancel it
if (wl_event_source_timer_update(keyboard->key_repeat_source,
1000 / wlr_device->repeat_info.rate) < 0) {
wlr_log(WLR_DEBUG, "failed to update key repeat timer");
}
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
}
seat_execute_command(keyboard->seat_device->sway_seat,
keyboard->repeat_binding);
transaction_commit_dirty();
}
return 0;
}
basic keyboard
7 years ago
static void handle_keyboard_modifiers(struct wl_listener *listener,
void *data) {
struct sway_keyboard *keyboard =
wl_container_of(listener, keyboard, keyboard_modifiers);
basic configuration
7 years ago
struct wlr_seat *wlr_seat = keyboard->seat_device->sway_seat->wlr_seat;
struct wlr_input_device *wlr_device =
keyboard->seat_device->input_device->wlr_device;
wlr_seat_set_keyboard(wlr_seat, wlr_device);
update for new wlr-keyboard modifiers
7 years ago
wlr_seat_keyboard_notify_modifiers(wlr_seat, &wlr_device->keyboard->modifiers);
basic keyboard
7 years ago
}
struct sway_keyboard *sway_keyboard_create(struct sway_seat *seat,
basic configuration
7 years ago
struct sway_seat_device *device) {
basic keyboard
7 years ago
struct sway_keyboard *keyboard =
calloc(1, sizeof(struct sway_keyboard));
if (!sway_assert(keyboard, "could not allocate sway keyboard")) {
return NULL;
}
basic configuration
7 years ago
keyboard->seat_device = device;
device->keyboard = keyboard;
basic keyboard
7 years ago
basic configuration
7 years ago
wl_list_init(&keyboard->keyboard_key.link);
wl_list_init(&keyboard->keyboard_modifiers.link);
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
keyboard->key_repeat_source = wl_event_loop_add_timer(server.wl_event_loop,
handle_keyboard_repeat, keyboard);
basic configuration
7 years ago
return keyboard;
}
void sway_keyboard_configure(struct sway_keyboard *keyboard) {
basic keyboard
7 years ago
struct xkb_rule_names rules;
memset(&rules, 0, sizeof(rules));
xkb config
7 years ago
struct input_config *input_config =
dont copy input config
7 years ago
input_device_get_config(keyboard->seat_device->input_device);
keyboard cleanup
7 years ago
struct wlr_input_device *wlr_device =
keyboard->seat_device->input_device->wlr_device;
xkb config
7 years ago
if (input_config && input_config->xkb_layout) {
rules.layout = input_config->xkb_layout;
} else {
rules.layout = getenv("XKB_DEFAULT_LAYOUT");
}
if (input_config && input_config->xkb_model) {
rules.model = input_config->xkb_model;
} else {
rules.model = getenv("XKB_DEFAULT_MODEL");
}
if (input_config && input_config->xkb_options) {
rules.options = input_config->xkb_options;
} else {
rules.options = getenv("XKB_DEFAULT_OPTIONS");
}
if (input_config && input_config->xkb_rules) {
rules.rules = input_config->xkb_rules;
} else {
rules.rules = getenv("XKB_DEFAULT_RULES");
}
if (input_config && input_config->xkb_variant) {
rules.variant = input_config->xkb_variant;
} else {
rules.variant = getenv("XKB_DEFAULT_VARIANT");
}
basic configuration
7 years ago
basic keyboard
7 years ago
struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!sway_assert(context, "cannot create XKB context")) {
basic configuration
7 years ago
return;
basic keyboard
7 years ago
}
handle keymap not found
7 years ago
struct xkb_keymap *keymap =
basic configuration
7 years ago
xkb_keymap_new_from_names(context, &rules, XKB_KEYMAP_COMPILE_NO_FLAGS);
handle keymap not found
7 years ago
if (!keymap) {
Update for swaywm/wlroots#1126
7 years ago
wlr_log(WLR_DEBUG, "cannot configure keyboard: keymap does not exist");
handle keymap not found
7 years ago
xkb_context_unref(context);
return;
}
xkb_keymap_unref(keyboard->keymap);
keyboard->keymap = keymap;
keyboard cleanup
7 years ago
wlr_keyboard_set_keymap(wlr_device->keyboard, keyboard->keymap);
handle keymap not found
7 years ago
Implement setting NumLock and CapsLock status After setting the keymap, try to enable NumLock and disable CapsLock. This only works if sway has the xkb master state and controls the keyboard. Prepare configuration settings for later use as well.
7 years ago
xkb_mod_mask_t locked_mods = 0;
Don't enable numlock by default. This fixes an annoying issue where laptop keyboards would have 'numlock mode' enabled, remapping parts of the alphabet to numbers.
7 years ago
if (input_config && input_config->xkb_numlock > 0) {
Implement setting NumLock and CapsLock status After setting the keymap, try to enable NumLock and disable CapsLock. This only works if sway has the xkb master state and controls the keyboard. Prepare configuration settings for later use as well.
7 years ago
xkb_mod_index_t mod_index = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_NUM);
if (mod_index != XKB_MOD_INVALID) {
locked_mods |= (uint32_t)1 << mod_index;
}
}
if (input_config && input_config->xkb_capslock > 0) {
xkb_mod_index_t mod_index = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
if (mod_index != XKB_MOD_INVALID) {
locked_mods |= (uint32_t)1 << mod_index;
}
}
if (locked_mods) {
wlr_keyboard_notify_modifiers(wlr_device->keyboard, 0, 0, locked_mods, 0);
Fix LEDs for configured modifier states
7 years ago
uint32_t leds = 0;
for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
if (xkb_state_led_index_is_active(wlr_device->keyboard->xkb_state,
wlr_device->keyboard->led_indexes[i])) {
leds |= (1 << i);
}
}
wlr_keyboard_led_update(wlr_device->keyboard, leds);
Implement setting NumLock and CapsLock status After setting the keymap, try to enable NumLock and disable CapsLock. This only works if sway has the xkb master state and controls the keyboard. Prepare configuration settings for later use as well.
7 years ago
}
Make key repeat configurable This creates two input commands for configuring the repeat delay and rate. Example config: input "myidentifier" { repeat_delay 250 repeat_rate 25 }
7 years ago
if (input_config && input_config->repeat_delay != INT_MIN
&& input_config->repeat_rate != INT_MIN) {
wlr_keyboard_set_repeat_info(wlr_device->keyboard,
input_config->repeat_rate, input_config->repeat_delay);
} else {
wlr_keyboard_set_repeat_info(wlr_device->keyboard, 25, 600);
}
basic keyboard
7 years ago
xkb_context_unref(context);
remove assumption of one device per identifier
7 years ago
struct wlr_seat *seat = keyboard->seat_device->sway_seat->wlr_seat;
wlr_seat_set_keyboard(seat, wlr_device);
basic keyboard
7 years ago
basic configuration
7 years ago
wl_list_remove(&keyboard->keyboard_key.link);
keyboard cleanup
7 years ago
wl_signal_add(&wlr_device->keyboard->events.key, &keyboard->keyboard_key);
basic keyboard
7 years ago
keyboard->keyboard_key.notify = handle_keyboard_key;
basic configuration
7 years ago
wl_list_remove(&keyboard->keyboard_modifiers.link);
keyboard cleanup
7 years ago
wl_signal_add( &wlr_device->keyboard->events.modifiers,
sway input device
7 years ago
&keyboard->keyboard_modifiers);
basic keyboard
7 years ago
keyboard->keyboard_modifiers.notify = handle_keyboard_modifiers;
}
keyboard remove
7 years ago
void sway_keyboard_destroy(struct sway_keyboard *keyboard) {
fix keyboard hotplugging
7 years ago
if (!keyboard) {
return;
}
keyboard: free xkb keymap on destroy
7 years ago
if (keyboard->keymap) {
xkb_keymap_unref(keyboard->keymap);
}
keyboard remove
7 years ago
wl_list_remove(&keyboard->keyboard_key.link);
wl_list_remove(&keyboard->keyboard_modifiers.link);
Implement key repeat for pressed key bindings Each sway_keyboard is provided with a wayland timer event source. When a valid keypress binding has been found, a callback to handle_keyboard_repeat is set. Any key event will either clear the callback or (if the new key event is a valid keypress binding) delay the callback again.
7 years ago
wl_event_source_remove(keyboard->key_repeat_source);
keyboard remove
7 years ago
free(keyboard);
}