jasmine/qmk_keymaps
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

spring clean

Browse source
This commit is contained in:
♥ Minnie ♥ 2023-08-15 07:39:18 +08:00
parent 0c241c31a8
commit bf8beb8166
10 changed files with 32 additions and 387 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
keyboards/crkbd/keymaps/sajenim/combos.def
View file

@ -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 : */

4
keyboards/crkbd/keymaps/sajenim/config.h
View file

@ -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

145
keyboards/crkbd/keymaps/sajenim/features/layer_lock.c
View file

@ -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
* <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;
}
__attribute__((weak)) void layer_lock_set_user(layer_state_t locked_layers) {}

136
keyboards/crkbd/keymaps/sajenim/features/layer_lock.h
View file

@ -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
* <https://getreuer.info/posts/keyboards/layer-lock>
*/
#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

61
keyboards/crkbd/keymaps/sajenim/keymap.c
View file

@ -17,26 +17,14 @@
#include QMK_KEYBOARD_H
#include <stdio.h>
#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);
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();
}

10
keyboards/crkbd/keymaps/sajenim/layers.h
View file

@ -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,
};

7
keyboards/crkbd/keymaps/sajenim/oled.c
View file

@ -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);
}

24
keyboards/crkbd/keymaps/sajenim/process_record.c
View file

@ -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;
};

12
keyboards/crkbd/keymaps/sajenim/process_record.h
View file

@ -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)

3
keyboards/crkbd/keymaps/sajenim/rules.mk
View file

@ -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)