diff options
Diffstat (limited to 'quantum/repeat_key.c')
| -rw-r--r-- | quantum/repeat_key.c | 282 | 
1 files changed, 282 insertions, 0 deletions
| diff --git a/quantum/repeat_key.c b/quantum/repeat_key.c new file mode 100644 index 0000000000..0689c6d454 --- /dev/null +++ b/quantum/repeat_key.c @@ -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 | 
