148 lines
4.5 KiB
C
148 lines
4.5 KiB
C
// 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.
|
|
|
|
/**
|
|
* @file layer_lock.c
|
|
* @brief Layer Lock implementation
|
|
*
|
|
* For full documentation, see
|
|
* <https://getreuer.info/posts/keyboards/layer-lock>
|
|
*/
|
|
|
|
#include "layer_lock.h"
|
|
|
|
// The current lock state. The kth bit is on if layer k is locked.
|
|
static layer_state_t locked_layers = 0;
|
|
|
|
// Layer Lock timer to disable layer lock after X seconds inactivity
|
|
#if LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
static uint32_t layer_lock_timer = 0;
|
|
|
|
void layer_lock_task(void) {
|
|
if (locked_layers &&
|
|
timer_elapsed32(layer_lock_timer) > LAYER_LOCK_IDLE_TIMEOUT) {
|
|
layer_lock_all_off();
|
|
layer_lock_timer = timer_read32();
|
|
}
|
|
}
|
|
#endif // LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
|
|
// Handles an event on an `MO` or `TT` layer switch key.
|
|
static 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);
|
|
}
|
|
return false; // Skip default handling.
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool process_layer_lock(uint16_t keycode, keyrecord_t* record,
|
|
uint16_t lock_keycode) {
|
|
#if LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
layer_lock_timer = timer_read32();
|
|
#endif // LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
|
|
// The intention is that locked layers remain on. If something outside of
|
|
// this feature turned any locked layers off, unlock them.
|
|
if ((locked_layers & ~layer_state) != 0) {
|
|
layer_lock_set_user(locked_layers &= layer_state);
|
|
}
|
|
|
|
if (keycode == lock_keycode) {
|
|
if (record->event.pressed) { // The layer lock key was pressed.
|
|
layer_lock_invert(get_highest_layer(layer_state));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
switch (keycode) {
|
|
case QK_MOMENTARY ... QK_MOMENTARY_MAX: // `MO(layer)` keys.
|
|
return handle_mo_or_tt(QK_MOMENTARY_GET_LAYER(keycode), record);
|
|
|
|
case QK_LAYER_TAP_TOGGLE ... QK_LAYER_TAP_TOGGLE_MAX: // `TT(layer)`.
|
|
return handle_mo_or_tt(QK_LAYER_TAP_TOGGLE_GET_LAYER(keycode), record);
|
|
|
|
case QK_LAYER_MOD ... QK_LAYER_MOD_MAX: { // `LM(layer, mod)`.
|
|
uint8_t layer = QK_LAYER_MOD_GET_LAYER(keycode);
|
|
if (is_layer_locked(layer)) {
|
|
if (record->event.pressed) { // On press, unlock the layer.
|
|
layer_lock_invert(layer);
|
|
} else { // On release, clear the mods.
|
|
clear_mods();
|
|
send_keyboard_report();
|
|
}
|
|
return false; // Skip default handling.
|
|
}
|
|
} break;
|
|
|
|
#ifndef NO_ACTION_TAPPING
|
|
case QK_LAYER_TAP ... QK_LAYER_TAP_MAX: // `LT(layer, key)` keys.
|
|
if (record->tap.count == 0 && !record->event.pressed &&
|
|
is_layer_locked(QK_LAYER_TAP_GET_LAYER(keycode))) {
|
|
// Release event on a held layer-tap key where the layer is locked.
|
|
return false; // Skip default handling so that layer stays on.
|
|
}
|
|
break;
|
|
#endif // NO_ACTION_TAPPING
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool is_layer_locked(uint8_t layer) {
|
|
return locked_layers & ((layer_state_t)1 << layer);
|
|
}
|
|
|
|
void layer_lock_invert(uint8_t layer) {
|
|
const layer_state_t mask = (layer_state_t)1 << layer;
|
|
if ((locked_layers & mask) == 0) { // Layer is being locked.
|
|
#ifndef NO_ACTION_ONESHOT
|
|
if (layer == get_oneshot_layer()) {
|
|
reset_oneshot_layer(); // Reset so that OSL doesn't turn layer off.
|
|
}
|
|
#endif // NO_ACTION_ONESHOT
|
|
layer_on(layer);
|
|
#if LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
layer_lock_timer = timer_read32();
|
|
#endif // LAYER_LOCK_IDLE_TIMEOUT > 0
|
|
} else { // Layer is being unlocked.
|
|
layer_off(layer);
|
|
}
|
|
layer_lock_set_user(locked_layers ^= mask);
|
|
}
|
|
|
|
// Implement layer_lock_on/off by deferring to layer_lock_invert.
|
|
void layer_lock_on(uint8_t layer) {
|
|
if (!is_layer_locked(layer)) {
|
|
layer_lock_invert(layer);
|
|
}
|
|
}
|
|
|
|
void layer_lock_off(uint8_t layer) {
|
|
if (is_layer_locked(layer)) {
|
|
layer_lock_invert(layer);
|
|
}
|
|
}
|
|
|
|
void layer_lock_all_off(void) {
|
|
layer_and(~locked_layers);
|
|
locked_layers = 0;
|
|
layer_lock_set_user(locked_layers);
|
|
}
|
|
|
|
__attribute__((weak)) void layer_lock_set_user(layer_state_t locked_layers) {}
|
|
|