[Core] Add Repeat Key ("repeat last key") as a core feature. (#19700)
Co-authored-by: casuanoob <96005765+casuanoob@users.noreply.github.com> Co-authored-by: Sergey Vlasov <sigprof@gmail.com>
This commit is contained in:
parent
e1766df185
commit
3993b15f05
29 changed files with 2508 additions and 6 deletions
282
quantum/repeat_key.c
Normal file
282
quantum/repeat_key.c
Normal file
|
@ -0,0 +1,282 @@
|
|||
// Copyright 2022-2023 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "repeat_key.h"
|
||||
|
||||
// Variables saving the state of the last key press.
|
||||
static keyrecord_t last_record = {0};
|
||||
static uint8_t last_mods = 0;
|
||||
// Signed count of the number of times the last key has been repeated or
|
||||
// alternate repeated: it is 0 when a key is pressed normally, positive when
|
||||
// repeated, and negative when alternate repeated.
|
||||
static int8_t last_repeat_count = 0;
|
||||
// The repeat_count, but set to 0 outside of repeat_key_invoke() so that it is
|
||||
// nonzero only while a repeated key is being processed.
|
||||
static int8_t processing_repeat_count = 0;
|
||||
|
||||
uint16_t get_last_keycode(void) {
|
||||
return last_record.keycode;
|
||||
}
|
||||
|
||||
uint8_t get_last_mods(void) {
|
||||
return last_mods;
|
||||
}
|
||||
|
||||
void set_last_keycode(uint16_t keycode) {
|
||||
set_last_record(keycode, &(keyrecord_t){
|
||||
#ifndef NO_ACTION_TAPPING
|
||||
.tap.interrupted = false,
|
||||
.tap.count = 1,
|
||||
#endif
|
||||
});
|
||||
}
|
||||
|
||||
void set_last_mods(uint8_t mods) {
|
||||
last_mods = mods;
|
||||
}
|
||||
|
||||
void set_last_record(uint16_t keycode, keyrecord_t* record) {
|
||||
last_record = *record;
|
||||
last_record.keycode = keycode;
|
||||
last_repeat_count = 0;
|
||||
}
|
||||
|
||||
/** @brief Updates `last_repeat_count` in direction `dir`. */
|
||||
static void update_last_repeat_count(int8_t dir) {
|
||||
if (dir * last_repeat_count < 0) {
|
||||
last_repeat_count = dir;
|
||||
} else if (dir * last_repeat_count < 127) {
|
||||
last_repeat_count += dir;
|
||||
}
|
||||
}
|
||||
|
||||
int8_t get_repeat_key_count(void) {
|
||||
return processing_repeat_count;
|
||||
}
|
||||
|
||||
void repeat_key_invoke(const keyevent_t* event) {
|
||||
// It is possible (e.g. in rolled presses) that the last key changes while
|
||||
// the Repeat Key is pressed. To prevent stuck keys, it is important to
|
||||
// remember separately what key record was processed on press so that the
|
||||
// the corresponding record is generated on release.
|
||||
static keyrecord_t registered_record = {0};
|
||||
static int8_t registered_repeat_count = 0;
|
||||
// Since this function calls process_record(), it may recursively call
|
||||
// itself. We return early if `processing_repeat_count` is nonzero to
|
||||
// prevent infinite recursion.
|
||||
if (processing_repeat_count || !last_record.keycode) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (event->pressed) {
|
||||
update_last_repeat_count(1);
|
||||
// On press, apply the last mods state, stacking on top of current mods.
|
||||
register_weak_mods(last_mods);
|
||||
registered_record = last_record;
|
||||
registered_repeat_count = last_repeat_count;
|
||||
}
|
||||
|
||||
// Generate a keyrecord and plumb it into the event pipeline.
|
||||
registered_record.event = *event;
|
||||
processing_repeat_count = registered_repeat_count;
|
||||
process_record(®istered_record);
|
||||
processing_repeat_count = 0;
|
||||
|
||||
// On release, restore the mods state.
|
||||
if (!event->pressed) {
|
||||
unregister_weak_mods(last_mods);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef NO_ALT_REPEAT_KEY
|
||||
/**
|
||||
* @brief Find alternate keycode from a table of opposing keycode pairs.
|
||||
* @param table Array of pairs of basic keycodes, declared as PROGMEM.
|
||||
* @param table_size_bytes The size of the table in bytes.
|
||||
* @param target The basic keycode to find.
|
||||
* @return The alternate basic keycode, or KC_NO if none was found.
|
||||
*
|
||||
* @note The table keycodes and target must be basic keycodes.
|
||||
*
|
||||
* This helper is used several times below to define alternate keys. Given a
|
||||
* table of pairs of basic keycodes, the function finds the pair containing
|
||||
* `target` and returns the other keycode in the pair.
|
||||
*/
|
||||
static uint8_t find_alt_keycode(const uint8_t (*table)[2], uint8_t table_size_bytes, uint8_t target) {
|
||||
const uint8_t* keycodes = (const uint8_t*)table;
|
||||
for (uint8_t i = 0; i < table_size_bytes; ++i) {
|
||||
if (target == pgm_read_byte(keycodes + i)) {
|
||||
// Xor (i ^ 1) the index to get the other element in the pair.
|
||||
return pgm_read_byte(keycodes + (i ^ 1));
|
||||
}
|
||||
}
|
||||
return KC_NO;
|
||||
}
|
||||
|
||||
uint16_t get_alt_repeat_key_keycode(void) {
|
||||
uint16_t keycode = last_record.keycode;
|
||||
uint8_t mods = last_mods;
|
||||
|
||||
// Call the user callback first to give it a chance to override the default
|
||||
// alternate key definitions that follow.
|
||||
uint16_t alt_keycode = get_alt_repeat_key_keycode_user(keycode, mods);
|
||||
|
||||
if (alt_keycode != KC_TRANSPARENT) {
|
||||
return alt_keycode;
|
||||
}
|
||||
|
||||
// Convert 8-bit mods to the 5-bit format used in keycodes. This is lossy:
|
||||
// if left and right handed mods were mixed, they all become right handed.
|
||||
mods = ((mods & 0xf0) ? /* set right hand bit */ 0x10 : 0)
|
||||
// Combine right and left hand mods.
|
||||
| (((mods >> 4) | mods) & 0xf);
|
||||
|
||||
switch (keycode) {
|
||||
case QK_MODS ... QK_MODS_MAX: // Unpack modifier + basic key.
|
||||
mods |= QK_MODS_GET_MODS(keycode);
|
||||
keycode = QK_MODS_GET_BASIC_KEYCODE(keycode);
|
||||
break;
|
||||
|
||||
# ifndef NO_ACTION_TAPPING
|
||||
case QK_MOD_TAP ... QK_MOD_TAP_MAX:
|
||||
keycode = QK_MOD_TAP_GET_TAP_KEYCODE(keycode);
|
||||
break;
|
||||
# ifndef NO_ACTION_LAYER
|
||||
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX:
|
||||
keycode = QK_LAYER_TAP_GET_TAP_KEYCODE(keycode);
|
||||
break;
|
||||
# endif // NO_ACTION_LAYER
|
||||
# endif // NO_ACTION_TAPPING
|
||||
|
||||
# ifdef SWAP_HANDS_ENABLE
|
||||
case QK_SWAP_HANDS ... QK_SWAP_HANDS_MAX:
|
||||
if (IS_SWAP_HANDS_KEYCODE(keycode)) {
|
||||
return KC_NO;
|
||||
}
|
||||
keycode = QK_SWAP_HANDS_GET_TAP_KEYCODE(keycode);
|
||||
break;
|
||||
# endif // SWAP_HANDS_ENABLE
|
||||
}
|
||||
|
||||
if (IS_QK_BASIC(keycode)) {
|
||||
if ((mods & (MOD_LCTL | MOD_LALT | MOD_LGUI))) {
|
||||
// The last key was pressed with a modifier other than Shift.
|
||||
// The following maps
|
||||
// mod + F <-> mod + B
|
||||
// and a few others, supporting several core hotkeys used in
|
||||
// Emacs, Vim, less, and other programs.
|
||||
// clang-format off
|
||||
static const uint8_t pairs[][2] PROGMEM = {
|
||||
{KC_F , KC_B }, // Forward / Backward.
|
||||
{KC_D , KC_U }, // Down / Up.
|
||||
{KC_N , KC_P }, // Next / Previous.
|
||||
{KC_A , KC_E }, // Home / End.
|
||||
{KC_O , KC_I }, // Older / Newer in Vim jump list.
|
||||
};
|
||||
// clang-format on
|
||||
alt_keycode = find_alt_keycode(pairs, sizeof(pairs), keycode);
|
||||
} else {
|
||||
// The last key was pressed with no mods or only Shift. The
|
||||
// following map a few more Vim hotkeys.
|
||||
// clang-format off
|
||||
static const uint8_t pairs[][2] PROGMEM = {
|
||||
{KC_J , KC_K }, // Down / Up.
|
||||
{KC_H , KC_L }, // Left / Right.
|
||||
// These two lines map W and E to B, and B to W.
|
||||
{KC_W , KC_B }, // Forward / Backward by word.
|
||||
{KC_E , KC_B }, // Forward / Backward by word.
|
||||
};
|
||||
// clang-format on
|
||||
alt_keycode = find_alt_keycode(pairs, sizeof(pairs), keycode);
|
||||
}
|
||||
|
||||
if (!alt_keycode) {
|
||||
// The following key pairs are considered with any mods.
|
||||
// clang-format off
|
||||
static const uint8_t pairs[][2] PROGMEM = {
|
||||
{KC_LEFT, KC_RGHT}, // Left / Right Arrow.
|
||||
{KC_UP , KC_DOWN}, // Up / Down Arrow.
|
||||
{KC_HOME, KC_END }, // Home / End.
|
||||
{KC_PGUP, KC_PGDN}, // Page Up / Page Down.
|
||||
{KC_BSPC, KC_DEL }, // Backspace / Delete.
|
||||
{KC_LBRC, KC_RBRC}, // Brackets [ ] and { }.
|
||||
#ifdef EXTRAKEY_ENABLE
|
||||
{KC_WBAK, KC_WFWD}, // Browser Back / Forward.
|
||||
{KC_MNXT, KC_MPRV}, // Next / Previous Media Track.
|
||||
{KC_MFFD, KC_MRWD}, // Fast Forward / Rewind Media.
|
||||
{KC_VOLU, KC_VOLD}, // Volume Up / Down.
|
||||
{KC_BRIU, KC_BRID}, // Brightness Up / Down.
|
||||
#endif // EXTRAKEY_ENABLE
|
||||
#ifdef MOUSEKEY_ENABLE
|
||||
{KC_MS_L, KC_MS_R}, // Mouse Cursor Left / Right.
|
||||
{KC_MS_U, KC_MS_D}, // Mouse Cursor Up / Down.
|
||||
{KC_WH_L, KC_WH_R}, // Mouse Wheel Left / Right.
|
||||
{KC_WH_U, KC_WH_D}, // Mouse Wheel Up / Down.
|
||||
#endif // MOUSEKEY_ENABLE
|
||||
};
|
||||
// clang-format on
|
||||
alt_keycode = find_alt_keycode(pairs, sizeof(pairs), keycode);
|
||||
}
|
||||
|
||||
if (alt_keycode) {
|
||||
// Combine basic keycode with mods.
|
||||
return (mods << 8) | alt_keycode;
|
||||
}
|
||||
}
|
||||
|
||||
return KC_NO; // No alternate key found.
|
||||
}
|
||||
|
||||
void alt_repeat_key_invoke(const keyevent_t* event) {
|
||||
static keyrecord_t registered_record = {0};
|
||||
static int8_t registered_repeat_count = 0;
|
||||
// Since this function calls process_record(), it may recursively call
|
||||
// itself. We return early if `processing_repeat_count` is nonzero to
|
||||
// prevent infinite recursion.
|
||||
if (processing_repeat_count) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (event->pressed) {
|
||||
registered_record = (keyrecord_t){
|
||||
# ifndef NO_ACTION_TAPPING
|
||||
.tap.interrupted = false,
|
||||
.tap.count = 0,
|
||||
# endif
|
||||
.keycode = get_alt_repeat_key_keycode(),
|
||||
};
|
||||
}
|
||||
|
||||
// Early return if there is no alternate key defined.
|
||||
if (!registered_record.keycode) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (event->pressed) {
|
||||
update_last_repeat_count(-1);
|
||||
registered_repeat_count = last_repeat_count;
|
||||
}
|
||||
|
||||
// Generate a keyrecord and plumb it into the event pipeline.
|
||||
registered_record.event = *event;
|
||||
processing_repeat_count = registered_repeat_count;
|
||||
process_record(®istered_record);
|
||||
processing_repeat_count = 0;
|
||||
}
|
||||
|
||||
// Default implementation of get_alt_repeat_key_keycode_user().
|
||||
__attribute__((weak)) uint16_t get_alt_repeat_key_keycode_user(uint16_t keycode, uint8_t mods) {
|
||||
return KC_TRANSPARENT;
|
||||
}
|
||||
#endif // NO_ALT_REPEAT_KEY
|
Loading…
Add table
Add a link
Reference in a new issue