From b863b29d8920eb87ecadea9376ff2f9f3c86fccc Mon Sep 17 00:00:00 2001 From: Joel Challis Date: Thu, 21 Nov 2024 13:02:49 +0000 Subject: [PATCH] Review fixes for layer lock feature (#24627) --- quantum/keyboard.c | 6 +-- quantum/layer_lock.c | 29 ++++++++++-- quantum/layer_lock.h | 45 ++---------------- quantum/process_keycode/process_layer_lock.c | 17 +------ quantum/process_keycode/process_layer_lock.h | 48 -------------------- quantum/quantum.c | 2 +- quantum/quantum.h | 2 +- 7 files changed, 35 insertions(+), 114 deletions(-) diff --git a/quantum/keyboard.c b/quantum/keyboard.c index 8db81a4b391b..d7836cf36e00 100644 --- a/quantum/keyboard.c +++ b/quantum/keyboard.c @@ -140,9 +140,9 @@ along with this program. If not, see . #ifdef OS_DETECTION_ENABLE # include "os_detection.h" #endif -#if defined(LAYER_LOCK_ENABLE) && LAYER_LOCK_IDLE_TIMEOUT > 0 +#ifdef LAYER_LOCK_ENABLE # include "layer_lock.h" -#endif // LAYER_LOCK_ENABLE +#endif static uint32_t last_input_modification_time = 0; uint32_t last_input_activity_time(void) { @@ -659,7 +659,7 @@ void quantum_task(void) { secure_task(); #endif -#if defined(LAYER_LOCK_ENABLE) && LAYER_LOCK_IDLE_TIMEOUT > 0 +#ifdef LAYER_LOCK_ENABLE layer_lock_task(); #endif } diff --git a/quantum/layer_lock.c b/quantum/layer_lock.c index 9ee3c307dcaa..9fc84bcfca18 100644 --- a/quantum/layer_lock.c +++ b/quantum/layer_lock.c @@ -23,12 +23,18 @@ layer_state_t locked_layers = 0; # if defined(LAYER_LOCK_IDLE_TIMEOUT) && LAYER_LOCK_IDLE_TIMEOUT > 0 uint32_t layer_lock_timer = 0; -void layer_lock_task(void) { +void layer_lock_timeout_task(void) { if (locked_layers && timer_elapsed32(layer_lock_timer) > LAYER_LOCK_IDLE_TIMEOUT) { layer_lock_all_off(); layer_lock_timer = timer_read32(); } } +void layer_lock_activity_trigger(void) { + layer_lock_timer = timer_read32(); +} +# else +void layer_lock_timeout_task(void) {} +void layer_lock_activity_trigger(void) {} # endif // LAYER_LOCK_IDLE_TIMEOUT > 0 bool is_layer_locked(uint8_t layer) { @@ -44,9 +50,7 @@ void layer_lock_invert(uint8_t layer) { } # endif // NO_ACTION_ONESHOT layer_on(layer); -# if defined(LAYER_LOCK_IDLE_TIMEOUT) && LAYER_LOCK_IDLE_TIMEOUT > 0 - layer_lock_timer = timer_read32(); -# endif // LAYER_LOCK_IDLE_TIMEOUT > 0 + layer_lock_activity_trigger(); } else { // Layer is being unlocked. layer_off(layer); } @@ -72,10 +76,25 @@ void layer_lock_all_off(void) { layer_lock_set_kb(locked_layers); } +#else // NO_ACTION_LAYER +bool is_layer_locked(uint8_t layer) { + return false; +} +void layer_lock_on(uint8_t layer) {} +void layer_lock_off(uint8_t layer) {} +void layer_lock_all_off(void) {} +void layer_lock_invert(uint8_t layer) {} +void layer_lock_timeout_task(void) {} +void layer_lock_activity_trigger(void) {} +#endif // NO_ACTION_LAYER + __attribute__((weak)) bool layer_lock_set_kb(layer_state_t locked_layers) { return layer_lock_set_user(locked_layers); } __attribute__((weak)) bool layer_lock_set_user(layer_state_t locked_layers) { return true; } -#endif // NO_ACTION_LAYER + +void layer_lock_task(void) { + layer_lock_timeout_task(); +} diff --git a/quantum/layer_lock.h b/quantum/layer_lock.h index 6d7285da2a61..97f6c60d70d1 100644 --- a/quantum/layer_lock.h +++ b/quantum/layer_lock.h @@ -49,13 +49,6 @@ * * #define LAYER_LOCK_IDLE_TIMEOUT 60000 // Turn off after 60 seconds. * - * and call `layer_lock_task()` from your `matrix_scan_user()` in keymap.c: - * - * void matrix_scan_user(void) { - * layer_lock_task(); - * // Other tasks... - * } - * * For full documentation, see * */ @@ -67,24 +60,6 @@ #include "action_layer.h" #include "action_util.h" -/** - * Handler function for Layer Lock. - * - * In your keymap, define a custom keycode to use for Layer Lock. Then handle - * Layer Lock from your `process_record_user` function by calling - * `process_layer_lock`, passing your custom keycode for the `lock_keycode` arg: - * - * #include "features/layer_lock.h" - * - * bool process_record_user(uint16_t keycode, keyrecord_t* record) { - * if (!process_layer_lock(keycode, record, LLOCK)) { return false; } - * // Your macros ... - * - * return true; - * } - */ - -#ifndef NO_ACTION_LAYER /** Returns true if `layer` is currently locked. */ bool is_layer_locked(uint8_t layer); @@ -116,20 +91,8 @@ void layer_lock_invert(uint8_t layer); bool layer_lock_set_kb(layer_state_t locked_layers); bool layer_lock_set_user(layer_state_t locked_layers); +/** Handle various background tasks */ void layer_lock_task(void); -#else // NO_ACTION_LAYER -static inline bool is_layer_locked(uint8_t layer) { - return false; -} -static inline void layer_lock_on(uint8_t layer) {} -static inline void layer_lock_off(uint8_t layer) {} -static inline void layer_lock_all_off(void) {} -static inline void layer_lock_invert(uint8_t layer) {} -static inline bool layer_lock_set_kb(layer_state_t locked_layers) { - return true; -} -static inline bool layer_lock_set_user(layer_state_t locked_layers) { - return true; -} -static inline void layer_lock_task(void) {} -#endif // NO_ACTION_LAYER + +/** Update any configured timeouts */ +void layer_lock_activity_trigger(void); diff --git a/quantum/process_keycode/process_layer_lock.c b/quantum/process_keycode/process_layer_lock.c index 1e36d8844e83..6946d3c8862f 100644 --- a/quantum/process_keycode/process_layer_lock.c +++ b/quantum/process_keycode/process_layer_lock.c @@ -12,14 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -/** - * @file layer_lock.c - * @brief Layer Lock implementation - * - * For full documentation, see - * - */ - #include "layer_lock.h" #include "process_layer_lock.h" #include "quantum_keycodes.h" @@ -27,12 +19,9 @@ // The current lock state. The kth bit is on if layer k is locked. extern layer_state_t locked_layers; -#if defined(LAYER_LOCK_IDLE_TIMEOUT) && LAYER_LOCK_IDLE_TIMEOUT > 0 -extern uint32_t layer_lock_timer; -#endif // Handles an event on an `MO` or `TT` layer switch key. -static bool handle_mo_or_tt(uint8_t layer, keyrecord_t* record) { +static inline bool handle_mo_or_tt(uint8_t layer, keyrecord_t* record) { if (is_layer_locked(layer)) { if (record->event.pressed) { // On press, unlock the layer. layer_lock_invert(layer); @@ -44,9 +33,7 @@ static bool handle_mo_or_tt(uint8_t layer, keyrecord_t* record) { bool process_layer_lock(uint16_t keycode, keyrecord_t* record) { #ifndef NO_ACTION_LAYER -# if defined(LAYER_LOCK_IDLE_TIMEOUT) && LAYER_LOCK_IDLE_TIMEOUT > 0 - layer_lock_timer = timer_read32(); -# endif // LAYER_LOCK_IDLE_TIMEOUT > 0 + layer_lock_activity_trigger(); // The intention is that locked layers remain on. If something outside of // this feature turned any locked layers off, unlock them. diff --git a/quantum/process_keycode/process_layer_lock.h b/quantum/process_keycode/process_layer_lock.h index b54c0f6f1062..6795110029a7 100644 --- a/quantum/process_keycode/process_layer_lock.h +++ b/quantum/process_keycode/process_layer_lock.h @@ -12,54 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -/** - * @file layer_lock.h - * @brief Layer Lock, a key to stay in the current layer. - * - * Overview - * -------- - * - * Layers are often accessed by holding a button, e.g. with a momentary layer - * switch `MO(layer)` or layer tap `LT(layer, key)` key. But you may sometimes - * want to "lock" or "toggle" the layer so that it stays on without having to - * hold down a button. One way to do that is with a tap-toggle `TT` layer key, - * but here is an alternative. - * - * This library implements a "Layer Lock key". When tapped, it "locks" the - * highest layer to stay active, assuming the layer was activated by one of the - * following keys: - * - * * `MO(layer)` momentary layer switch - * * `LT(layer, key)` layer tap - * * `OSL(layer)` one-shot layer - * * `TT(layer)` layer tap toggle - * * `LM(layer, mod)` layer-mod key (the layer is locked, but not the mods) - * - * Tapping the Layer Lock key again unlocks and turns off the layer. - * - * @note When a layer is "locked", other layer keys such as `TO(layer)` or - * manually calling `layer_off(layer)` will override and unlock the layer. - * - * Configuration - * ------------- - * - * Optionally, a timeout may be defined so that Layer Lock disables - * automatically if not keys are pressed for `LAYER_LOCK_IDLE_TIMEOUT` - * milliseconds. Define `LAYER_LOCK_IDLE_TIMEOUT` in your config.h, for instance - * - * #define LAYER_LOCK_IDLE_TIMEOUT 60000 // Turn off after 60 seconds. - * - * and call `layer_lock_task()` from your `matrix_scan_user()` in keymap.c: - * - * void matrix_scan_user(void) { - * layer_lock_task(); - * // Other tasks... - * } - * - * For full documentation, see - * - */ - #pragma once #include diff --git a/quantum/quantum.c b/quantum/quantum.c index 811ad2e71520..4aef26a6a56a 100644 --- a/quantum/quantum.c +++ b/quantum/quantum.c @@ -78,7 +78,7 @@ #ifdef LAYER_LOCK_ENABLE # include "process_layer_lock.h" -#endif // LAYER_LOCK_ENABLE +#endif #ifdef AUDIO_ENABLE # ifndef GOODBYE_SONG diff --git a/quantum/quantum.h b/quantum/quantum.h index 71cf900f2de0..9db88a54d4ba 100644 --- a/quantum/quantum.h +++ b/quantum/quantum.h @@ -242,7 +242,7 @@ extern layer_state_t layer_state; #ifdef LAYER_LOCK_ENABLE # include "layer_lock.h" -#endif // LAYER_LOCK_ENABLE +#endif void set_single_default_layer(uint8_t default_layer); void set_single_persistent_default_layer(uint8_t default_layer);