From bf8beb8166fec24a6cd2060ea7c39e31c12ec56c Mon Sep 17 00:00:00 2001 From: sajenim Date: Tue, 15 Aug 2023 07:39:18 +0800 Subject: [PATCH] spring clean --- keyboards/crkbd/keymaps/sajenim/combos.def | 15 +- keyboards/crkbd/keymaps/sajenim/config.h | 4 - .../keymaps/sajenim/features/layer_lock.c | 145 ------------------ .../keymaps/sajenim/features/layer_lock.h | 136 ---------------- keyboards/crkbd/keymaps/sajenim/keymap.c | 63 +++----- keyboards/crkbd/keymaps/sajenim/layers.h | 10 +- keyboards/crkbd/keymaps/sajenim/oled.c | 7 +- .../crkbd/keymaps/sajenim/process_record.c | 24 --- .../crkbd/keymaps/sajenim/process_record.h | 12 +- keyboards/crkbd/keymaps/sajenim/rules.mk | 3 +- 10 files changed, 32 insertions(+), 387 deletions(-) delete mode 100644 keyboards/crkbd/keymaps/sajenim/features/layer_lock.c delete mode 100644 keyboards/crkbd/keymaps/sajenim/features/layer_lock.h diff --git a/keyboards/crkbd/keymaps/sajenim/combos.def b/keyboards/crkbd/keymaps/sajenim/combos.def index ff9827e..ed41291 100644 --- a/keyboards/crkbd/keymaps/sajenim/combos.def +++ b/keyboards/crkbd/keymaps/sajenim/combos.def @@ -1,15 +1,10 @@ // name result chord keys -COMB(DF_GAME, GM_TOGG, KC_D, KC_F) -COMB(JK_ESC, KC_ESC, KC_J, KC_K) -COMB(DK_CAPS, CW_TOGG, KC_D, KC_K) +COMB(NE_ESC, KC_ESC, KC_N, KC_E) +COMB(SE_CAPS, CW_TOGG, KC_S, KC_E) // unix shell -SUBS(ER_HOME, "~/", KC_E, KC_R) -SUBS(UI_UPDIR, "../", KC_U, KC_I) - -// neovim -SUBS(VI_WRITE, ":w", KC_SCLN, KC_W ) -SUBS(VI_QUIT, ":q", KC_SCLN, KC_Q ) -SUBS(VI_WRITE_QUIT, ":wq", KC_SCLN, KC_W, KC_Q) +SUBS(YP_HOME, "~/", KC_Y, KC_P) +SUBS(FO_UPDIR, "../", KC_F, KC_O) /* vim: set filetype=c : */ + diff --git a/keyboards/crkbd/keymaps/sajenim/config.h b/keyboards/crkbd/keymaps/sajenim/config.h index 86c8b02..5a88838 100644 --- a/keyboards/crkbd/keymaps/sajenim/config.h +++ b/keyboards/crkbd/keymaps/sajenim/config.h @@ -22,12 +22,8 @@ // Caps Word #define CAPS_WORD_IDLE_TIMEOUT 2000 -// Layer Lock -#define LAYER_LOCK_IDLE_TIMEOUT 60000 - // Combos #define COMBO_TERM 50 -#define COMBO_ONLY_FROM_LAYER 0 // RGB #ifdef RGBLIGHT_ENABLE diff --git a/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c b/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c deleted file mode 100644 index a14ce3b..0000000 --- a/keyboards/crkbd/keymaps/sajenim/features/layer_lock.c +++ /dev/null @@ -1,145 +0,0 @@ -// 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 - * - */ - -#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; -} - -__attribute__((weak)) void layer_lock_set_user(layer_state_t locked_layers) {} diff --git a/keyboards/crkbd/keymaps/sajenim/features/layer_lock.h b/keyboards/crkbd/keymaps/sajenim/features/layer_lock.h deleted file mode 100644 index a0f1455..0000000 --- a/keyboards/crkbd/keymaps/sajenim/features/layer_lock.h +++ /dev/null @@ -1,136 +0,0 @@ -// 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.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 "quantum.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * 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; - * } - */ -bool process_layer_lock(uint16_t keycode, keyrecord_t* record, - uint16_t lock_keycode); - -/** Returns true if `layer` is currently locked. */ -bool is_layer_locked(uint8_t layer); - -/** Locks and turns on `layer`. */ -void layer_lock_on(uint8_t layer); - -/** Unlocks and turns off `layer`. */ -void layer_lock_off(uint8_t layer); - -/** Unlocks and turns off all locked layers. */ -void layer_lock_all_off(void); - -/** Toggles whether `layer` is locked. */ -void layer_lock_invert(uint8_t layer); - -/** - * Optional callback that gets called when a layer is locked or unlocked. - * - * This is useful to represent the current lock state, e.g. by setting an LED or - * playing a sound. In your keymap, define - * - * void layer_lock_set_user(layer_state_t locked_layers) { - * // Do something like `set_led(is_layer_locked(NAV));` - * } - * - * @param locked_layers Bitfield in which the kth bit represents whether the - * kth layer is on. - */ -void layer_lock_set_user(layer_state_t locked_layers); - -/** - * @fn layer_lock_task(void) - * Matrix task function for Layer Lock. - * - * If using `LAYER_LOCK_IDLE_TIMEOUT`, call this function from your - * `matrix_scan_user()` function in keymap.c. (If no timeout is set, calling - * `layer_lock_task()` has no effect.) - */ -#if LAYER_LOCK_IDLE_TIMEOUT > 0 -void layer_lock_task(void); -#else -static inline void layer_lock_task(void) {} -#endif // LAYER_LOCK_IDLE_TIMEOUT > 0 - -#ifdef __cplusplus -} -#endif diff --git a/keyboards/crkbd/keymaps/sajenim/keymap.c b/keyboards/crkbd/keymaps/sajenim/keymap.c index 44205b6..93f85b6 100644 --- a/keyboards/crkbd/keymaps/sajenim/keymap.c +++ b/keyboards/crkbd/keymaps/sajenim/keymap.c @@ -17,26 +17,14 @@ #include QMK_KEYBOARD_H #include #include "config.h" -#include "layers.h" #include "features/sentence_case.h" #include "process_record.h" #include "g/keymap_combo.h" +#include "layers.h" /* Keymaps */ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { - [L_QWERTY] = LAYOUT_split_3x6_3( - //,-----------------------------------------------------. ,-----------------------------------------------------. - QK_GESC, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, BSPC_DW, - //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - TABCTRL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, - //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - OS_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, OS_RSFT, - //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - GUI_EXT, BAK_LWR, SPC_EXT, ENT_SFT, DEL_RSE, ALT_EXT - //`--------------------------' `--------------------------' - ), - [L_CANARY] = LAYOUT_split_3x6_3( //,-----------------------------------------------------. ,-----------------------------------------------------. QK_GESC, KC_W, KC_L, KC_Y, KC_P, KC_B, KC_Z, KC_F, KC_O, KC_U, KC_QUOT, BSPC_DW, @@ -45,35 +33,23 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| OS_LSFT, KC_Q, KC_J, KC_V, KC_D, KC_K, KC_X, KC_H, KC_SLSH, KC_COMM, KC_DOT, OS_RSFT, //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - GUI_EXT, BAK_LWR, SPC_EXT, ENT_SFT, DEL_RSE, ALT_EXT - //`--------------------------' `--------------------------' - ), - - [L_EXTEND] = LAYOUT_split_3x6_3( - //,-----------------------------------------------------. ,-----------------------------------------------------. - _______, XXXXXXX, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PGUP, KC_HOME, KC_UP, KC_END, XXXXXXX, _______, - //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - _______, XXXXXXX, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, XXXXXXX, - //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - KC_5, KC_4, KC_3, KC_2, KC_1, KC_0, KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, - //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - XXXXXXX, XXXXXXX, XXXXXXX, _______, WZ_CMOD, WZ_PSTE + GUI_EXT, BAK_LWR, SPC_EXT, ENT_SFT, DEL_UPR, ALT_EXT //`--------------------------' `--------------------------' ), [L_LOWER] = LAYOUT_split_3x6_3( //,-----------------------------------------------------. ,-----------------------------------------------------. - KC_VOLU, KC_MNXT, KC_F7, KC_F8, KC_F9, KC_F10, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, _______, + XXXXXXX, KC_F9, KC_F10, KC_F11, KC_F12, XXXXXXX, KC_SLSH, KC_7, KC_8, KC_9, KC_MINS, XXXXXXX, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - KC_VOLD, KC_MPRV, KC_F4, KC_F5, KC_F6, KC_F11, KC_ASTR, KC_4, KC_5, KC_6, KC_PLUS, XXXXXXX, + XXXXXXX, KC_F5, KC_F6, KC_F7, KC_F8, XXXXXXX, KC_ASTR, KC_4, KC_5, KC_6, KC_PLUS, XXXXXXX, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - KC_MUTE, KC_MPLY, KC_F1, KC_F2, KC_F3, KC_F12, KC_0, KC_1, KC_2, KC_3, KC_DOT, XXXXXXX, + XXXXXXX, KC_F1, KC_F2, KC_F3, KC_F4, XXXXXXX, KC_0, KC_1, KC_2, KC_3, KC_DOT, XXXXXXX, //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - CK_LOCK, _______, XXXXXXX, _______, _______, XXXXXXX + XXXXXXX, _______, XXXXXXX, XXXXXXX, _______, XXXXXXX //`--------------------------' `--------------------------' ), - [L_RAISE] = LAYOUT_split_3x6_3( + [L_UPPER] = LAYOUT_split_3x6_3( //,-----------------------------------------------------. ,-----------------------------------------------------. XXXXXXX, XXXXXXX, KC_LABK, KC_DLR, KC_RABK, XXXXXXX, XXXXXXX, KC_LBRC, KC_UNDS, KC_RBRC, XXXXXXX, XXXXXXX, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| @@ -81,44 +57,42 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| XXXXXXX, XXXXXXX, KC_COLN, KC_ASTR, KC_PLUS, XXXXXXX, XXXXXXX, KC_AMPR, KC_CIRC, KC_TILD, XXXXXXX, XXXXXXX, //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - XXXXXXX, _______, XXXXXXX, XXXXXXX, _______, CK_LOCK + XXXXXXX, _______, XXXXXXX, XXXXXXX, _______, XXXXXXX //`--------------------------' `--------------------------' ), [L_ADJUST] = LAYOUT_split_3x6_3( //,-----------------------------------------------------. ,-----------------------------------------------------. - QK_BOOT, xQWERTY, xCANARY, XXXXXXX, XXXXXXX, AS_TOGG, SC_TOGG, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PWR, + QK_BOOT, AS_TOGG, AC_TOGG, CM_TOGG, SC_TOGG, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_PWR, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, XXXXXXX, AC_TOGG, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_SLEP, + XXXXXXX, RGB_TOG, RGB_HUI, RGB_SAI, RGB_VAI, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_SLEP, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD, XXXXXXX, CM_TOGG, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_WAKE, + XXXXXXX, RGB_MOD, RGB_HUD, RGB_SAD, RGB_VAD, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_WAKE, //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| XXXXXXX, _______, XXXXXXX, XXXXXXX, _______, XXXXXXX //`--------------------------' `--------------------------' ), - [L_GAMING] = LAYOUT_split_3x6_3( + [L_EXTEND] = LAYOUT_split_3x6_3( //,-----------------------------------------------------. ,-----------------------------------------------------. - KC_ESC, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_BSPC, + XXXXXXX, XXXXXXX, KC_HOME, KC_UP, KC_END, KC_PGUP, KC_PGUP, KC_HOME, KC_UP, KC_END, XXXXXXX, _______, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - KC_LCTL, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, + XXXXXXX, XXXXXXX, KC_LEFT, KC_DOWN, KC_RGHT, KC_PGDN, KC_PGDN, KC_LEFT, KC_DOWN, KC_RGHT, XXXXXXX, XXXXXXX, //|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| - KC_LSFT, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_RSFT, + KC_5, KC_4, KC_3, KC_2, KC_1, KC_0, KC_0, KC_1, KC_2, KC_3, KC_4, KC_5, //|--------+--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------+--------| - XXXXXXX, KC_BSPC, KC_SPC, KC_ENT, KC_DEL, XXXXXXX + XXXXXXX, XXXXXXX, XXXXXXX, _______, WZ_CMOD, WZ_PSTE //`--------------------------' `--------------------------' ), }; - /* Layer Change */ layer_state_t layer_state_set_user(layer_state_t state) { - state = update_tri_layer_state(state, L_LOWER, L_RAISE, L_ADJUST); - return state; + state = update_tri_layer_state(state, L_LOWER, L_UPPER, L_ADJUST); + return state; } - /* Post Init */ void keyboard_post_init_user(void) { @@ -127,3 +101,4 @@ void keyboard_post_init_user(void) { combo_disable(); sentence_case_off(); } + diff --git a/keyboards/crkbd/keymaps/sajenim/layers.h b/keyboards/crkbd/keymaps/sajenim/layers.h index 02d4f83..43ffd2d 100644 --- a/keyboards/crkbd/keymaps/sajenim/layers.h +++ b/keyboards/crkbd/keymaps/sajenim/layers.h @@ -1,12 +1,10 @@ -// Our layers +/* Layers */ + enum layers { - L_QWERTY, L_CANARY, - L_EXTEND, L_LOWER, - L_RAISE, + L_UPPER, L_ADJUST, - L_GAMING, - L_GAMEFN, + L_EXTEND, }; diff --git a/keyboards/crkbd/keymaps/sajenim/oled.c b/keyboards/crkbd/keymaps/sajenim/oled.c index a1eb4c7..a46350b 100644 --- a/keyboards/crkbd/keymaps/sajenim/oled.c +++ b/keyboards/crkbd/keymaps/sajenim/oled.c @@ -15,14 +15,13 @@ oled_rotation_t oled_init_user(oled_rotation_t rotation) { void oled_render_master(void) { // Layer Status switch (get_highest_layer(layer_state)) { - case L_QWERTY: case L_CANARY: oled_write(" BAS ", false); break; case L_LOWER: oled_write(" LWR ", false); break; - case L_RAISE: + case L_UPPER: oled_write(" RSE ", false); break; case L_ADJUST: @@ -31,10 +30,6 @@ void oled_render_master(void) { case L_EXTEND: oled_write(" EXT ", false); break; - case L_GAMING: - case L_GAMEFN: - oled_write(" GME ", false); - break; default: oled_write(" UND ", false); } diff --git a/keyboards/crkbd/keymaps/sajenim/process_record.c b/keyboards/crkbd/keymaps/sajenim/process_record.c index 6fa3bbd..7b2c285 100644 --- a/keyboards/crkbd/keymaps/sajenim/process_record.c +++ b/keyboards/crkbd/keymaps/sajenim/process_record.c @@ -1,11 +1,9 @@ #include "process_record.h" #include "layers.h" #include "oled.h" -#include "features/layer_lock.h" #include "features/sentence_case.h" bool process_record_user(uint16_t keycode, keyrecord_t *record) { - if (!process_layer_lock(keycode, record, CK_LOCK)) { return false; } if (!process_sentence_case(keycode, record)) { return false; } switch (keycode) { @@ -48,28 +46,6 @@ bool process_record_user(uint16_t keycode, keyrecord_t *record) { sentence_case_toggle(); } return false; - - /* KEYBOARD PET STATUS START */ - case TABCTRL: - case KC_LCTL: - case KC_RCTL: - if (record->event.pressed) { - isSneaking = true; - } else { - isSneaking = false; - } - break; - - case SPC_EXT: - case KC_SPC: - if (record->tap.count && record->event.pressed) { - isJumping = true; - showedJump = false; - } else { - isJumping = false; - } - break; - /* KEYBOARD PET STATUS END */ } return true; }; diff --git a/keyboards/crkbd/keymaps/sajenim/process_record.h b/keyboards/crkbd/keymaps/sajenim/process_record.h index 63372aa..4cd19da 100644 --- a/keyboards/crkbd/keymaps/sajenim/process_record.h +++ b/keyboards/crkbd/keymaps/sajenim/process_record.h @@ -4,8 +4,7 @@ // Our custom keycodes enum custom_keycodes { - CK_LOCK = SAFE_RANGE, - BSPC_DW, + BSPC_DW = SAFE_RANGE, SC_TOGG, }; @@ -16,7 +15,7 @@ enum custom_keycodes { // Right-hand thumb key layers #define ENT_SFT MT(MOD_LSFT, KC_ENT) -#define DEL_RSE LT(L_RAISE, KC_DEL) +#define DEL_UPR LT(L_UPPER, KC_DEL) #define ALT_EXT LT(L_EXTEND, KC_LALT) // One Shot Keys @@ -30,18 +29,11 @@ enum custom_keycodes { #define OS_RALT OSM(MOD_RALT) #define OS_RGUI OSM(MOD_RGUI) -// Default Layers -#define xQWERTY DF(L_QWERTY) -#define xCANARY DF(L_CANARY) - // Shortcuts #define WZ_CMOD LCTL(LSFT(KC_X)) #define WZ_COPY LCTL(LSFT(KC_C)) #define WZ_PSTE LCTL(LSFT(KC_V)) -// Gaming -#define GM_TOGG TG(L_GAMING) - // Misc #define TABCTRL MT(MOD_LCTL, KC_TAB) #define BSPC_DW MT(MOD_LCTL, KC_BSPC) diff --git a/keyboards/crkbd/keymaps/sajenim/rules.mk b/keyboards/crkbd/keymaps/sajenim/rules.mk index abef87c..f4a8393 100644 --- a/keyboards/crkbd/keymaps/sajenim/rules.mk +++ b/keyboards/crkbd/keymaps/sajenim/rules.mk @@ -8,14 +8,13 @@ LTO_ENABLE = yes # Optional features OLED_ENABLE = yes RGBLIGHT_ENABLE = yes -COMBO_ENABLE = yes # Toggleable through keymap AUTO_SHIFT_ENABLE = yes AUTOCORRECT_ENABLE = yes CAPS_WORD_ENABLE = yes +COMBO_ENABLE = yes SRC += process_record.c -SRC += features/layer_lock.c SRC += features/sentence_case.c ifeq ($(OLED_ENABLE),yes)